/*

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

*

* Writer for dictionary file

*

*/

package com.nokia.tracecompiler.decodeplugins.dictionary;

import java.io.File;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.DataType;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.Dictionary;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.LocationStore;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.TraceComponent;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.TraceDataStore;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.TraceDictionaryEncoder;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.TypeDef;

import com.nokia.tracecompiler.decodeplugins.dictionary.encoder.TypeDefStore;

import com.nokia.tracecompiler.engine.LocationListBase;

import com.nokia.tracecompiler.engine.LocationProperties;

import com.nokia.tracecompiler.file.FileUtils;

import com.nokia.tracecompiler.model.Trace;

import com.nokia.tracecompiler.model.TraceConstantTable;

import com.nokia.tracecompiler.model.TraceConstantTableEntry;

import com.nokia.tracecompiler.model.TraceGroup;

import com.nokia.tracecompiler.model.TraceModel;

import com.nokia.tracecompiler.model.TraceObjectUtils;

import com.nokia.tracecompiler.model.TraceParameter;

import com.nokia.tracecompiler.project.FormattingUtils;

import com.nokia.tracecompiler.project.PropertyNames;

import com.nokia.tracecompiler.project.TraceProjectAPI;

import com.nokia.tracecompiler.project.TraceProjectAPI.TraceFormatFlags;

import com.nokia.tracecompiler.rules.FillerParameterRule;

import com.nokia.tracecompiler.rules.HiddenTraceObjectRule;

import com.nokia.tracecompiler.source.SourceConstants;

import com.nokia.tracecompiler.source.SourceUtils;

/**

 * Writer for dictionary file

 * 

 */

final class DictionaryFileWriter {

	/**

	 * Comparator for file references

	 */

	private final class FileRefComparator implements

			Comparator<DictionaryFileRef> {

		public int compare(DictionaryFileRef o1, DictionaryFileRef o2) {

			int val = o1.path.compareTo(o2.path);

			if (val == 0) {

				val = o1.file.compareTo(o2.file);

			}

			return val;

		}

	}

	/**

	 * Dictionary file

	 */

	private DictionaryFile dictionaryFile;

	/**

	 * Sequential number for trace definitions

	 */

	private int defref;

	/**

	 * Sequential number for file definitions

	 */

	private int fileref;

	/**

	 * Constructor

	 * 

	 * @param dictionaryFile

	 *            the dictionary file

	 */

	DictionaryFileWriter(DictionaryFile dictionaryFile) {

		this.dictionaryFile = dictionaryFile;

	}

	/**

	 * Writes the dictionary file

	 */

	void write() {

		defref = 0;

		fileref = 0;

		File file = new File(dictionaryFile.getAbsolutePathWithID());

		// Delete removes possible read-only flags

		if (file.exists()) {

			file.delete();

		}

		TraceDictionaryEncoder encoder = new TraceDictionaryEncoder();

		File path = file.getParentFile();

		if (!path.exists()) {

			FileUtils.createDirectories(path);

		}

		encoder.createNewDictionary(file.getAbsolutePath());

		Dictionary.startDictionary();

		createTypedefs();

		createDefs();

		createLocations();

		createComponent();

		Dictionary.endDictionary();

	}

	/**

	 * Creates the type definitions

	 */

	private void createTypedefs() {

		TypeDefStore.startTypeDefs();

		ArrayList<String> typeList = buildTypeList();

		writeTypeDefinitions(typeList);

		TypeDefStore.endTypeDefs();

	}

	/**

	 * Builds the list of parameter types

	 * 

	 * @return the list of types found from the model

	 */

	private ArrayList<String> buildTypeList() {

		TraceModel model = dictionaryFile.getOwner().getModel();

		ArrayList<String> typeList = new ArrayList<String>();

		for (TraceGroup group : model) {

			for (Trace trace : group) {

				for (TraceParameter parameter : trace) {

					if ((parameter.getExtension(HiddenTraceObjectRule.class) == null)

							|| (parameter

									.getExtension(FillerParameterRule.class) != null)) {

						String type = parameter.getType();

						if (!typeList.contains(type)) {

							typeList.add(type);

						}

					}

				}

			}

		}

		return typeList;

	}

	/**

	 * Writes the data type definitions

	 * 

	 * @param typeList

	 *            the list of data types

	 */

	private void writeTypeDefinitions(ArrayList<String> typeList) {

		for (String type : typeList) {

			DataType dt = mapTypeToDataType(type);

			if (dt != null) {

				// Normal parameters

				int size = mapParameterTypeToSize(type);

				String formatChar = SourceUtils.mapNormalTypeToFormat(type);

				if (formatChar != null && formatChar.length() > 1

						&& formatChar.charAt(0) == '%') {

					formatChar = formatChar.substring(1);

					TypeDefStore.writeTypeDef(type, size, formatChar, dt);

					// Write alternative format characters

					writeAlternativeFormatChars(formatChar, type, size, dt);

				} else {

					TypeDefStore.writeTypeDef(type, size, null, dt);

				}

			} else {

				// Enum parameters

				TraceModel model = dictionaryFile.getOwner().getModel();

				TraceConstantTable table = model.findConstantTableByName(type);

				if (table != null) {

					TypeDefStore.startTypeDef(table.getName(),

							mapParameterTypeToSize(table.getType()), null,

							DataType.ENUM);

					for (TraceConstantTableEntry entry : table) {

						TypeDef.writeTypeMember(entry.getID(), entry.getName(),

								null);

					}

					TypeDefStore.endTypeDef();

				}

			}

		}

	}

	/**

	 * Writes alternative format characters to the Dictionary

	 * 

	 * @param formatChar

	 *            formatchar

	 * @param type

	 *            parameter type

	 * @param size

	 *            parameter size

	 * @param dt

	 *            data type

	 */

	private void writeAlternativeFormatChars(String formatChar, String type,

			int size, DataType dt) {

		// If there's big L, write also 'll' type

		if (formatChar.indexOf('L') != -1) {

			// Double small l

			String newFormatChar = formatChar.replace("L", "ll"); //$NON-NLS-1$ //$NON-NLS-2$

			TypeDefStore.writeTypeDef(type, size, newFormatChar, dt);

			writeCapitalHexType(newFormatChar, type, size, dt);

		}

		// Write alternative option to float types

		else if (formatChar.equals("f") || formatChar.equals("e") //$NON-NLS-1$//$NON-NLS-2$

				|| formatChar.equals("g")) { //$NON-NLS-1$

			String newFormatChar = 'L' + formatChar;

			TypeDefStore.writeTypeDef(type, size, newFormatChar, dt);

		}

		else {

			// If length is one, add also formatchar with "l"

			if (formatChar.length() == 1) {

				String newFormatChar = "l" + formatChar; //$NON-NLS-1$

				TypeDefStore.writeTypeDef(type, size, newFormatChar, dt);

				writeCapitalHexType(newFormatChar, type, size, dt);

			}

			// Check capital hex need

			writeCapitalHexType(formatChar, type, size, dt);

		}

	}

	/**

	 * Writes capital hex type

	 * 

	 * @param formatChar

	 *            formatchar

	 * @param type

	 *            parameter type

	 * @param size

	 *            parameter size

	 * @param dt

	 *            data type

	 */

	private void writeCapitalHexType(String formatChar, String type, int size,

			DataType dt) {

		// Write also capital X if there are hex values

		if (formatChar.indexOf('x') != -1) {

			type = type.toUpperCase();

			TypeDefStore.writeTypeDef(type, size, formatChar.replace('x', 'X'),

					dt);

		}

	}

	/**

	 * Gets the parameter size from type

	 * 

	 * @param type

	 *            the type

	 * @return the size in bytes

	 */

	private int mapParameterTypeToSize(String type) {

		int size = SourceUtils.mapParameterTypeToSize(type);

		if (size == 0) {

			if (type.equals(TraceParameter.ASCII)) {

				size = 1;

			} else if (type.equals(TraceParameter.UNICODE)) {

				size = 2; // CodForChk_Dis_Magic

			}

		}

		return size;

	}

	/**

	 * Creates the trace definitions

	 */

	private void createDefs() {

		// This should check for duplicates

		TraceDataStore.startDataStore();

		TraceModel model = dictionaryFile.getOwner().getModel();

		TraceProjectAPI api = model.getExtension(TraceProjectAPI.class);

		for (TraceGroup group : model) {

			for (Trace trace : group) {

				trace.addExtension(new DictionaryDefRef(++defref));

				TraceFormatFlags flags = new TraceFormatFlags();

				flags.isFormattingSupported = true;

				String data = api.formatTraceForExport(trace, flags);

				data = replaceUnescapeQuotes(data);

				TraceDataStore.writeData(defref, DataType.STRING, data);

			}

		}

		TraceDataStore.endDataStore();

	}

	/**

	 * Replaces unescape quates

	 * 

	 * @param data

	 *            the data

	 * @return the new string

	 */

	private String replaceUnescapeQuotes(String data) {

		data = data.replace("\\\"", "\""); //$NON-NLS-1$ //$NON-NLS-2$

		return data;

	}

	/**

	 * Maps a basic type to a Dictionary data type

	 * 

	 * @param type

	 *            the type

	 * @return the data type

	 */

	private DataType mapTypeToDataType(String type) { // CodForChk_Dis_ComplexFunc

		DataType retval;

		// Unsigned is not supported in Dictionary

		if (type.equals(TraceParameter.SDEC32)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.HEX32)) {

			retval = DataType.HEX;

		} else if (type.equals(TraceParameter.UDEC32)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.OCT32)) {

			retval = DataType.OCTAL;

		} else if (type.equals(TraceParameter.SDEC16)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.HEX16)) {

			retval = DataType.HEX;

		} else if (type.equals(TraceParameter.UDEC16)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.OCT16)) {

			retval = DataType.OCTAL;

		} else if (type.equals(TraceParameter.SDEC8)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.HEX8)) {

			retval = DataType.HEX;

		} else if (type.equals(TraceParameter.UDEC8)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.OCT8)) {

			retval = DataType.OCTAL;

		} else if (type.equals(TraceParameter.SDEC64)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.HEX64)) {

			retval = DataType.HEX;

		} else if (type.equals(TraceParameter.UDEC64)) {

			retval = DataType.INTEGER;

		} else if (type.equals(TraceParameter.OCT64)) {

			retval = DataType.OCTAL;

		} else if (type.equals(TraceParameter.ASCII)) {

			retval = DataType.STRING;

		} else if (type.equals(TraceParameter.UNICODE)) {

			retval = DataType.STRING;

		} else if (type.equals(TraceParameter.FLOAT_FIX)) {

			retval = DataType.FLOAT;

		} else if (type.equals(TraceParameter.FLOAT_EXP)) {

			retval = DataType.FLOAT;

		} else if (type.equals(TraceParameter.FLOAT_OPT)) {

			retval = DataType.FLOAT;

		} else if (type.equals(TraceParameter.POINTER)) {

			retval = DataType.HEX;

		} else {

			retval = null;

		}

		return retval;

	}

	/**

	 * Creates the location definitions

	 */

	private void createLocations() {

		ArrayList<DictionaryFileRef> files = new ArrayList<DictionaryFileRef>();

		LocationStore.startLocations();

		for (TraceGroup group : dictionaryFile.getOwner().getModel()) {

			for (Trace trace : group) {

				writeLocation(files, trace);

			}

		}

		// Build XML and assign ID's to refs

		Collections.sort(files, new FileRefComparator());

		String lastpath = null;

		for (DictionaryFileRef ref : files) {

			if (!ref.path.equals(lastpath)) {

				if (lastpath != null) {

					LocationStore.endPath();

				}

				LocationStore.startPath(ref.path);

				lastpath = ref.path;

			}

			LocationStore.writeFile(++fileref, ref.file);

			ref.refid = fileref;

		}

		if (lastpath != null) {

			LocationStore.endPath();

		}

		LocationStore.endLocations();

	}

	/**

	 * Writes the location of a trace

	 * 

	 * @param files

	 *            file references

	 * @param trace

	 *            trace to be written

	 */

	private void writeLocation(ArrayList<DictionaryFileRef> files, Trace trace) {

		LocationProperties loc = findFirstLocation(trace);

		if (loc != null) {

			String path = loc.getFilePath();

			String file = loc.getFileName();

			if (path != null) {

				path = FileUtils.convertSeparators(

						SourceConstants.FORWARD_SLASH_CHAR, path, true);

				// TODO: Remove drive letter. Actually cannot remove drive

				// letter because EPOCROOT might not be in the root of the drive

			}

			DictionaryFileRef ref = getRef(files, file, path);

			if (ref == null) {

				ref = new DictionaryFileRef(file, path, trace);

				files.add(ref);

				trace.addExtension(ref);

			} else {

				trace.addExtension(ref);

			}

		}

	}

	/**

	 * Finds the first location from trace

	 * 

	 * @param trace

	 *            the trace

	 * @return the location

	 */

	private LocationProperties findFirstLocation(Trace trace) {

		Iterator<LocationListBase> itr = trace

				.getExtensions(LocationListBase.class);

		LocationProperties loc = null;

		while (itr.hasNext() && loc == null) {

			Iterator<LocationProperties> locs = itr.next().iterator();

			if (locs.hasNext()) {

				loc = locs.next();

			}

		}

		return loc;

	}

	/**

	 * Gets a file reference

	 * 

	 * @param files

	 *            the list of file references

	 * @param file

	 *            file name

	 * @param path

	 *            file path

	 * @return the file reference

	 */

	private DictionaryFileRef getRef(ArrayList<DictionaryFileRef> files,

			String file, String path) {

		DictionaryFileRef retval = null;

		for (int i = 0; i < files.size() && retval == null; i++) {

			DictionaryFileRef ref = files.get(i);

			if (ref.file.equals(file) && ref.path.equals(path)) {

				retval = ref;

			}

		}

		return retval;

	}

	/**

	 * Creates the component definition

	 */

	private void createComponent() {

		TraceModel model = dictionaryFile.getOwner().getModel();

		int compid = model.getID();

		// Component prefix and suffix are in property file.

		// If not there, the default values are used

		String prefix = TraceObjectUtils.findProperty(model,

				PropertyNames.PREFIX);

		if (prefix == null || prefix.length() == 0) {

			prefix = FormattingUtils.getDefaultComponentPrefix(model);

		}

		String suffix = TraceObjectUtils.findProperty(model,

				PropertyNames.SUFFIX);

		if (suffix == null || suffix.length() == 0) {

			suffix = FormattingUtils.getDefaultComponentSuffix(model);

		}

		Dictionary.startComponent(compid, dictionaryFile.getProjectName(),

				prefix, suffix);

		for (TraceGroup group : model) {

			createGroup(group);

		}

		Dictionary.endComponent();

	}

	/**

	 * Creates a group definition

	 * 

	 * @param group

	 *            the group

	 */

	private void createGroup(TraceGroup group) {

		String prefix = TraceObjectUtils.findProperty(group,

				PropertyNames.PREFIX);

		if (prefix == null || prefix.length() == 0) {

			prefix = FormattingUtils.getDefaultGroupPrefix(group);

		}

		String suffix = TraceObjectUtils.findProperty(group,

				PropertyNames.SUFFIX);

		if (suffix == null || suffix.length() == 0) {

			suffix = FormattingUtils.getDefaultGroupSuffix(group);