/*

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

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

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

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

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

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

public class IttSample extends GenericSampleWithFunctions

{

	private static final long serialVersionUID = -6451379240317856526L;

  public long[] instructions;

  public long checksum;

  public long programCounter;

  private IFunction currentFunctionItt;

  private IFunction currentFunctionSym;

  public IttSample(int size)

  {

    instructions = new long[size];

    sampleSynchTime = 0;

  }

  public long[] reversedInstructions()

  {

    long[] revs = new long[instructions.length];

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

    {

      revs[i] |= (((instructions[i] & 0x000000ff) << 24) & 0xff000000);

      revs[i] |= (((instructions[i] & 0x0000ff00) << 8) & 0x00ff0000);

      revs[i] |= (((instructions[i] & 0x00ff0000) >> 8) & 0x0000ff00);

      revs[i] |= (((instructions[i] & 0xff000000) >> 24) & 0x000000ff);

      //System.out.print("\nOriginal "+Integer.toHexString((int)instructions[i]));

      String temp = Long.toHexString(revs[i]);

      String nulls = ""; //$NON-NLS-1$

      for (int n=0;n<8-temp.length();n++) nulls=nulls+"0"; //$NON-NLS-1$

      temp = nulls+temp;

      //System.out.println(" reversed "+temp);

    }

    return revs;

  }

  public void resolveFunction(FunctionResolver res)

  {

  	if (res.getResolverName().equals("Symbol"))  //$NON-NLS-1$

  	{

  		this.currentFunctionSym = res.findFunctionForAddress(programCounter);

  	}

  	else if (res.getResolverName().equals("ITT"))  //$NON-NLS-1$

  	{

  		if (currentFunctionSym == null) {

	  		this.currentFunctionItt = res.findFunctionForAddress(programCounter, sampleSynchTime);

  		}

  	}

  }

  public String toReversedString()

  {

    String s = ""; //$NON-NLS-1$

    long[] revs = this.reversedInstructions();

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

    {

      String nulls = ""; //$NON-NLS-1$

      String temp = ""; //$NON-NLS-1$

      temp = Integer.toHexString((int)revs[i]);

      for (int t = 0;t<(8-temp.length());t++) nulls = nulls+"0"; //$NON-NLS-1$

      s = s+(nulls+temp+Messages.getString("IttSample.space")); //$NON-NLS-1$

    }

    return s;

  }

	 /**

	  * Getter for current function resolved from dynamic binary trace

	 * @return the currentFunctionItt

	 */

	public IFunction getCurrentFunctionItt() {

		return currentFunctionItt;

	}

	/**

	  * Setter for current function resolved from dynamic binary trace

	 * @param currentFunctionItt the currentFunctionItt to set

	 */

	public void setCurrentFunctionItt(Function currentFunctionItt) {

		this.currentFunctionItt = currentFunctionItt;

	}

	/**

	  * Getter for current function resolved from symbols

	 * @return the currentFunctionSym

	 */

	public IFunction getCurrentFunctionSym() {

		return currentFunctionSym;

	}

	/**

	  * Setter for current function resolved from symbols

	 * @param currentFunctionSym the currentFunctionSym to set

	 */

	public void setCurrentFunctionSym(Function currentFunctionSym) {

		this.currentFunctionSym = currentFunctionSym;

	}

	/**

	 * Getter for the current binary resolved from dynamic binary trace

	 * @return the currentBinaryItt

	 */

	public IBinary getCurrentBinaryItt() {

		IBinary ret = null;

  		if (this.currentFunctionItt != null){

  			ret = this.currentFunctionItt.getFunctionBinary();

  		}

  		return ret;

	}

	/**

	 * Getter for the current binary resolved from symbols

	 * @return the currentBinarySym

	 */

	public IBinary getCurrentBinarySym() {

		IBinary ret = null;

  		if (this.currentFunctionSym != null){

  			ret = this.currentFunctionSym.getFunctionBinary();

  		}

		return ret;

	}

	@Override

	public String toString()

  {

  	long diff = 0;

  	if (this.getCurrentBinaryItt() != null && this.getCurrentBinarySym() != null)

  		diff = this.getCurrentBinaryItt().getStartAddress()+this.getCurrentBinaryItt().getOffsetToCodeStart()-

			   this.getCurrentBinarySym().getStartAddress();

  	else

  	{

  		System.out.println("NULL"); //$NON-NLS-1$

  	}

  	String result = "Itt:#"+this.sampleSynchTime+ //$NON-NLS-1$

			" @0x"+Long.toHexString(this.programCounter)+ //$NON-NLS-1$

			" fS:"+this.currentFunctionSym.getFunctionName()+ //$NON-NLS-1$

			" oS:"+Long.toHexString(this.currentFunctionSym.getStartAddress().longValue())+" +"+(this.programCounter-this.currentFunctionSym.getStartAddress().longValue())+ //$NON-NLS-1$ //$NON-NLS-2$

			" fI:"+this.currentFunctionItt.getFunctionName()+ //$NON-NLS-1$

			" oI:"+Long.toHexString(this.currentFunctionItt.getStartAddress().longValue())+" +"+(this.programCounter-this.currentFunctionItt.getStartAddress().longValue()); //$NON-NLS-1$ //$NON-NLS-2$

  	if (diff != 0) result=" DIFF: "+diff+" "+result; //$NON-NLS-1$ //$NON-NLS-2$

  	return result;

  }

}