/*

 * Copyright (c) 2010 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.irq;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.HashSet;

import java.util.Hashtable;

import java.util.Vector;

import org.eclipse.swt.graphics.RGB;

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

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

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

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

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

import com.nokia.carbide.cpp.internal.pi.visual.GenericTraceGraph;

import com.nokia.carbide.cpp.pi.address.GppTrace;

import com.nokia.carbide.cpp.pi.editors.PIPageEditor;

/**

 * Class containing all samples from one Irq trace

 */

public class IrqTrace extends GenericSampledTraceWithFunctions {

	private static final long serialVersionUID = 5128848053984932839L;

	private transient IrqTraceGraph[] graphs;

	/* Hashtable containing thread id's and swi offsets */

	private Hashtable<Long, Integer> threadToOffset;

	/* Hashtable containing thread id's and names */

	private Hashtable<Long, String> threadToName;

	/* Hashtable containing Irq lines and offsets */

	private Hashtable<Long, Integer> irqToOffset;

	/* Vector containing all thread wrappers */

	private transient Vector<SwiThreadWrapper> allThreadWrappers;

	/* Hashtable containing thread id's and all samples from that thread */

	private transient Hashtable<Long, IrqSampleTypeWrapper> swiTable;

	/* Hashtable containing irq line id's and all samples from that line */

	private transient Hashtable<Long, IrqSampleTypeWrapper> irqTable;

	/* Hashtable containing thread names functions */

	private transient Hashtable<String, Hashtable<String, ArrayList<Long>>> threadsToFunctions;

	/* All colors in use */

	private transient HashSet<RGB> colorSet;

	/* Colors in functions and irq lines */

	private Hashtable<String, RGB> colorsOfThreadsAndLines;

	/* maximum amount of swi interrupts at one time frame */

	private int maxAmountOfSWISamples;

	/* maximum amount of irq interrupts at one time frame */

	private int maxAmountOfIRQSamples;

	/* Boolean value that is false if no function names is found from trace

	 * (No Symbol files imported) 

	 */

	boolean functionNamesFound = false;

	/**

	 * getter for trace graph

	 * 

	 * @param graphIndex

	 *            index of the graph

	 * @return graph

	 */

	public GenericTraceGraph getTraceGraph(int graphIndex) {

		if (graphs == null) {

			graphs = new IrqTraceGraph[3];

		}

		// note that graphIndex need not match the index sent to TraceGraph

		if ((graphIndex == PIPageEditor.THREADS_PAGE)

				|| (graphIndex == PIPageEditor.BINARIES_PAGE)

				|| (graphIndex == PIPageEditor.FUNCTIONS_PAGE)) {

			int uid = NpiInstanceRepository.getInstance().activeUid();

			if(graphs[graphIndex] != null){

				return graphs[graphIndex];

			}

			// get first item that is null in graph array

			int index = 0;

			while(index < graphs.length){

				if( graphs[index] == null){

					break;

				}

				index++;

			}

			if(index < graphs.length){

				graphs[index] = new IrqTraceGraph(index, this, uid);

				return graphs[index];

			}

		}

		return null;

	}

	/**

	 * Fetches thread name for one sample from the address plug-in

	 * 

	 * @param sample

	 *            sample

	 * @return thread name

	 */

	@SuppressWarnings("unchecked")

	private String getThreadName(IrqSample sample) {

		if (sample.getType() == IrqSample.TYPE_SWI) {

			// fetch trace information from address plug-in

			ParsedTraceData ptd = TraceDataRepository.getInstance().getTrace(

					NpiInstanceRepository.getInstance().activeUid(),

					GppTrace.class);

			// if trace data or static data cannot be found

			if (ptd == null || ptd.staticData == null) {

				return Messages.IrqTrace_0

						+ Long.toHexString(sample.getThreadValue());

			}

			// Get that contains name for thread

			ArrayList al = ptd.staticData.getColumnMatch(Messages.IrqTrace_1,

			if (al.size() > 0) {

				return (String) al.get(0);

			} else {

				return Messages.IrqTrace_3

						+ Long.toHexString(sample.getThreadValue());

			}

		}

		return Messages.IrqTrace_4;

	}

	/**

	 * Gathers data that is needed for drawing graph.

	 */

	public void gatherDrawData() {

		boolean readThreadNamesFromTrace = false;

		// if hash containing thread names is not found(meaning that dat file

		// has just been imported) load thread names from trace.

		if (threadToName == null) {

			threadToName = new Hashtable<Long, String>();

			readThreadNamesFromTrace = true;

		}

		if(colorsOfThreadsAndLines == null){

			colorsOfThreadsAndLines = new Hashtable<String, RGB>();

		}

		// reset all vectors and Hashtables that are just for optimizing drawing

		allThreadWrappers = new Vector<SwiThreadWrapper>();

		swiTable = new Hashtable<Long, IrqSampleTypeWrapper>();

		irqTable = new Hashtable<Long, IrqSampleTypeWrapper>();

		threadToOffset = new Hashtable<Long, Integer>();

		this.irqToOffset = new Hashtable<Long, Integer>();

		threadsToFunctions = new Hashtable<String, Hashtable<String, ArrayList<Long>>>();

		colorSet = new HashSet<RGB>();

		Hashtable<Long, Hashtable<Long, Integer>> irqLines = new Hashtable<Long, Hashtable<Long, Integer>>();

		int swiOffset = 0;

		int irqOffset = 0;

		maxAmountOfSWISamples = 1;

		maxAmountOfIRQSamples = 1;

		int amountOfSamples = 0;

		long previousTimeCode = 0;

		// go thru all samples from trace

		Enumeration<GenericSample> enumeration = this.getSamples();

		while (enumeration.hasMoreElements()) {

			IrqSample sample = (IrqSample) enumeration.nextElement();

			long val = 0;

			long valL = 0;

			Hashtable<Long, IrqSampleTypeWrapper> table = new Hashtable<Long, IrqSampleTypeWrapper>();

			// if this is software interrupt

			if (sample.getType() == IrqSample.TYPE_SWI) {

				val = sample.getLrValue();

				table = swiTable;

				String threadName = Messages.IrqTrace_5;

				// Get thread name

				if (readThreadNamesFromTrace) {

					threadName = getThreadName(sample);

				} else {

					threadName = threadToName.get(sample.getThreadValue());

				}

				if(sample.getFunction()!= null){

					this.functionNamesFound = true;

					// Add thread into threadsToFunctions hash if needed

					if (!threadsToFunctions.containsKey(threadName)) {

						// Create new item into thread section

						Hashtable<String, ArrayList<Long>> functionTable = new Hashtable<String, ArrayList<Long>>();

						ArrayList<Long> list = new ArrayList<Long>();

						list.add(sample.sampleSynchTime);

						functionTable.put(sample.getFunction().getFunctionName(), list);

						threadsToFunctions.put(threadName, functionTable);

						previousTimeCode = sample.sampleSynchTime;

						amountOfSamples = 1;

					} else {

						// add sample to existing thread

						// check if previous sample from this thread was from same

						// time frame and increase amountOfSamples if needed

						if (sample.sampleSynchTime == previousTimeCode) {

							amountOfSamples++;

						} else {

							// check is amount of samples from previous tim frame

							// was greater than maximum amount of interrupts so far

							if (amountOfSamples > maxAmountOfSWISamples) {

								maxAmountOfSWISamples = amountOfSamples;

							}

							amountOfSamples = 0;

							previousTimeCode = sample.sampleSynchTime;

						}

						// get thread's hashtable containing all its functions

						Hashtable<String, ArrayList<Long>> functionSet = threadsToFunctions

								.get(threadName);

						String functionName = sample.getFunction().getFunctionName();

						if (!functionSet.containsKey(functionName)) {

							// add new function into table

							ArrayList<Long> list = new ArrayList<Long>();

							list.add(sample.sampleSynchTime);

							functionSet

									.put(sample.getFunction().getFunctionName(), list);

						} else {

							functionSet.get(functionName).add(

									sample.sampleSynchTime);

						}

					}

				}				

				// if thread is not yet found from threadToOffset

						.getThreadValue()))) {

							Integer.valueOf(swiOffset++));

					// read thread names from trace if needed

					if (readThreadNamesFromTrace) {

						try {

									.getThreadValue()), this

									.getThreadName(sample));

						} catch (NullPointerException e1) {

							this.threadToName

											Messages.IrqTrace_6

													+ Long.toHexString(sample

															.getThreadValue()));

						}

					}

					// create thread wrapper for the thread and add it to allThreadWrappers

					SwiThreadWrapper wrapper = new SwiThreadWrapper();

					wrapper.threadName = threadToName.get(sample

							.getThreadValue());

					this.allThreadWrappers.add(wrapper);

				}

			// if this is hardware interrupt

			} else if (sample.getType() == IrqSample.TYPE_IRQ) {

				val = sample.getIrqL1Value() + (sample.getIrqL2Value() << 8);

				table = irqTable;

							Integer.valueOf(irqOffset++));

				}

				// if line is already found from irq line hashtable

				if (!irqLines.containsKey(val)) {

					Hashtable<Long, Integer> hashTable = new Hashtable<Long, Integer>();

					hashTable.put(val, 1);

					irqLines.put(val, hashTable);

				} else {

					Hashtable<Long, Integer> interrupts = irqLines.get(val);

					// if event at this timeframe is not found yet

					if (!interrupts.containsKey(sample.sampleSynchTime)) {

						interrupts.put(sample.sampleSynchTime, 1);

					} else {

						int previousValue = interrupts

								.get(sample.sampleSynchTime);

						interrupts.put(sample.sampleSynchTime,

								previousValue + 1);

						// check if value is greater than max amount of interrupts 

						if (previousValue + 1 > maxAmountOfIRQSamples) {

							maxAmountOfIRQSamples = previousValue + 1;

						}

					}

				}

			} else {

				throw new ArrayIndexOutOfBoundsException();

			}

			// Add interrupts into its sampleTypeWrapper or create one if needed

			if (!table.containsKey(valL)) {

				IrqSampleTypeWrapper w = new IrqSampleTypeWrapper(sample,

						colorSet, colorsOfThreadsAndLines);

				table.put(valL, w);

			} else {

				IrqSampleTypeWrapper w = (IrqSampleTypeWrapper) table.get(valL);

				w.addSample(sample);

			}

		}

	}

	/**

	 * @return all thread wrappers vector

	 */

	public Vector<SwiThreadWrapper> getAllThreadWrappers() {

		return allThreadWrappers;

	}

	/**

	 * @return irq to offset hashtable

	 */

	public Hashtable<Long, Integer> getIrqToOffset() {

		return irqToOffset;

	}

	/**

	 * @return swi hashtable

	 */

	public Hashtable<Long, IrqSampleTypeWrapper> getSwiTable() {

		return swiTable;

	}

	/**

	 * @return irq hashtable

	 */

	public Hashtable<Long, IrqSampleTypeWrapper> getIrqTable() {

		return irqTable;

	}

	/**

	 * @return threadsToFunctions hashtable

	 */

	public Hashtable<String, Hashtable<String, ArrayList<Long>>> getThreadsToFunctions() {

		return threadsToFunctions;

	}

	/**

	 * @return max amount of swi interrupts per one timeframe

	 */

	public int getMaxAmountOfSWISamples() {

		return maxAmountOfSWISamples;

	}

	/**

	 * @return max amount of irq interrupts per one timeframe

	 */

	public int getMaxAmountOfIRQSamples() {

		return maxAmountOfIRQSamples;

	}

	/**

	 * @return thread and irq line colors

	 */

	public Hashtable<String, RGB> getColorsOfThreadsAndLines() {

		return colorsOfThreadsAndLines;

	}

	/**

	 * @return set containing all colors of the trace

	 */

	public HashSet<RGB> getColorSet(){

		return colorSet;

	}

	/**

	 * changes color of one thread or irq line

	 * @param wrapper threadwrapper

	 * @param newColor new color for item

	 */

	public void changeColorOfThreadOrIRQLine(IrqSampleTypeWrapper wrapper, RGB newColor){

		// save color into colorsets at trace information

		colorSet.remove(wrapper.rgb);

		colorSet.add(newColor);

		if(wrapper.getPrototypeSample().getType() == IrqSample.TYPE_IRQ){

			colorsOfThreadsAndLines.put(Long.toString(wrapper.getPrototypeSample().getIrqL1Value()), newColor);

		}

		else{

			if(wrapper.getPrototypeSample().getFunction() != null){

				colorsOfThreadsAndLines.put(wrapper.getPrototypeSample().getFunction().getFunctionName(), newColor);

			}

		}

		wrapper.rgb = newColor;

		for(IrqTraceGraph item : graphs){

			// refresh table and set editor window dirty so that it can be saved.

			if(wrapper.getPrototypeSample().getType() == IrqSample.TYPE_IRQ){

				item.irqLineUnchecked(wrapper);

				item.irqLineChecked(wrapper);

			}

			else{

				item.recalculateWholeGraph();

			}

		}

		PIPageEditor.currentPageEditor().setDirty();

	}

	/**

	 * updates all table viewers

	 */

	public void updateAllTableViewers(){

		for(IrqTraceGraph item : graphs){

			item.updateTableViewers();

		}

	}

	/**

	 * @return all graphs for this trace

	 */

	public IrqTraceGraph[] getGraphs() {

		return graphs;

	}

	/**

	 * @return true if function names are found from trace

	 */

	public boolean isFunctionNamesFound() {

		return functionNamesFound;

	}

}