/*
 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 
 * All rights reserved.
 * This component and the accompanying materials are made available
 * under the terms of "Eclipse Public License v1.0"
 * which accompanies this distribution, and is available
 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
 *
 * Initial Contributors:
 * Nokia Corporation - initial contribution.
 *
 * Contributors:
 *
 * Description:
 *
 * Utility functions for rules package
 *
 */
package com.nokia.tracecompiler.engine.rules;

import java.util.Iterator;
import java.util.List;

import com.nokia.tracecompiler.engine.TraceCompilerEngineConfiguration;
import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
import com.nokia.tracecompiler.model.Trace;
import com.nokia.tracecompiler.model.TraceCompilerException;
import com.nokia.tracecompiler.model.TraceConstantTable;
import com.nokia.tracecompiler.model.TraceModel;
import com.nokia.tracecompiler.model.TraceModelExtension;
import com.nokia.tracecompiler.model.TraceObjectUtils;
import com.nokia.tracecompiler.model.TraceParameter;
import com.nokia.tracecompiler.source.ParsedType;
import com.nokia.tracecompiler.source.SourceContext;
import com.nokia.tracecompiler.source.SourceParserException;
import com.nokia.tracecompiler.source.SourceReturn;
import com.nokia.tracecompiler.source.TypeMapping;

/**
 * Utility functions for rules package
 * 
 */
public final class RuleUtils {

	/**
	 * Entry-exit template
	 */
	public static final int TYPE_ENTRY_EXIT = 0; // CodForChk_Dis_Magic

	/**
	 * Start-stop event template
	 */
	public static final int TYPE_PERF_EVENT = 1; // CodForChk_Dis_Magic

	/**
	 * State trace template
	 */
	public static final int TYPE_STATE_TRACE = 2; // CodForChk_Dis_Magic

	/**
	 * Trace name format base
	 */
	static final String NAME_FORMAT_BASE = "{$CN}_{$FN}"; //$NON-NLS-1$

	/**
	 * Trace text format base
	 */
	static final String TEXT_FORMAT_BASE = "{$cn}::{$fn}"; //$NON-NLS-1$

	/**
	 * Template titles
	 */
	private static final String[] ENTRY_TEMPLATE_TITLES = {
			Messages.getString("RuleUtils.FunctionEntryTitle"), //$NON-NLS-1$
			Messages.getString("RuleUtils.PerformanceEventTitle"), //$NON-NLS-1$
			Messages.getString("RuleUtils.StateTraceTitle"), //$NON-NLS-1$
	};

	/**
	 * Entry name prefixes
	 */
	public static final String[] ENTRY_NAME_PREFIXES = { "", //$NON-NLS-1$
			"EVENT_", //$NON-NLS-1$
			"STATE_" //$NON-NLS-1$
	};

	/**
	 * Entry name suffixes
	 */
	public static final String[] ENTRY_NAME_SUFFIXES = { "_ENTRY", //$NON-NLS-1$
			"_START", //$NON-NLS-1$
			"" //$NON-NLS-1$
	};

	/**
	 * Exit name prefixes
	 */
	private static final String[] EXIT_NAME_PREFIXES = { "", //$NON-NLS-1$
			"EVENT_", //$NON-NLS-1$
			"" //$NON-NLS-1$
	};

	/**
	 * Exit name suffixes
	 */
	public static final String[] EXIT_NAME_SUFFIXES = { "_EXIT", //$NON-NLS-1$
			"_STOP", //$NON-NLS-1$
			"" //$NON-NLS-1$
	};

	/**
	 * Gets an entry template title
	 * 
	 * @param type
	 *            the template type
	 * @return the template title
	 */
	static String getEntryTemplateTitle(int type) {
		return ENTRY_TEMPLATE_TITLES[type];
	}

	/**
	 * Creates exit name from entry name
	 * 
	 * @param entryName
	 *            the entry name
	 * @param type
	 *            the type of entry
	 * @return the exit name
	 */
	static String createExitName(String entryName, int type) {
		// Strips the duplicate modifier from the name
		entryName = TraceObjectUtils.removeDuplicateModifier(entryName);
		StringBuffer sb = new StringBuffer();
		if (entryName.startsWith(ENTRY_NAME_PREFIXES[type])) {
			entryName = entryName.substring(ENTRY_NAME_PREFIXES[type].length());
		}
		if (entryName.endsWith(ENTRY_NAME_SUFFIXES[type])) {
			entryName = entryName.substring(0, entryName.length()
					- ENTRY_NAME_SUFFIXES[type].length());
		}
		sb.append(EXIT_NAME_PREFIXES[type]);
		sb.append(entryName);
		sb.append(EXIT_NAME_SUFFIXES[type]);
		return sb.toString();
	}

	/**
	 * Creates an entry trace name format from type
	 * 
	 * @param type
	 *            the trace format type
	 * @return the trace name format
	 */
	public static String createEntryTraceNameFormat(int type) {
		StringBuffer sb = new StringBuffer();
		if (type == TYPE_PERF_EVENT || type == TYPE_STATE_TRACE) {
			sb.append(NAME_FORMAT_BASE);
		} else {
			sb.append(ENTRY_NAME_PREFIXES[type]);
			sb.append(NAME_FORMAT_BASE);
			sb.append(ENTRY_NAME_SUFFIXES[type]);
		}
		return sb.toString();
	}

	/**
	 * Creates an exit trace name format based on type
	 * 
	 * @param type
	 *            the format type
	 * @return the trace name format
	 */
	public static String createExitTraceNameFormat(int type) {
		StringBuffer sb = new StringBuffer();
		sb.append(EXIT_NAME_PREFIXES[type]);
		sb.append(NAME_FORMAT_BASE);
		sb.append(EXIT_NAME_SUFFIXES[type]);
		return sb.toString();
	}

	/**
	 * Gets the return statements from current context from the context manager.
	 * 
	 * @param returnStatements
	 *            the list where the return statements are stored
	 */
	static void getCurrentContextReturns(List<SourceReturn> returnStatements) {
		SourceContext context = TraceCompilerEngineGlobals.getSourceContextManager()
				.getContext();
		if (context != null) {
			try {
				context.parseReturnValues(returnStatements);
			} catch (SourceParserException e) {
				String msg = Messages
						.getString("RuleUtils.FailedToParseReturnValues"); //$NON-NLS-1$
				String cname = context.getClassName();
				String source;
				if (cname != null) {
					source = cname + "::" + context.getFunctionName(); //$NON-NLS-1$;
				} else {
					source = context.getFunctionName();
				}
				TraceCompilerEngineGlobals.getEvents().postErrorMessage(msg, source,
						true);
			}
		} else {
			if (TraceCompilerEngineConfiguration.ASSERTIONS_ENABLED) {
				TraceCompilerEngineGlobals.getEvents().postAssertionFailed(
						"Function return not in function", null); //$NON-NLS-1$
			}
		}
	}

	/**
	 * Checks if the function is static. Currently this is just dummy, checking
	 * that the class name exists and the function name is not New / NewL /
	 * NewLC
	 * 
	 * @param context
	 *            the context to be checked
	 * @return true if static, false if not
	 */
	static boolean isStaticFunction(SourceContext context) {
		boolean retval;
		if (context.getClassName() == null) {
			retval = true;
		} else {
			String fname = context.getFunctionName();
			if (fname.equals("New") //$NON-NLS-1$
					|| fname.equals("NewL") //$NON-NLS-1$
					|| fname.equals("NewLC") //$NON-NLS-1$
			) {
				retval = true;
			} else {
				retval = false;
			}
		}
		return retval;
	}

	/**
	 * Locates a constant table based on type definition parsed from source
	 * 
	 * @param model
	 *            the trace model
	 * @param type
	 *            the parameter type
	 * @return the constant table or null if not found
	 */
	static TraceConstantTable findConstantTableByType(TraceModel model,
			ParsedType type) {
		Iterator<TraceConstantTable> tables = model.getConstantTables();
		TraceConstantTable foundTable = null;
		while (tables.hasNext() && foundTable == null) {
			TraceConstantTable table = tables.next();
			if (type.typeEquals(table.getName())) {
				foundTable = table;
			}
		}
		return foundTable;
	}

	/**
	 * Creates a parameter based on TypeMapping definition
	 * 
	 * @param owner
	 *            the parameter owner
	 * @param name
	 *            the parameter name
	 * @param type
	 *            the type mapping
	 * @return the parameter
	 * @throws TraceCompilerException
	 *             if parameter cannot be created
	 */
	static TraceParameter createParameterFromType(Trace owner, String name,
			TypeMapping type) throws TraceCompilerException {
		int id = owner.getNextParameterID();
		owner.getModel().getVerifier().checkTraceParameterProperties(owner,
				null, id, name, type.type);
		TraceModelExtension[] extensions = null;
		if (type.needsCasting || type.valueToPointer
				|| type.type.equals(TraceParameter.TIME)) {
			extensions = new TraceModelExtension[1];
			extensions[0] = new ParameterTypeMappingRule(type);
		}
		TraceParameter parameter = owner.getModel().getFactory()
				.createTraceParameter(owner, id, name, type.type, extensions);
		return parameter;
	}

	/**
	 * Creates a parameter object from constant table
	 * 
	 * @param owner
	 *            the parameter owner
	 * @param name
	 *            the name for the parameter
	 * @param table
	 *            the constant table
	 * @return the parameter
	 * @throws TraceCompilerException
	 *             if parameter cannot be created
	 */
	static TraceParameter createParameterFromConstantTable(Trace owner,
			String name, TraceConstantTable table) throws TraceCompilerException {
		int id = owner.getNextParameterID();
		owner.getModel().getVerifier().checkTraceParameterProperties(owner,
				null, id, name, table.getType());
		// Constant tables need a cast to constant table type
		TypeMapping type = new TypeMapping(table.getType());
		type.needsCasting = true;
		TraceModelExtension[] extensions = new TraceModelExtension[1];
		extensions[0] = new ParameterTypeMappingRule(type);
		return owner.getModel().getFactory().createTraceParameter(owner, id,
				name, table.getName(), extensions);
	}

}