/*
* Copyright (c) 2007 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 related to traces
*
*/
package com.nokia.tracebuilder.engine.utils;

import java.util.Iterator;

import com.nokia.tracebuilder.engine.TraceBuilderConfiguration;
import com.nokia.tracebuilder.engine.TraceBuilderGlobals;
import com.nokia.tracebuilder.engine.source.SourceEngine;
import com.nokia.tracebuilder.model.Trace;
import com.nokia.tracebuilder.model.TraceBuilderException;
import com.nokia.tracebuilder.plugin.TraceFormatConstants;
import com.nokia.tracebuilder.source.SourceContext;

/**
 * Utility functions related to traces
 * 
 */
public final class TraceUtils {

	/**
	 * Default name format
	 */
	private static final String DEFAULT_NAME_FORMAT = "{$CN}_{$FN}"; //$NON-NLS-1$

	/**
	 * Default trace format
	 */
	private static final String DEFAULT_TRACE_FORMAT = "{$cn}::{$fn}"; //$NON-NLS-1$

	/**
	 * Underscore character
	 */
	private static final String UNDERSCORE = "_"; //$NON-NLS-1$

	/**
	 * Underscore character
	 */
	private static final char UNDERSCORE_CHAR = '_';

	/**
	 * Cannot be constructed
	 */
	private TraceUtils() {
	}

	/**
	 * Gets the default trace name format
	 * 
	 * @return the default trace name format
	 */
	public static String getDefaultNameFormat() {
		return DEFAULT_NAME_FORMAT;
	}

	/**
	 * Gets the default trace text format
	 * 
	 * @return the default trace text format
	 */
	public static String getDefaultTraceFormat() {
		return DEFAULT_TRACE_FORMAT;
	}

	/**
	 * Formats a trace
	 * 
	 * @param format
	 *            the format specification
	 * @param cname
	 *            the class name
	 * @param fname
	 *            the function name
	 * @return the formatted trace
	 */
	public static String formatTrace(String format, String cname, String fname) {
		StringBuffer sb = new StringBuffer(format);
		int cnindex = sb
				.indexOf(TraceFormatConstants.FORMAT_CLASS_NAME_NORMAL_CASE);
		if (cnindex >= 0) {
			if (cname != null) {
				sb.replace(cnindex, cnindex
						+ TraceFormatConstants.FORMAT_CLASS_NAME_NORMAL_CASE
								.length(), cname);
			} else {
				sb.replace(cnindex, cnindex
						+ TraceFormatConstants.FORMAT_CLASS_NAME_NORMAL_CASE
								.length(), ""); //$NON-NLS-1$
			}
		}
		int cnup = sb
				.indexOf(TraceFormatConstants.FORMAT_CLASS_NAME_UPPER_CASE);
		if (cnup >= 0) {
			if (cname != null) {
				sb.replace(cnup, cnup
						+ TraceFormatConstants.FORMAT_CLASS_NAME_UPPER_CASE
								.length(), cname.toUpperCase());
			} else {
				sb.replace(cnup, cnup
						+ TraceFormatConstants.FORMAT_CLASS_NAME_UPPER_CASE
								.length(), ""); //$NON-NLS-1$
			}
		}
		int fnindex = sb
				.indexOf(TraceFormatConstants.FORMAT_FUNCTION_NAME_NORMAL_CASE);
		if (fnindex >= 0) {
			sb.replace(fnindex, fnindex
					+ TraceFormatConstants.FORMAT_FUNCTION_NAME_NORMAL_CASE
							.length(), fname);
		}
		int fnup = sb
				.indexOf(TraceFormatConstants.FORMAT_FUNCTION_NAME_UPPER_CASE);
		if (fnup >= 0) {
			sb.replace(fnup, fnup
					+ TraceFormatConstants.FORMAT_FUNCTION_NAME_UPPER_CASE
							.length(), fname.toUpperCase());
		}
		return sb.toString();
	}

	/**
	 * Replaces invalid characters with '_'
	 * 
	 * @param name
	 *            name to be converted
	 * @return the converted name
	 */
	public static String convertName(String name) {
		StringBuffer sb;
		if (name.length() > 0) {
			boolean underscore = false;
			sb = new StringBuffer(name);
			if (Character.isDigit(name.charAt(0))) {
				sb.insert(0, UNDERSCORE_CHAR);
			}
			for (int i = 0; i < sb.length(); i++) {
				char c = sb.charAt(i);
				if (!Character.isLetterOrDigit(c)) {
					if (!underscore) {
						sb.setCharAt(i, UNDERSCORE_CHAR);
						underscore = true;
					} else {
						sb.deleteCharAt(i);
						i--;
					}
				} else {
					underscore = false;
				}
			}
			if (sb.length() > 0) {
				if (sb.charAt(sb.length() - 1) == UNDERSCORE_CHAR) {
					sb.deleteCharAt(sb.length() - 1);
				}
			} else {
				sb.append(UNDERSCORE);
			}
		} else {
			sb = new StringBuffer();
		}
		// If parameter value is NULL, it would be used as name
		String s = sb.toString();
		if (s.equals("NULL")) { //$NON-NLS-1$
			s = "_NULL"; //$NON-NLS-1$
		}
		return s;
	}

	/**
	 * Creates copies of the trace if it has TraceMultiplierRule extensions
	 * 
	 * @param trace
	 *            the trace to be multiplied
	 * @param insertLocation
	 *            the location where the original trace was inserted
	 * @param sourceEngine
	 *            the source engine
	 */
	public static void multiplyTrace(Trace trace, int insertLocation,
			SourceEngine sourceEngine) {
		// If multiplier rules have been added to the trace, they are
		// used to create copies of the trace
		TraceMultiplierRule multiplier;
		trace.getModel().startProcessing();
		try {
			// Trace may contain multiple multipliers. This loop gets one,
			// removes it and stops when there are no more multipliers
			do {
				multiplier = trace.getExtension(TraceMultiplierRule.class);
				if (multiplier != null) {
					processMultiplier(trace, multiplier, insertLocation,
							sourceEngine);
					// Multiplier extension is removed after use
					trace.removeExtension(multiplier);
				}
			} while (multiplier != null);
		} finally {
			trace.getModel().processingComplete();
		}
	}

	/**
	 * Processes a trace multiplier
	 * 
	 * @param trace
	 *            the trace
	 * @param multiplier
	 *            the multiplier
	 * @param insertLocation
	 *            the location where the original trace was inserted
	 * @param sourceEngine
	 *            the source engine
	 */
	private static void processMultiplier(Trace trace,
			TraceMultiplierRule multiplier, int insertLocation,
			SourceEngine sourceEngine) {
		Iterator<Trace> itr = multiplier.createCopies(trace);
		while (itr.hasNext()) {
			Trace copy = itr.next();
			addMultipliedTrace(copy, insertLocation, sourceEngine);
		}
	}

	/**
	 * Adds a trace that has been created by a multiplier rule. The trace is
	 * inserted to the same location as the original trace.
	 * 
	 * @param trace
	 *            the trace to be added
	 * @param insertLocation
	 *            the location where the original trace was inserted
	 * @param sourceEngine
	 *            the source engine
	 */
	private static void addMultipliedTrace(Trace trace, int insertLocation,
			SourceEngine sourceEngine) {
		try {
			// If location is specified, the trace is inserted into it
			if (insertLocation != -1) {
				SourceContext context = TraceBuilderGlobals
						.getSourceContextManager().getContext();
				if (insertLocation >= context.getOffset()
						&& insertLocation < context.getOffset()
								+ context.getLength()) {
					sourceEngine.insertTrace(trace, sourceEngine
							.getSourceOfContext(context), insertLocation);
				} else {
					if (TraceBuilderConfiguration.ASSERTIONS_ENABLED) {
						TraceBuilderGlobals.getEvents().postAssertionFailed(
								"Out of context insert", trace); //$NON-NLS-1$
					}
				}
			}
		} catch (TraceBuilderException e) {
			TraceBuilderGlobals.getEvents().postError(e);
		}
	}

}