/*

 * Copyright (c) 2007-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:

 *

 * Trace Dictionary Decoder

 *

 */

package com.nokia.trace.dictionary.decoder;

import java.nio.ByteBuffer;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import com.nokia.trace.dictionary.model.DictionaryDecodeModel;

import com.nokia.trace.dictionary.model.Location;

import com.nokia.trace.dictionary.model.Trace;

import com.nokia.trace.dictionary.model.TraceComponent;

import com.nokia.trace.dictionary.model.TraceData;

import com.nokia.trace.dictionary.model.TraceGroup;

import com.nokia.trace.dictionary.model.decodeparameters.DecodeParameter;

/**

 * Trace Dictionary Decoder

 * 

 */

public final class TraceDictionaryDecoder {

	/**

	 * Estimated trace size

	 */

	private static final int ESTIMATED_TRACE_SIZE = 70;

	/**

	 * Separator between class and function

	 */

	private static final String CLASS_FUNCTION_SEPARATOR = "::"; //$NON-NLS-1$

	/**

	 * Separator after function name

	 */

	private static final String AFTER_FUNCTION_SEPARATOR = ": "; //$NON-NLS-1$

	/**

	 * Model to use for decoding

	 */

	private DictionaryDecodeModel model;

	/**

	 * Previous trace used when getting metadata so that trace is only need to

	 * be get once

	 */

	private Trace previousMetaTrace;

	/**

	 * Constructor

	 * 

	 * @param model

	 *            dictionary model

	 */

	public TraceDictionaryDecoder(DictionaryDecodeModel model) {

		this.model = model;

	}

	/**

	 * Decodes the contents of a trace

	 * 

	 * @param dataBuffer

	 *            buffer containing data

	 * @param dataStart

	 *            data start offset

	 * @param dataLength

	 *            data length

	 * @param componentId

	 *            component ID of the trace

	 * @param groupId

	 *            group ID of the trace

	 * @param traceId

	 *            trace ID

	 * @param showClassPrefixes

	 *            if true, add class and function name to the trace text if they

	 *            exist

	 * @param showComponentGroupPrefixes

	 *            if true, add component and group name to the trace text if

	 *            they exist

	 * @param parameterList

	 *            parameter list where to add each parameters separately when

	 *            decoding

	 * @return decoded trace string buffer

	 */

	public StringBuffer decode(ByteBuffer dataBuffer, int dataStart,

			int dataLength, int componentId, int groupId, int traceId,

			boolean showClassPrefixes, boolean showComponentGroupPrefixes,

			ArrayList<String> parameterList) {

		// Get trace

		Trace trace = getTrace(componentId, groupId, traceId);

		// Create variables

		StringBuffer buf = null;

		ArrayList<DecodeParameter> parameters = null;

		TraceData traceData = null;

		// Get trace data

		if (trace != null) {

			traceData = trace.getTraceData();

			// Get trace parameters

			if (traceData != null) {

				parameters = traceData.getDecodeParameters();

				// Check if the trace only contains one variable and tell it to

				// the decoders

				if (traceData.containsOnlyOneVariable()) {

					DecodeParameter.isOnlyVariableInTrace = true;

				} else {

					DecodeParameter.isOnlyVariableInTrace = false;

				}

			}

		}

		// Decode the trace to the StringBuffer

		if (parameters != null && trace != null) {

			buf = new StringBuffer(ESTIMATED_TRACE_SIZE);

			// Create parameter list if it doesn't exist so the decode

			// parameters doesn't have to make a null check

			if (parameterList == null) {

				parameterList = new ArrayList<String>();

			}

			// Insert prefixes

			TraceGroup group = trace.getGroup();

			insertPrefixes(buf, trace, group, showClassPrefixes,

					showComponentGroupPrefixes);

			// Decode all parameters

			Iterator<DecodeParameter> it = parameters.iterator();

			int offset = dataStart;

			while (it.hasNext()) {

				DecodeParameter par = it.next();

				offset = par.decode(dataBuffer, offset, buf, dataStart,

						dataLength, parameterList);

			}

			// Insert suffixes

			insertSuffixes(buf, group);

		}

		return buf;

	}

	/**

	 * Inserts prefixes

	 * 

	 * @param buf

	 *            trace buffer

	 * @param trace

	 *            trace

	 * @param group

	 *            trace group

	 * @param showClassPrefixes

	 *            if true, add class and function name to the trace text if they

	 *            exist

	 * @param showComponentGroupPrefixes

	 *            if true, add component and group name to the trace text if

	 *            they exist

	 */

	private void insertPrefixes(StringBuffer buf, Trace trace,

			TraceGroup group, boolean showClassPrefixes,

			boolean showComponentGroupPrefixes) {

		if (showComponentGroupPrefixes) {

			if (group.getComponent().getPrefix() != null) {

				buf.append(group.getComponent().getPrefix());

			}

			if (group.getPrefix() != null) {

				buf.append(group.getPrefix());

			}

		}

		if (showClassPrefixes && trace.getClassName() != null

				&& trace.getMethodName() != null) {

			buf.append(trace.getClassName());

			buf.append(CLASS_FUNCTION_SEPARATOR);

			buf.append(trace.getMethodName());

			buf.append(AFTER_FUNCTION_SEPARATOR);

		}

	}

	/**

	 * Insert suffixes

	 * 

	 * @param buf

	 *            trace buffer

	 * @param group

	 *            trace group

	 */

	private void insertSuffixes(StringBuffer buf, TraceGroup group) {

		if (group.getSuffix() != null) {

			buf.append(group.getSuffix());

		}

		if (group.getComponent().getSuffix() != null) {

			buf.append(group.getComponent().getSuffix());

		}

	}

	/**

	 * Gets trace with component, group and trace IDs

	 * 

	 * @param componentId

	 *            component Id

	 * @param groupId

	 *            group Id

	 * @param traceId

	 *            trace Id

	 * @return Trace

	 */

	private Trace getTrace(int componentId, int groupId, int traceId) {

		TraceGroup group = null;

		Trace trace = null;

		// Get component

		TraceComponent comp = model.getComponent(componentId);

		// Get group

		if (comp != null) {

			group = comp.getGroup(groupId);

			// Get trace

			if (group != null) {

				trace = group.getTrace(traceId);

			}

		}

		return trace;

	}

	/**

	 * Sets previous trace where to get data from. Must be set before calling

	 * decode or getMetaData functions

	 * 

	 * @param componentId

	 *            component Id

	 * @param groupId

	 *            group Id

	 * @param traceId

	 *            trace Id

	 */

	public void setTraceWhereToGetMetaData(int componentId, int groupId,

			int traceId) {

		previousMetaTrace = getTrace(componentId, groupId, traceId);

	}

	/**

	 * Gets location

	 * 

	 * @return location

	 */

	public Location getLocation() {

		Location location = null;

		if (previousMetaTrace != null) {

			location = previousMetaTrace.getLocation();

		}

		return location;

	}

	/**

	 * Gets line number

	 * 

	 * @return line number

	 */

	public int getLineNumber() {

		int lineNum = 0;

		if (previousMetaTrace != null) {

			lineNum = previousMetaTrace.getLineNumber();

		}

		return lineNum;

	}

	/**

	 * Gets class name

	 * 

	 * @return class name

	 */

	public String getClassName() {

		String className = null;

		if (previousMetaTrace != null) {

			className = previousMetaTrace.getClassName();

		}

		return className;

	}

	/**

	 * Gets method name

	 * 

	 * @return method name

	 */

	public String getMethodName() {

		String methodName = null;

		if (previousMetaTrace != null) {

			methodName = previousMetaTrace.getMethodName();

		}

		return methodName;

	}

	/**

	 * Gets metadata map

	 * 

	 * @return metadata map

	 */

	public HashMap<String, HashMap<String, Object>> getMetadata() {

		HashMap<String, HashMap<String, Object>> metadata = null;

		// Create a new metadata map if trace has some metadata

		if (previousMetaTrace != null

				&& (previousMetaTrace.getMetadata() != null

						|| previousMetaTrace.getGroup().getMetadata() != null || previousMetaTrace

						.getGroup().getComponent().getMetadata() != null)) {

			TraceGroup group = previousMetaTrace.getGroup();

			metadata = new HashMap<String, HashMap<String, Object>>();

			// Add trace metadata

			if (previousMetaTrace.getMetadata() != null) {

				addMissingMetadataToList(previousMetaTrace.getMetadata(),

						metadata);

			}

			// Add group metadata

			if (group.getMetadata() != null) {

				addMissingMetadataToList(group.getMetadata(), metadata);

			}

			// Add component metadata

			if (group.getComponent().getMetadata() != null) {

				addMissingMetadataToList(group.getComponent().getMetadata(),

						metadata);

			}

		}

		return metadata;

	}

	/**

	 * Adds missing metadata to list

	 * 

	 * @param oldList

	 *            old list to append from

	 * @param newList

	 *            new list to append to

	 */

	private void addMissingMetadataToList(

			HashMap<String, HashMap<String, Object>> oldList,

			HashMap<String, HashMap<String, Object>> newList) {

		Iterator<String> it = oldList.keySet().iterator();

		while (it.hasNext()) {

			String key = it.next();

			// Doesn't contain this key, add it

			if (!newList.containsKey(key)) {

				newList.put(key, oldList.get(key));

				// Contains the key, check values inside

			} else {

				Iterator<String> valueIt = oldList.get(key).keySet().iterator();

				while (valueIt.hasNext()) {

					String valueKey = valueIt.next();

					// Doesn't contain value key, add it

					if (!newList.get(key).containsKey(valueKey)) {

						newList.get(key).put(valueKey,

								newList.get(key).get(valueKey));

					}

				}

			}

		}

	}

}