/*

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

import java.io.DataInputStream;

import java.io.DataOutputStream;

import java.io.EOFException;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.util.Hashtable;

import java.util.StringTokenizer;

import com.nokia.carbide.cpp.internal.pi.analyser.NpiInstanceRepository;

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

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

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

public class GppTraceParser extends Parser

{

//  private String traceVersion;

  private boolean debug = false;

  private String profilerVersion;

  private String samplerVersion;

  private Hashtable<Integer,GppProcess> processes;

  private Hashtable<Integer,GppThread> threads;

  public GppTraceParser() throws IOException

  {

    this.processes = new Hashtable<Integer,GppProcess>();

    this.threads   = new Hashtable<Integer,GppThread>();

  }

  {

    if (!traceInput.exists())

    	throw new IOException(Messages.getString("GppTraceParser.0"));  //$NON-NLS-1$

    DataInputStream dis = new DataInputStream(new FileInputStream(traceInput));

    if (validate(dis) == false)

    	throw new IOException(Messages.getString("GppTraceParser.1"));  //$NON-NLS-1$

    long pc = 0;

    GppThread thread = null;

    int threadIndexer = 0;

    int count = 1;

    int samples = 0;

    long time = 0;

    // determine the base sampling period (address/thread sampling period) 

    int addrThreadPeriod = 1;

    if (traceVersion.indexOf("V2.01") != -1) { //$NON-NLS-1$

    	addrThreadPeriod =   (dis.readUnsignedByte() << 24)

			    		   | (dis.readUnsignedByte() << 16)

			    		   | (dis.readUnsignedByte() <<  8)

			    		   |  dis.readUnsignedByte();

    }

	// initialize the address/thread base sampling rate

	NpiInstanceRepository.getInstance().activeUidSetPersistState(

								"com.nokia.carbide.cpp.pi.address.samplingInterval", //$NON-NLS-1$

    while (dis.available() > 0)

    {

      try

      {

        count = 1;

        int diff = (int)decodeInt(dis);

        if ((diff & 1) == 1)

        {

          diff &= ~1;

          thread = decodeThread(dis);

        }

        else if (diff == 0)

        {

          count = (int)decodeUInt(dis);

        }

        pc += diff;

        while (--count >= 0)

        {

          samples++;

          time += addrThreadPeriod;

          {

        	// create a new sample object for this sample

            GppSample gppSample = new GppSample();

            long pcMod = pc << 32;

            pcMod = pcMod >>> 32;

           	gppSample.programCounter = pcMod;

            gppSample.sampleSynchTime = time;

            GppThread unknownThread = new GppThread();

            unknownThread.threadId = -1;

            unknownThread.threadName = Messages.getString("GppTraceParser.unknown"); //$NON-NLS-1$

            GppProcess unknownProcess = new GppProcess();

            unknownProcess.id = -1;

            unknownProcess.name = Messages.getString("GppTraceParser.unknown"); //$NON-NLS-1$

            this.processes.put(-1,unknownProcess);

            unknownThread.process = unknownProcess;

            unknownThread.index = threadIndexer++;

            gppSample.thread = unknownThread;

            this.threads.put(-1,unknownThread);

            gppSample.thread = unknownThread;

          }

          else if (thread.index >= -1)

	      {

            if (thread.index == -1) thread.index = threadIndexer++;

            // create a new sample object for this sample

            GppSample gppSample = new GppSample();

           	long pcMod = pc << 32;

           	pcMod = pcMod >>> 32;

           	if (thread.threadName.equals("*Native*")) //$NON-NLS-1$

           		gppSample.programCounter = 0;

           	else

           		gppSample.programCounter = pcMod;

            //System.out.println("PC value:"+pc+" "+Long.toHexString(pc));

            gppSample.sampleSynchTime = time;

            gppSample.thread = thread;

            thread.samples++;

          }

        }

      }

      catch (EOFException e) {}

    }

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

    // all samples have been parsed

  }

  private boolean validate(DataInputStream dis) throws IOException

  {

    String data = decodeName(dis);

    if (debug) System.out.println(Messages.getString("GppTraceParser.3")+data);  //$NON-NLS-1$

    if (data.equals("profile")) //pre 1.10 //$NON-NLS-1$

    if (decodeUInt(dis) == 1) return true;

    if (data.startsWith("Bappea_GPP_V")) //version 1.20 //$NON-NLS-1$

    {

        try

        {

        	int separatorIndex = data.indexOf("#"); //$NON-NLS-1$

	        this.traceVersion = data.substring(data.indexOf("_")+1,separatorIndex); //$NON-NLS-1$

	    }

	    catch (Exception e)

	    {

	    	return false;

	    }

    	StringTokenizer st = new StringTokenizer(data,"#"); //$NON-NLS-1$

      	while(st.hasMoreElements())

    	{

    		String id = st.nextToken();

    		if (id.equals("Prof")) //$NON-NLS-1$

    		{

    			this.profilerVersion = st.nextToken();

    		}

    		else if (id.equals("Samp"))  //$NON-NLS-1$

    		{

    			this.samplerVersion = st.nextToken();

    		}

    	}

		if (   (traceVersion.indexOf("V1.10") != -1)	//$NON-NLS-1$

			|| (traceVersion.indexOf("V1.64") != -1)	//$NON-NLS-1$

			|| (traceVersion.indexOf("V2.01") != -1))	//$NON-NLS-1$

            return true;

      	else

      		return false;

    }

    return false;

  }

	{

		int digit;

		for (;;) {

			digit = number & 0x7f;

			if ((number >> 6) == (number >> 7))

				break;

			number >>= 7;

			dos.write(digit);

		}

		dos.write(digit | 0x80);

		dos.flush();

	}

	{

		int digit;

		for (;;) {

			digit = number & 0x7f;

			number >>= 7;

			if (number <= 0)

				break;

			dos.write(digit);

		}

		dos.write(digit | 0x80);		

	}

  {

    //System.out.println("DECODING INT");

	int val = 0;

    int shift = 0;

    int data;

    do

    {

      data = dis.readUnsignedByte();

      //System.out.print(":"+Integer.toHexString(data));

      if (data < 0)

    	  throw new IOException(Messages.getString("GppTraceParser.7"));  //$NON-NLS-1$

      val |= (data & 0x7f) << shift;

      shift += 7;

    } while ((data & 0x80) == 0);

    if (shift < 32)

    {

      shift = 32 - shift;

      val = val << shift >> shift;

    }

    //System.out.println("read int"+(val & 0xffffffff));

    return (val);

  }

  {

    //System.out.println("DECODING UINT");

    long val = 0;

    int shift = 0;

    int data;

    do

    {

      data = dis.readUnsignedByte();

      //System.out.println("read byte:"+Integer.toHexString(data));

      if (data < 0)

    	  throw new IOException(Messages.getString("GppTraceParser.8"));  //$NON-NLS-1$

      val |= (data & 0x7f) << shift;

      shift += 7;

    } while ((data & 0x80) == 0);

    //System.out.println("read unsigned int"+val);

    return val;

  }

  private String decodeName(DataInputStream dis) throws IOException

  {

    //System.out.println("DECODING NAME");

    int length = dis.readUnsignedByte();

    //System.out.println("name length "+Integer.toHexString(length));

    byte[] data = new byte[length];

    dis.read(data);

    //System.out.println("Read name:"+new String(data));

    return new String(data);

  }

  private GppProcess decodeProcess(DataInputStream dis) throws IOException

  {

    //System.out.println("DECODING PROCESS");

    if (this.processes.containsKey(pid))

    {

      return (GppProcess)this.processes.get(pid);

    }

    else

    {

      GppProcess np = new GppProcess();

      np.id = pid;

      np.name = decodeName(dis);

      this.processes.put(pid,np);

      return np;

    }

  }

  private GppThread decodeThread(DataInputStream dis) throws IOException

  {

    //System.out.println("DECODING THREAD");

    if (this.threads.containsKey(tid))

    {

      return (GppThread)this.threads.get(tid);

    }

    GppProcess p = decodeProcess(dis);

    String name = decodeName(dis);

    try

	{

    	if (name.endsWith("]")) //$NON-NLS-1$

    	{

    		String l = name.substring(name.lastIndexOf("[")+1,name.lastIndexOf("]")); //$NON-NLS-1$ //$NON-NLS-2$

    		Long threadAddress = Long.decode("0x"+l); //$NON-NLS-1$

    		name = name.substring(0,name.lastIndexOf("[")); //$NON-NLS-1$

    	}

	}

    catch (Exception e)

	{

    	e.printStackTrace();

	}

    GppThread nt = new GppThread();

    nt.threadId = tid;

    nt.threadName = name;

    nt.process = p;

    nt.index = -1;

    this.threads.put(tid,nt);

    return nt;

  }

  {

  	GppTrace trace = new GppTrace();

  	return trace;

  }

}