/*

 * 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 the License "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: 

 *

 */

package com.nokia.carbide.cpp.pi.memory;

import java.io.ByteArrayInputStream;

import java.io.DataInputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

import com.nokia.carbide.cpp.internal.pi.model.GenericSampledTrace;

import com.nokia.carbide.cpp.internal.pi.model.ParsedTraceData;

import com.nokia.carbide.cpp.internal.pi.model.Parser;

import com.nokia.carbide.cpp.pi.priority.PriSample;

import com.nokia.carbide.cpp.pi.priority.PriThread;

import com.nokia.carbide.cpp.pi.priority.PriTrace;

import com.nokia.carbide.cpp.pi.util.GeneralMessages;

public class MemTraceParser extends Parser

{

    private boolean debug = false;

    private String version;

	private Vector<MemThread> memSamples = new Vector<MemThread>();

	private Vector<PriThread> priSamples = new Vector<PriThread>();

	private char[] buffer = new char[80];

	private String threadName;

	private String processName;

	private int threadId;

	private int sampleTime;

	private int heapSize;

	private int stackSize;

	private int processPriority;

	private int threadPriority;

	private int defaultSamplingTime = 3000;

	private int samplingTime;

	private MemSample sample;

	private MemTrace memTrace;

	private PriSample priSample;

	private PriTrace priTrace;

	private byte a, b, c, d;

	private int readCount = 0;

	// constants

	public static int SAMPLE_CODE_INITIAL_CHUNK = 0;

	public static int SAMPLE_CODE_NEW_CHUNK = 1;

	public static int SAMPLE_CODE_UPDATE_CHUNK = 2;

	public static int SAMPLE_CODE_DELETE_CHUNK = 3;

	public MemTraceParser() //throws Exception

	{

	}

	public ParsedTraceData parse(File file) throws Exception 

	{

		if (!file.exists() || file.isDirectory())

	    {

	      throw new Exception(Messages.getString("MemTraceParser.cannotOpenTraceFile")); //$NON-NLS-1$

	    }

		if (debug)

			System.out.println(Messages.getString("MemTraceParser.traceFileLength") + file.length()); //$NON-NLS-1$

	    parseMemTrace(file);

	    int versionNumber = convertVersionStringToInt(version);

	    memTrace.setVersion(versionNumber);

	    samplingTime = calcSamplingTime();

		ParsedTraceData ptd = new ParsedTraceData();

		ptd.traceData = this.getTrace();

		/* TODO some debug prints remove

		MemTrace memTrace = (MemTrace)ptd.traceData;

		int ii = 1;

		for (Enumeration e = memTrace.getSamples(); e.hasMoreElements(); )

		{

			MemSample memSample = (MemSample) e.nextElement();

			if(memSample.thread.threadId == 0xc81dc318){

				System.out.println("Threadname: " + memSample.thread.threadName +  ", time:" + Long.toString(memSample.sampleSynchTime) + ", stack:" + Integer.toString(memSample.stackSize) + ", heap:" + Integer.toString(memSample.heapSize));

				ii++;

			}

		}*/

		return ptd;

	}

	private void parseNewMemFile(String version,DataInputStream dis) throws Exception

	{

		if (version.equals("0.85") || version.equals("0.91") || version.equals("1.00")||version.equals("1.10")) //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$

		{

			parseV085MemFile(dis);

		}

		else throw new Exception(Messages.getString("MemTraceParser.traceVersionException1") + version //$NON-NLS-1$

				                 + Messages.getString("MemTraceParser.traceVersionException2")); //$NON-NLS-1$

	}

	private void parseV085MemFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug)System.out.println(Messages.getString("MemTraceParser.readVersionDebug") + new String(version)); //$NON-NLS-1$

		this.version = new String(version);

		this.readV085MemSample(dis);

	}

	private void parseV110MemFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug) System.out.println(Messages.getString("MemTraceParser.readVersionDebug") + new String(version)); //$NON-NLS-1$

		this.version = new String(version);

		this.readV110MemSample(dis);

	}

	private void parseV155MemFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug) System.out.println(Messages.getString("MemTraceParser.readVersion")+new String(version)); //$NON-NLS-1$

		this.version = new String(version);

		this.readV155MemSample(dis);

	}

	private void parseV157MemFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug) System.out.println("Read version "+new String(version));

		this.version = new String(version);

		this.readV157MemSample(dis);

	}

	private void parseV110PriFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		if (debug) System.out.println(Messages.getString("MemTraceParser.readVersionDebug") + new String(version)); //$NON-NLS-1$

		this.version = new String(version);

		this.readV110PriSample(dis);

	}

	public String getProfilerVersion()

	{

	    return version;

	}

	private void readV085MemSample(DataInputStream dis) throws Exception

	{

	    Vector<long[]> rawV085Samples = new Vector<long[]>();

	    Vector<long[]> lastSampleRaw = new Vector<long[]>();

		memTrace = new MemTrace();

	    priTrace = new PriTrace();

		// first there should be 4 bytes of sample time

		long sample = this.readTUintWithLength(dis);

		// then read if there is thread name data

		int length = dis.readUnsignedByte();readCount++;

		if (length != 1)

			throw new Exception(Messages.getString("MemTraceParser.parseErrorTypeMissing")); //$NON-NLS-1$

		int mode = dis.readUnsignedByte(); readCount++;

		try

		{

			// read the first length

			length = dis.readUnsignedByte(); readCount++;

			Thread.currentThread().setPriority(Thread.MIN_PRIORITY);

			while(true)

			{

				//System.out.println("ReadCount:"+this.readCount);

				if (length == 0) //haxor =)

				{

					// end of sample

					// read new length

					// first there should be 4 bytes of sample time

					sample = this.readTUintWithLength(dis);

					length = dis.readUnsignedByte(); readCount++;

					if (length == 4)

					{

						// there was only the sample header here

						System.out.println(Messages.getString("MemTraceParser.missingSampleNumber") + sample); //$NON-NLS-1$

						mode = 0x00;

					}

					else if (length != 1)

					{

						throw new Exception(Messages.getString("MemTraceParser.parseErrorWrongLength") + length); //$NON-NLS-1$

					}

					else

					{

						lastSampleRaw.clear();

					}

				}

				if (length == 1)

				{

					mode = dis.readUnsignedByte(); readCount++;

					// read the next length

					length = dis.readUnsignedByte(); readCount++;

					lastSampleRaw.clear(); //lisätty 16.11.05 -aniskane

				}

				if (mode == 0xaa)

				{

					// reading thread names

					String rawName = readThreadName(dis,length);

					long threadId = readTUint(dis);

				   	int index = rawName.indexOf(':');

				   	if (index != -1)

				   	{

				   		processName = rawName.substring(0,index);

				   		threadName = rawName.substring(rawName.lastIndexOf(':')+ 1, rawName.length());

				   	}

				   	else

				   	{

				   		processName = rawName;

				   		threadName = rawName;

				   	}

				   	// read the next length

					length = dis.readUnsignedByte(); readCount++;

					//System.out.println("Next length " + length);

				}

				else if (mode == 0xdd)

				{

					// reading data

					long[] elements = this.readDataElements085Mem(dis, length, sample);

					rawV085Samples.add(elements);

					lastSampleRaw.add(elements);

					// read the next length

					length = dis.readUnsignedByte(); readCount++;

				}

				else if (mode == 0x00)

				{

					// duplicate the previous sample to replace the missing sample

					Enumeration<long[]> e = lastSampleRaw.elements();

					while(e.hasMoreElements())

					{

						long[] element = e.nextElement();

						long[] newElement = new long[7];

						newElement[0] = element[0];

						newElement[1] = element[1];

						newElement[2] = element[2];

						newElement[3] = element[3];

						newElement[4] = element[4];

						newElement[5] = element[5];

						// replace the sample number with the missing one

						newElement[6] = sample;

						// add the duplicated sample

						rawV085Samples.add(newElement);

					}

					// read the length, it is already known

					sample = readTUint(dis);

					System.out.println(Messages.getString("MemTraceParser.sampleRead") + sample); //$NON-NLS-1$

					length = dis.readUnsignedByte(); readCount++;;

				}

				else

				{

					throw new Exception(Messages.getString("MemTraceParser.parseErrorWrongMode") + mode); //$NON-NLS-1$

				}

			}

		}

		catch (EOFException e)

		{

			if (debug) System.out.println(Messages.getString("MemTraceParser.finishedReading")); //$NON-NLS-1$

			this.addRawV085Samples(rawV085Samples);

		}

	}

	private void readV110MemSample(DataInputStream dis) throws Exception

	{

	    Vector<long[]> rawV110MemSamples = new Vector<long[]>();

	    Vector<long[]> lastSampleRaw = new Vector<long[]>();

		memTrace = new MemTrace();

		// first there should be 4 bytes of sample time

		long sample = this.readTUintWithLength(dis);

		// then read if there is thread name data

		int length = dis.readUnsignedByte(); readCount++;

		if (length != 1)

			throw new Exception(Messages.getString("MemTraceParser.parseErrorTypeMissing")); //$NON-NLS-1$

		int mode = dis.readUnsignedByte(); readCount++;

		try

		{

			length = dis.readUnsignedByte(); readCount++;

			while(true)

			{

				if (length == 0) 

				{

					// end of sample

					// read new length

					// first there should be 4 bytes of sample time

					sample = this.readTUintWithLength(dis);

					length = dis.readUnsignedByte(); readCount++;

					if (length == 4)

					{

						// there was only the sample header here

						System.out.println(Messages.getString("MemTraceParser.missingSampleNumber") + sample); //$NON-NLS-1$

						mode = 0x00;

					}

					else if (length != 1)

					{

						throw new Exception(Messages.getString("MemTraceParser.parseErrorWrongLength") + length); //$NON-NLS-1$

					}

					else

					{

						lastSampleRaw.clear();

					}

				}

				if (length == 1)

				{

					mode = dis.readUnsignedByte(); readCount++;

					// read the next length

					length = dis.readUnsignedByte(); readCount++;

					lastSampleRaw.clear(); //lisätty 16.11.05 -aniskane

				}

				if (mode == 0xaa)

				{

					// reading thread names

					String rawName = readThreadName(dis,length);

					long threadId = readTUint(dis);

				   	int index = rawName.indexOf(':');

				   	if (index != -1)

				   	{

				   		processName = rawName.substring(0,index);

				   		threadName = rawName.substring(rawName.lastIndexOf(':') + 1, rawName.length());

				   	}

				   	else

				   	{

				   		processName = rawName;

				   		threadName = rawName;

				   	}

					length = dis.readUnsignedByte(); readCount++;

				}

				else if (mode == 0xdd)

				{

					// reading data

					long[] elements = this.readDataElements110Mem(dis, length, sample);

					rawV110MemSamples.add(elements);

					lastSampleRaw.add(elements);

					// read the next length

					length = dis.readUnsignedByte(); readCount++;

				}

				else if (mode == 0x00)

				{

					// duplicate the previous sample to replace the missing sample

					Enumeration<long[]> e = lastSampleRaw.elements();

					while(e.hasMoreElements())

					{

						long[] element = e.nextElement();

						long[] newElement = new long[7];

						newElement[0] = element[0];

						newElement[1] = element[1];

						newElement[2] = element[2];

						newElement[3] = element[3];

						newElement[4] = element[4];

						// replace the sample number with the missing one

						newElement[5] = sample;

						// add the duplicated sample

						rawV110MemSamples.add(newElement);

					}

					// read the length, it is already known

					sample = readTUint(dis);

					if (debug) System.out.println(Messages.getString("MemTraceParser.sampleRead") + sample); //$NON-NLS-1$

					length = dis.readUnsignedByte();readCount++;;

				}

				else

				{

					throw new Exception(Messages.getString("MemTraceParser.parseErrorWrongMode")+mode); //$NON-NLS-1$

				}

			}

		}

		catch (EOFException e)

		{

			System.out.println(Messages.getString("MemTraceParser.finishedReading")); //$NON-NLS-1$

			this.addRawV110MemSamples(rawV110MemSamples);

		}

	}

	private void readV155MemSample(DataInputStream dis) throws Exception

	{

	    Vector<long[]> rawV155MemSamples = new Vector<long[]>();

	    Vector<long[]> lastSampleRaw = new Vector<long[]>();

		memTrace = new MemTrace();

		// first there should be 4 bytes of sample time

		long sample = this.readTUintWithLength(dis);

		// then read if there is thread name data

		int length = dis.readUnsignedByte();readCount++;

		if (length != 1) throw new Exception(Messages.getString("MemTraceParser.missingType")); //$NON-NLS-1$

		int mode = dis.readUnsignedByte();readCount++;

		try

		{

			length = dis.readUnsignedByte();readCount++;

			while(true)

			{

				if (length == 0) 

				{

					if (debug)System.out.println(Messages.getString("MemTraceParser.newSample")); //$NON-NLS-1$

					// end of sample

					// read new length

					// first there should be 4 bytes of sample time

					sample = this.readTUintWithLength(dis);

					length = dis.readUnsignedByte();readCount++;

					if (length == 4)

					{

						// there was only the sample header here

						System.out.println(Messages.getString("MemTraceParser.missingSampleNum")+sample); //$NON-NLS-1$

						mode = 0x00;

					}

					else if (length != 1)

					{

						throw new Exception(Messages.getString("MemTraceParser.wrongLength")+length); //$NON-NLS-1$

					}

					else

					{

						lastSampleRaw.clear();

					}

				}

				if (length == 1)

				{

					mode = dis.readUnsignedByte();readCount++;

					// read the next length

					length = dis.readUnsignedByte();readCount++;

					if (debug)System.out.println(Messages.getString("MemTraceParser.nextLength")+length); //$NON-NLS-1$

					lastSampleRaw.clear(); //lisätty 16.11.05 -aniskane

				}

				if (mode == 0xaa)

				{

					// reading thread names

					String rawName = readThreadName(dis,length);

					long threadId = readTUint(dis);

					if (debug)System.out.println(Messages.getString("MemTraceParser.rawName1")+rawName+Messages.getString("MemTraceParser.rawName2")+threadId); //$NON-NLS-1$ //$NON-NLS-2$

				   	int index = rawName.indexOf(':');

				   	if (index != -1)

				   	{

				   		processName = rawName.substring(0,index);

				   		//threadName = rawName.substring(rawName.lastIndexOf(':')+1,rawName.length());

				   		threadName = rawName.substring(rawName.indexOf(':')+2,rawName.length());

				   	}

				   	else

				   	{

				   		processName = rawName;

				   		threadName = rawName;

				   	}

					if (processName.startsWith("T_")) //$NON-NLS-1$

					{

						processName = processName.substring(2);

						threadName += "_T"; //$NON-NLS-1$

					}

					else if (processName.startsWith("C_")) //$NON-NLS-1$

					{

						processName = processName.substring(2);