/*
 * Copyright (c) 2010 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:
 *
 * Formatting rules are provided by Trace objects
 *
 */
package com.nokia.tracecompiler.engine.source;

import java.util.Iterator;

import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
import com.nokia.tracecompiler.engine.rules.StateTraceRule;
import com.nokia.tracecompiler.model.Trace;
import com.nokia.tracecompiler.model.TraceParameter;
import com.nokia.tracecompiler.plugin.TraceFormatConstants;
import com.nokia.tracecompiler.plugin.TraceAPIFormatter.TraceFormatType;
import com.nokia.tracecompiler.source.SourceConstants;
import com.nokia.tracecompiler.source.SourceUtils;
import com.nokia.tracecompiler.source.SymbianConstants;

/**
 * Static functions for source formatting
 * 
 */
public class SourceFormatter {

	/**
	 * Value parameter name
	 */
	public static final String VALUE_PARAMETER_NAME = "value"; //$NON-NLS-1$	

	/**
	 * Event start trace id parameter name
	 */
	public static final String EVENT_START_TRACE_ID_PARAMETER_NAME = "linkToStart"; //$NON-NLS-1$		

	/**
	 * Constructor is hidden
	 */
	private SourceFormatter() {
	}

	/**
	 * Formats a trace to string format using the formatting rule from the trace
	 * 
	 * @param trace
	 *            the trace
	 * @param formatType
	 *            the type of format
	 * @return the trace string
	 */
	public static String formatTrace(Trace trace, TraceFormatType formatType) {
		return formatTrace(trace, null, formatType, null, false);
	}

	/**
	 * Formats a trace to string format
	 * 
	 * @param trace
	 *            the trace
	 * @param traceRule
	 *            the formatting rule to be used
	 * @param formatType
	 *            the type of format
	 * @param tags
	 *            the tags for parameters or null if parameter names are used
	 * @param fixedTags
	 *            true if the <i>tags</i> iterator is fixed, false if the
	 *            contents of <i>tags</i> should go through
	 *            <code>SourceRule.mapNameToSource</code>
	 * @return the trace string
	 */
	static String formatTrace(Trace trace, TraceFormattingRule traceRule,
			TraceFormatType formatType, Iterator<String> tags, boolean fixedTags) {
		StringBuffer data = new StringBuffer();
		String format = null;
		if (traceRule == null) {

			// If rule is not explicitly provided, it is fetched from the trace
			traceRule = trace.getExtension(TraceFormattingRule.class);
			if (traceRule == null) {

				// If trace does not have a formatting rule, the project API's
				// should implement default rule
				traceRule = trace.getModel().getExtension(
						TraceFormattingRule.class);
			}
		}
		if (traceRule != null) {
			format = traceRule.getFormat(trace, formatType);
		}
		if (format != null && traceRule != null) {
			data.append(format);
			data.append(SourceConstants.LINE_FEED);
			buildParameterList(trace, traceRule, data, formatType, tags,
					fixedTags);

			String traceName = traceRule.mapNameToSource(trace);
			String traceGroupName = trace.getGroup().getName();

			// %NAME% is replaced with rule-mapped trace name
			replaceData(data, traceName, TraceFormatConstants.NAME_FORMAT);

			// %GROUP% is replaced with group name
			replaceData(data, traceGroupName, TraceFormatConstants.GROUP_FORMAT);

			// %TEXT% is replaced with trace text
			replaceData(data, "\"" + trace.getTrace() //$NON-NLS-1$
					+ "\"", TraceFormatConstants.TEXT_FORMAT); //$NON-NLS-1$

			// %FORMATTED_TRACE% is replaced with trace data
			replaceData(data, trace.getTrace(),
					TraceFormatConstants.FORMATTED_TRACE);

			// Comment is inserted before the trace
			int index = data.indexOf(TraceFormatConstants.COMMENT_FORMAT);
			if (index >= 0) {
				String comment = data.substring(index + 1);
				data.delete(index, data.length());
				data.insert(0, comment);
				data.append(SourceConstants.LINE_FEED);
			}
		}

		// If trace does not have formatting, it is not shown in source
		return data.toString();
	}

	/**
	 * Adds the parameters to the data buffer
	 * 
	 * @param trace
	 *            the trace
	 * @param format
	 *            the formatter from trace
	 * @param data
	 *            the data buffer where the formatted data is stored
	 * @param formatType
	 *            the format type to be applied
	 * @param tags
	 *            the tags for parameters or null if parameter names are used
	 * @param fixedTags
	 *            true if the <i>tags</i> iterator is fixed, false if the
	 *            contents of <i>tags</i> should go through
	 *            <code>SourceRule.mapNameToSource</code>
	 */
	private static void buildParameterList(Trace trace,
			TraceFormattingRule format, StringBuffer data,
			TraceFormatType formatType, Iterator<String> tags, boolean fixedTags) {

		int count = trace.getParameterCount();

		Iterator<TraceParameter> itr = trace.getParameters();
		StringBuffer paramList = new StringBuffer();
		// Index is incremented by one for each parameter that has been added to
		// source
		int parameterIndex = 0;
		while (itr.hasNext()) {
			TraceParameter param = itr.next();
			TraceParameterFormattingRule rule = param
					.getExtension(TraceParameterFormattingRule.class);
			String name;
			// Count and name may be adjusted by rules provided by parameters
			if (rule != null) {
				boolean isInSource = rule.isShownInSource();
				// If the parameter iterator is explicitly provided, the
				// parameter name is fetched from it. If the parameter list does
				// not have enough tags (for example when a new parameter is
				// added to trace) the name of the parameter is used. The source
				// rule is used to map the parameter name to correct format
				if (isInSource) {
					name = getTagWithoutMapping(tags, param);
					addParameter(paramList, param, name, ++parameterIndex,
							formatType);
				} else {
					// If the parameter is not shown in source, it is skipped
					count--;
				}
			} else {
				// If the parameter is not associated with a source rule, it is
				// added without mapping
				name = getTagWithoutMapping(tags, param);
				addParameter(paramList, param, name, ++parameterIndex,
						formatType);
			}
		}
		// %PC% is replaced with adjusted parameter count
		// In case of packed trace, the header engine does the count mapping
		if (formatType != TraceFormatType.TRACE_PACKED) {
			String val = format.mapParameterCountToSource(trace, count);

			if (trace.getExtension(StateTraceRule.class) != null
					&& data.toString().startsWith("OstTraceState")) { //$NON-NLS-1$

				// In case of State Trace macro value in trace macro is
				// parameter count - 2
				if (count > 1) {
					val = String.valueOf(count - 2); // CodForChk_Dis_Magic
				} else {
					val = String.valueOf(count);
				}
			}
			replaceData(data, val, TraceFormatConstants.PARAM_COUNT_FORMAT);
		}
		// %PARAMETERS% is replaced with parameter names
		replaceData(data, paramList.toString(),
				TraceFormatConstants.PARAMETERS_FORMAT);
	}

	/**
	 * Gets the name for a parameter without source rule mapping. If the tags
	 * iterator contains a valid entry, the name is fetched from it. If not, the
	 * parameter name is used instead.
	 * 
	 * @param tags
	 *            the list of tags
	 * @param param
	 *            the parameter
	 * @return the parameter name
	 */
	private static String getTagWithoutMapping(Iterator<String> tags,
			TraceParameter param) {
		String name;
		// If the parameter iterator is explicitly provided, the
		// parameter name is fetched from it
		if (tags != null && tags.hasNext()) {
			name = tags.next();
			// The list may contain 0-length items to represent
			// that that parameter name should be used instead
			if (name == null || name.length() == 0) {
				name = param.getName();
			}
		} else {
			name = param.getName();
		}
		return name;
	}

	/**
	 * Adds a parameter to the parameter list
	 * 
	 * @param paramList
	 *            the parameter list
	 * @param param
	 *            the parameter to be added
	 * @param name
	 *            a name replacement for the parameter
	 * @param parameterIndex
	 *            the index of the parameter
	 * @param formatType
	 *            the type of the format
	 */
	private static void addParameter(StringBuffer paramList,
			TraceParameter param, String name, int parameterIndex,
			TraceFormatType formatType) {
		paramList.append(SourceConstants.PARAMETER_SEPARATOR);
		if (formatType == TraceFormatType.HEADER) {
			paramList.append(SourceUtils.mapParameterTypeToSymbianType(param));
			paramList.append(SourceConstants.SPACE_CHAR);
			paramList.append(SymbianConstants.PARAMETER_DECLARATION_PREFIX);
			paramList.append(parameterIndex);
		} else if (formatType == TraceFormatType.EMPTY_MACRO) {
			paramList.append(SymbianConstants.PARAMETER_DECLARATION_PREFIX);
			paramList.append(parameterIndex);
		}
	}

	/**
	 * Replaces data from the stringbuffer
	 * 
	 * @param data
	 *            the data
	 * @param replaceData
	 *            the data to be used
	 * @param replaceFormat
	 *            the format to be replaced
	 */
	private static void replaceData(StringBuffer data, String replaceData,
			String replaceFormat) {
		TraceCompilerEngineGlobals.getEvents().postInfoMessage(Messages.getString("SourceFormatter.replaceAllBeginText") + replaceFormat + Messages.getString("SourceFormatter.replaceAllMiddleText") + replaceData , null); //$NON-NLS-1$ //$NON-NLS-2$

		int replaceOffset = 0;
		do {
			replaceOffset = data.indexOf(replaceFormat, replaceOffset);
			if (replaceOffset >= 0) {
				data.replace(replaceOffset, replaceOffset
						+ replaceFormat.length(), replaceData);
				replaceOffset += replaceData.length();
			}
		} while (replaceOffset != -1);
	}

}