/*

 * 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.priority;

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.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.util.GeneralMessages;

public class PriTraceParser extends Parser

{

    private boolean debug = false;

    private String version;

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

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

	private String threadName;

	private String processName;

	private int threadId;

	private int sampleNum;

	private int processPriority;

	private int threadPriority;

	private PriSample priSample;

	private PriTrace priTrace;

	private byte a, b, c, d;

	private int readCount = 0;

	public PriTraceParser(File file) //throws Exception

	{

	}

	public ParsedTraceData parse(File f) throws Exception 

	{

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

	    {

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

	    }

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

	    parsePriTrace(f);

	    if (this.getTrace() == null)

	    	return null;

		ParsedTraceData ptd = new ParsedTraceData();

		ptd.traceData = this.getTrace();

		return ptd;

	}

	private void parseNewPriFile(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 if (version.equals("1.55")) //$NON-NLS-1$

		{

			return;

		}

		else

			throw new Exception(Messages.getString("PriTraceParser.unsupportedMemoryTrace1")+version+Messages.getString("PriTraceParser.unsupportedMemoryTrace2")); //$NON-NLS-1$ //$NON-NLS-2$

	}

	private void parseV085MemFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

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

		this.version = new String(version);

		this.readV085MemSample(dis);

	}

	private void parseV110PriFile(DataInputStream dis) throws Exception

	{

		// read the version again

		byte[] version = readElementWithLength(dis);

		System.out.println(Messages.getString("PriTraceParser.readVersion")+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);

		//System.out.println("Current sample "+sample);

		// then read if there is thread name data

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

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

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

		//System.out.println("First mode "+Integer.toHexString(mode));

		try

		{

			// read the first length

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

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

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

			while(true)

			{

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

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

				{

					//System.out.println("Length = 0, New sample");

					// end of sample

					// read new length

					// first there should be 4 bytes of sample time

					sample = this.readTUintWithLength(dis);

					//System.out.println("Sample number:"+sample);

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

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

					//break;

					if (length == 4)

					{

						// there was only the sample header here

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

						mode = 0x00;

					}

					else if (length != 1)

					{

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

					}

					else

					{

						lastSampleRaw.clear();

					}

				}

				if (length == 1)

				{

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

					//System.out.println("New Mode "+mode+" new length "+length);

					// read the next length

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

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

				}

				if (mode == 0xaa)

				{

					// reading thread names

					String rawName = readThreadName(dis,length);

					long threadId = readTUint(dis);

					//System.out.println("Raw name "+rawName);

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

				   	if (index != -1)

				   	{

				   		processName = rawName.substring(0,index);

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

				   		//System.out.println("Thread: "+threadName+" process: "+processName+" id: "+threadId);

				   	}

				   	else

				   	{

				   		processName = rawName;

				   		threadName = rawName;

				   	}

				   	priTrace.addFirstSynchTime(new Integer((int)threadId), new Integer(sampleNum));

				   	priSamples.add(new PriThread(new Integer((int)threadId), threadName, processName));

				   	// 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++;

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

				}

				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("PriTraceParser.readNextSample")+sample); //$NON-NLS-1$

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

				}

				else

				{

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

				}

			}

		}

		catch (EOFException e)

		{

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

			this.addRawV085Samples(rawV085Samples);

		}

	}

	private void addRawV085Samples(Vector<long[]> rawV085Samples)

	{

//	    MemThread[] memTreads = new MemThread[memSamples.size()];

//	    memSamples.copyInto((MemThread[]) memTreads);

//	    memTrace.setThreads(memTreads);

	    PriThread[] priThreads = new PriThread[priSamples.size()];

	    priSamples.copyInto((PriThread[]) priThreads);

	    priTrace.setThreads(priThreads);

	    Enumeration<long[]> rawEnum = rawV085Samples.elements();

	    while(rawEnum.hasMoreElements())

	    {

	    	long[] element = rawEnum.nextElement();

	    	threadId = (int)element[0];

	    	threadPriority = (int)element[5];

	    	// for the null thread, converts 8bit unsigned to signed

	    	if (threadPriority > 32768)

	    	    threadPriority = threadPriority - 65536;

	    	sampleNum = (int)element[6]; 

	    	for (Enumeration<PriThread> e = priSamples.elements();e.hasMoreElements();)

	    	{

	    		PriThread pt = e.nextElement();

	    		if (pt.threadId.intValue() == threadId)

	    		{

	    			//int priority = solveAbsolutPriority(processPriority, threadPriority);

	    			priSample = new PriSample(pt, threadPriority, sampleNum);

	    			priTrace.addSample(priSample);

	    			break;

	    		}

	    	}

//	    	memTrace.addLastSynchTime(new Integer(threadId), new Integer(sampleNum));

	    	priTrace.addLastSynchTime(new Integer(threadId), new Integer(sampleNum));

	    }

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

	}

	private void readV110PriSample(DataInputStream dis) throws Exception

	{

	    Vector<long[]> rawV110PriSamples = 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);

		//System.out.println("Current sample "+sample);

		// then read if there is thread name data

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

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

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

		//System.out.println("First mode "+Integer.toHexString(mode));

		try

		{

			// read the first length

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

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

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

			while(true)

			{

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

				if (length == 0)

				{

					//System.out.println("Length = 0, New sample");

					// end of sample

					// read new length

					// first there should be 4 bytes of sample time

					sample = this.readTUintWithLength(dis);

					//System.out.println("Sample number:"+sample);

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

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

					//break;

					if (length == 4)

					{

						// there was only the sample header here

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

						mode = 0x00;

					}

					else if (length != 1)

					{

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

					}

					else

					{

						lastSampleRaw.clear();

					}

				}

				if (length == 1)

				{

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

					//System.out.println("New Mode "+mode+" new length "+length);

					// read the next length

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

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

				}

				if (mode == 0xaa)

				{

					// reading thread names

					String rawName = readThreadName(dis,length);

					long threadId = readTUint(dis);

					//System.out.println("Raw name "+rawName);

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

				   	if (index != -1)

				   	{

				   		processName = rawName.substring(0,index);

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

				   		//System.out.println("Thread: "+threadName+" process: "+processName+" id: "+threadId);

				   	}

				   	else

				   	{

				   		processName = rawName;

				   		threadName = rawName;

				   	}

					//memTrace.addFirstSynchTime(new Integer((int)threadId),new Integer((int)sample));

				   	//memSamples.add(new MemThread(new Integer((int)threadId), threadName, processName));

				   	priTrace.addFirstSynchTime(new Integer((int)threadId), new Integer(sampleNum));

				   	priSamples.add(new PriThread(new Integer((int)threadId), threadName, processName));

				   	// read the next length

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

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

				}

				else if (mode == 0xdd)

				{

					// reading data

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

					/*

					System.out.println("Read elements "+elements);

					if (elements != null)

					{

						for (int i=0;i<elements.length;i++)

							System.out.println("Element #"+i+" "+Long.toHexString(elements[i]));

					}

					*/

					rawV110PriSamples.add(elements);

					lastSampleRaw.add(elements);

					// read the next length

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

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

				}

				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[2] = sample;

						// add the duplicated sample

						rawV110PriSamples.add(newElement);

					}

					// read the length, it is already known

					sample = readTUint(dis);

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

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

				}

				else

				{

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

				}

			}

		}

		catch (EOFException e)

		{

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

			this.addRawV110PriSamples(rawV110PriSamples);

		}

	}

	private void addRawV110PriSamples(Vector<long[]> rawV110PriSamples)

	{

	    //MemThread[] memTreads = new MemThread[memSamples.size()];

	    //memSamples.copyInto((MemThread[]) memTreads);

	    //memTrace.setThreads(memTreads);

	    PriThread[] priThreads = new PriThread[priSamples.size()];

	    priSamples.copyInto((PriThread[]) priThreads);

	    priTrace.setThreads(priThreads);

	    Enumeration<long[]> rawEnum = rawV110PriSamples.elements();

	    while(rawEnum.hasMoreElements())

	    {

	    	long[] element = rawEnum.nextElement();

	    	threadId = (int)element[0];

	    	threadPriority = (int)element[1];

	    	// for the null thread, converts 8bit unsigned to signed

	    	if (threadPriority > 32768)

	    	    threadPriority = threadPriority - 65536;

	    	//heapSize = (int)element[1];

	    	//stackSize = (int)element[4];

	    	sampleNum = (int)element[2]; 

	    	for (Enumeration<PriThread> e = priSamples.elements();e.hasMoreElements();)

	    	{

	    		PriThread pt = e.nextElement();

	    		if (pt.threadId.intValue() == threadId)

	    		{

	    			//int priority = solveAbsolutPriority(processPriority, threadPriority);

	    			priSample = new PriSample(pt, threadPriority, sampleNum);

	    			priTrace.addSample(priSample);

	    			break;

	    		}

	    	}

//	    	memTrace.addLastSynchTime(new Integer(threadId), new Integer(sampleNum));

	    	priTrace.addLastSynchTime(new Integer(threadId), new Integer(sampleNum));

	    }

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

	}

//	private void readAndPrintData(DataInputStream dis, int length) throws Exception

//	{

//		for (int i=0;i<length;i++)

//			System.out.print(" "+Integer.toHexString(dis.readUnsignedByte()));

//		System.out.print("\n");

//	}

	private long[] readDataElements085Mem(DataInputStream dis,int length,long sampleNum) throws Exception

	{

		if (length != 0)

		{

			long[] elements = new long[7];

			elements[0] = this.readTUint(dis);

			elements[1] = this.readTUint(dis);

			elements[2] = this.readTUint(dis);

			elements[3] = this.readTUint(dis);

			elements[4] = this.readTUint(dis);

			elements[5] = this.readShort(dis);

			//System.out.println("Priority: "+elements[5]);

			elements[6] = sampleNum;

			return elements;

		}

		else 

		{

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

			return null;

		}

	}

	private long[] readDataElements110Pri(DataInputStream dis,int length,long sampleNum) throws Exception

	{

		if (length != 0)

		{

			long[] elements = new long[3];