/*

 * 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: 

 *

 */

/*

 * GppTraceGraph.java

 */

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

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Vector;

import org.eclipse.draw2d.FigureCanvas;

import org.eclipse.draw2d.Graphics;

import org.eclipse.draw2d.MouseEvent;

import org.eclipse.draw2d.MouseListener;

import org.eclipse.draw2d.MouseMotionListener;

import org.eclipse.draw2d.Panel;

import org.eclipse.jface.action.Action;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.MouseMoveListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Point;

import org.eclipse.swt.graphics.RGB;

import org.eclipse.swt.graphics.Rectangle;

import org.eclipse.swt.layout.FormLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.swt.widgets.Sash;

import com.nokia.carbide.cpp.internal.pi.address.GppModelAdapter;

import com.nokia.carbide.cpp.internal.pi.address.GppTraceGraphSMP;

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

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

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

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

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

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

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

import com.nokia.carbide.cpp.internal.pi.plugin.model.IContextMenu;

import com.nokia.carbide.cpp.internal.pi.plugin.model.ITitleBarMenu;

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

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

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

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

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

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

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

import com.nokia.carbide.cpp.pi.visual.IGenericTraceGraph;

/**

 * Each instance of this class represents one trace graph for profiling

 * CPU activity. 

 *

 */

public class GppTraceGraph extends GenericTraceGraph implements IGppTraceGraph,

		ActionListener, FocusListener, MouseMotionListener, MouseListener,

		MouseMoveListener, ITitleBarMenu, IContextMenu {

	/**

	 * amount of space at bottom of graph to contain things like x-axis units

	 * and button icons

	 */

	public static final int X_LEGEND_HEIGHT = 50;

	/**

	 * When the graph is drawn, this is the finest granularity drawn. E.g.,

	 * assume a granularity of 100, and a sample every ms. If the 1st function

	 * draw appears in 5 samples from 101ms to 200ms and 10 samples from 200ms

	 * to 300ms then the graph will show a point at height 5 at time 200

	 * connected by a line to a point at height 10 at time 300.

	 */

	static final int GRANULARITY_VALUE = 100;

	/** constant to indicate graph is a bar graph */

	public static final int BAR_MODE_ON = 3;

	/** constant to indicate graph is stacked-area graph */

	public static final int BAR_MODE_OFF = 4;

	private static final String EMPTY_STRING = "";//$NON-NLS-1$ 

	protected GppVisualiserPanel vPanel;

	protected String title;

	protected String shortTitle;

	/*

	 * Depending on this trace graph's graphIndex, one of these will be the base

	 * table, and others will be derived from its selections. The other tables

	 * will appear and disappear based on drawMode.

	 * 

	 * E.g., say that for graphIndex = 0, the base table is threadTable. Then

	 * this graph can represent the draw modes of: THREADS THREADS_BINARIES

	 * THREADS_BINARIES_FUNCTIONS THREADS_FUNCTIONS THREADS_FUNCTIONS_BINARIES

	 */

	protected AddrThreadTable threadTable;

	protected AddrBinaryTable binaryTable;

	protected AddrFunctionTable functionTable;

	/*

	 * Depending on this trace graph's graphIndex, one of these will match the

	 * entire trace's profiled vector, while the others will be derived from

	 * drilldown selections. The other vectors will only be meaningful depending

	 * on the drawMode.

	 */

	protected Vector<ProfiledGeneric> profiledThreads = new Vector<ProfiledGeneric>();

	protected Vector<ProfiledGeneric> profiledBinaries = new Vector<ProfiledGeneric>();

	protected Vector<ProfiledGeneric> profiledFunctions = new Vector<ProfiledGeneric>();

	private Vector<ProfiledGeneric> sortedProfiledThreads = new Vector<ProfiledGeneric>();

	private Vector<ProfiledGeneric> sortedProfiledBinaries = new Vector<ProfiledGeneric>();

	private Vector<ProfiledGeneric> sortedProfiledFunctions = new Vector<ProfiledGeneric>();

	protected ProfiledThreshold thresholdThread;

	private ProfiledThreshold thresholdBinary;

	private ProfiledThreshold thresholdFunction;

	// when multiple tables are visible, they are separated by sashes

	private Sash leftSash;

	private Sash rightSash;

	protected int drawMode = Defines.THREADS;

	/** current graph drawing mode: either bar or stacked-area graph */

	public int barMode = BAR_MODE_OFF;

	protected int uid;

	private static class BarGraphData {

		public int x;

		public Color color;

	}

	private Vector<BarGraphData> barGraphData;

	/**

	 * The model adapter hides some of the SMP specifics. It must be created

	 * during initialisation of this graph.

	 */

	protected GppModelAdapter adapter;

	/** main Composite of legend view */

	private Composite holdTablesComposite;

	/**

	 * Constructor

	 * 

	 * @param graphIndex

	 *            the unique index of this graph

	 * @param trace

	 *            the trace data model to use

	 * @param uid

	 *            the Uid of the editor session

	 */

	public GppTraceGraph(int graphIndex, GppTrace trace, int uid) {

		super(trace);

		this.graphIndex = graphIndex;

		this.uid = uid;

	}

	/**

	 * Initialises the graph.

	 * 

	 * @param pageIndex

	 *            page index of the page which displays the graph

	 * @param trace

	 *            the trace model

	 */

	public void init(int pageIndex, GppTrace trace) {

		doCreateAdapter();

		doSetTitle();

		int granularityValue = trace.samples.size() > GppTraceGraph.GRANULARITY_VALUE ? GppTraceGraph.GRANULARITY_VALUE

				: trace.samples.size();

		// create the graph's 3 table objects - without any table items yet

		ProfileVisualiser pV = NpiInstanceRepository.getInstance()

				.getProfilePage(uid, pageIndex);

		holdTablesComposite = trace.createLegendComposite(pageIndex, graphIndex, pV.getBottomComposite(), getShortTitle());

		holdTablesComposite.setLayout(new FormLayout());

		createLegendTables(holdTablesComposite);

		// initialize the threshold counts

		int totalSampleCount = trace.getSampleAmount();

		// CH: this is called too many times (those values are global for the

		// whole trace) -> can we move it to GppTrace?

		NpiInstanceRepository

				.getInstance()

				.setPersistState(

						uid,

						"com.nokia.carbide.cpp.pi.address.thresholdCountThread", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadThread") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

		NpiInstanceRepository

				.getInstance()

				.setPersistState(

						uid,

						"com.nokia.carbide.cpp.pi.address.thresholdCountBinary", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadBinary") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

		NpiInstanceRepository

				.getInstance()

				.setPersistState(

						uid,

						"com.nokia.carbide.cpp.pi.address.thresholdCountFunction", Integer.valueOf(new Double(totalSampleCount * (Double) NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdLoadFunction") + 0.5).intValue())); //$NON-NLS-1$ //$NON-NLS-2$

		int samplingInterval = (Integer) NpiInstanceRepository.getInstance()

				.activeUidGetPersistState(

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

		// initialize the threshold items

		int bucketDuration = granularityValue * samplingInterval;

		int numberOfBuckets = GppTraceUtil.calculateNumberOfBuckets(trace

				.getLastSampleTime(), granularityValue);

		thresholdThread = new ProfiledThreshold(

				"dummy[0]::dummy_0", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

		thresholdBinary = new ProfiledThreshold(

				"\\dummy", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

		thresholdFunction = new ProfiledThreshold(

				"dummy::dummy()", trace.getCPUCount(), trace.getGraphCount()); //$NON-NLS-1$

		thresholdThread.setColor(trace.getThreadColorPalette().getColor(

				thresholdThread.getNameString()));

		thresholdThread.createBuckets(numberOfBuckets);

		thresholdThread.initialiseBuckets(bucketDuration);

		thresholdBinary.setColor(trace.getBinaryColorPalette().getColor(

				thresholdBinary.getNameString()));

		thresholdBinary.createBuckets(numberOfBuckets);

		thresholdBinary.initialiseBuckets(bucketDuration);

		thresholdFunction.setColor(trace.getFunctionColorPalette().getColor(

				thresholdFunction.getNameString()));

		thresholdFunction.createBuckets(numberOfBuckets);

		thresholdFunction.initialiseBuckets(bucketDuration);

		int graphType = adapter.getGraphType();

		if (graphType == PIPageEditor.THREADS_PAGE) {

			this.drawMode = Defines.THREADS;

			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$

			for (ProfiledGeneric profiled : trace.getSortedThreads()) {

				if (adapter.getTotalSampleCount(profiled) > 0){

					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

						adapter.addItem(thresholdThread, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

					} else {

						profiledThreads.add(profiled);

					}

				}

			}

			this.threadTable.setTableViewer(Defines.THREADS);

			this.profiledThreads = trace.getSortedThreads();

		} else if (graphType == PIPageEditor.BINARIES_PAGE) {

			this.drawMode = Defines.BINARIES;

			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$

			for (ProfiledGeneric profiled : trace.getSortedBinaries()) {

				if (adapter.getTotalSampleCount(profiled) > 0){

					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

						adapter.addItem(thresholdBinary, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

					} else {

						profiledBinaries.add(profiled);

					}

				}

			}

			this.binaryTable.setTableViewer(Defines.BINARIES);

			this.profiledBinaries = trace.getSortedBinaries();

		} else if (graphType == PIPageEditor.FUNCTIONS_PAGE) {

			this.drawMode = Defines.FUNCTIONS;

			int threshold = (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction"); //$NON-NLS-1$

			for (ProfiledGeneric profiled : trace.getSortedFunctions()) {

				if (adapter.getTotalSampleCount(profiled) > 0){

					if (adapter.getTotalSampleCount(profiled) < threshold){//check below threshold

						adapter.addItem(thresholdFunction, graphIndex, profiled, adapter.getTotalSampleCount(profiled));

					} else {

						profiledFunctions.add(profiled);

					}

				}

			}

			this.functionTable.setTableViewer(Defines.FUNCTIONS);

			this.profiledFunctions = trace.getSortedFunctions();

		} else {

			throw new IllegalStateException(Messages

					.getString("GppTraceGraph.traceGraphInternalErrorIn")); //$NON-NLS-1$

		}

		// since the trace can be shown any of 3 ways (by thread, by binary, or

		// by function), make sure that all 3 are ready for display

		// Sse sorted vector to be consistent with other call to

		// genericRefreshCumulativeThreadTable()

		// fix issue with wrong color on newly opened npi file before a change

		// in the table

		if (this.profiledThreads.size() > 0) {

			genericRefreshCumulativeThreadTable(this.profiledThreads.elements());

			genericRefreshCumulativeThreadTable(this.sortedProfiledThreads

					.elements());

		}

		if (this.profiledBinaries.size() > 0) {

			genericRefreshCumulativeThreadTable(this.profiledBinaries

					.elements());

			genericRefreshCumulativeThreadTable(this.sortedProfiledBinaries

					.elements());

		}

		if (this.profiledFunctions.size() > 0) {

			genericRefreshCumulativeThreadTable(this.profiledFunctions

					.elements());

			genericRefreshCumulativeThreadTable(this.sortedProfiledFunctions

					.elements());

		}

		if (this.profiledThreads.size() <= 0

				&& this.profiledBinaries.size() <= 0

				&& this.profiledFunctions.size() <= 0) {

			try {

				throw new Exception(Messages

						.getString("GppTraceGraph.traceGraphInternalErrorAt")); //$NON-NLS-1$

			} catch (Exception e) {

				e.printStackTrace();

			}

		}

		this.vPanel = new GppVisualiserPanel(this);

	}

	/**

	 * Sets the graph-specific title

	 */

	protected void doSetTitle() {

		title = Messages.getString("GppTraceGraph.1");		 //$NON-NLS-1$

		shortTitle = Messages.getString("GppTraceGraph.0"); //$NON-NLS-1$

	}

	/**

	 * Creates a GppModelAdapter

	 */

	protected void doCreateAdapter() {

		adapter = new GppModelAdapter(this.graphIndex);

	}

	/**

	 * Creates the three legend tables for this graph (for threads, binaries,

	 * functions)

	 * 

	 * @param holdTablesComposite

	 */

	protected void createLegendTables(Composite holdTablesComposite) {

		this.threadTable = new AddrThreadTable(this, holdTablesComposite, adapter);

		this.binaryTable = new AddrBinaryTable(this, holdTablesComposite, adapter);

		this.functionTable = new AddrFunctionTable(this, holdTablesComposite, adapter);

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.nokia.carbide.cpp.pi.address.IGppTraceGraph#getGppTrace()

	 */

	public GppTrace getGppTrace() {

		return (GppTrace) this.getTrace();

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see

	 * com.nokia.carbide.cpp.internal.pi.visual.PIEventListener#piEventReceived

	 * (com.nokia.carbide.cpp.internal.pi.visual.PIEvent)

	 */

	public void piEventReceived(PIEvent be) {

		switch (be.getType()) {

		// determine the threads that can be shown, and get rid of all

		// drilldowns

		case PIEvent.THRESHOLD_THREAD_CHANGED:

			if (this.getGraphIndex() == PIPageEditor.THREADS_PAGE)

				this.getThreadTable().action("changeThresholdThread"); //$NON-NLS-1$

			switch (this.drawMode) {

			case Defines.THREADS:

			case Defines.THREADS_FUNCTIONS:

			case Defines.THREADS_FUNCTIONS_BINARIES:

			case Defines.THREADS_BINARIES:

			case Defines.THREADS_BINARIES_FUNCTIONS:

			case Defines.BINARIES_THREADS:

			case Defines.BINARIES_THREADS_FUNCTIONS:

			case Defines.BINARIES_FUNCTIONS_THREADS:

			case Defines.FUNCTIONS_THREADS:

			case Defines.FUNCTIONS_THREADS_BINARIES:

			case Defines.FUNCTIONS_BINARIES_THREADS:

				this.setGraphImageChanged(true);

			default:

				break;

			}

			break;

		case PIEvent.THRESHOLD_BINARY_CHANGED:

			if (this.getGraphIndex() == PIPageEditor.BINARIES_PAGE)

				this.getBinaryTable().action("changeThresholdBinary"); //$NON-NLS-1$

			switch (this.drawMode) {

			case Defines.THREADS_FUNCTIONS_BINARIES:

			case Defines.THREADS_BINARIES:

			case Defines.THREADS_BINARIES_FUNCTIONS:

			case Defines.BINARIES:

			case Defines.BINARIES_THREADS:

			case Defines.BINARIES_THREADS_FUNCTIONS:

			case Defines.BINARIES_FUNCTIONS:

			case Defines.BINARIES_FUNCTIONS_THREADS:

			case Defines.FUNCTIONS_THREADS_BINARIES:

			case Defines.FUNCTIONS_BINARIES:

			case Defines.FUNCTIONS_BINARIES_THREADS:

				this.setGraphImageChanged(true);

			default:

				break;

			}

			break;

		case PIEvent.THRESHOLD_FUNCTION_CHANGED:

			if (this.getGraphIndex() == PIPageEditor.FUNCTIONS_PAGE)

				this.getFunctionTable().action("changeThresholdFunction"); //$NON-NLS-1$

			switch (this.drawMode) {

			case Defines.THREADS_FUNCTIONS:

			case Defines.THREADS_FUNCTIONS_BINARIES:

			case Defines.THREADS_BINARIES_FUNCTIONS:

			case Defines.BINARIES_THREADS_FUNCTIONS:

			case Defines.BINARIES_FUNCTIONS:

			case Defines.BINARIES_FUNCTIONS_THREADS:

			case Defines.FUNCTIONS:

			case Defines.FUNCTIONS_THREADS:

			case Defines.FUNCTIONS_THREADS_BINARIES:

			case Defines.FUNCTIONS_BINARIES:

			case Defines.FUNCTIONS_BINARIES_THREADS:

				this.setGraphImageChanged(true);

			default:

				break;

			}

			break;

		// when the selection area changes, change the percent loads

		// and the sample counts in all tables of this GPP graph

		case PIEvent.SELECTION_AREA_CHANGED:

			// this is the first GPP graph to be told of the selection area

			// change,

			// so it gathers the overall trace information

			double doubleStartTime = PIPageEditor.currentPageEditor()

					.getStartTime();

			double doubleEndTime = PIPageEditor.currentPageEditor()

					.getEndTime();

			GppTrace trace = (GppTrace) this.getTrace();

			trace.setSelectedArea(doubleStartTime, doubleEndTime);

			// take care of the threshold members

			int sampleCount = 0;

			int thresholdCount;

			if (graphIndex == PIPageEditor.THREADS_PAGE) {

				thresholdCount = (Integer) NpiInstanceRepository

						.getInstance()

						.getPersistState(uid,

								"com.nokia.carbide.cpp.pi.address.thresholdCountThread"); //$NON-NLS-1$

				if (thresholdCount > 0) {

					for (int i = 0; i < profiledThreads.size(); i++)

						if (profiledThreads.elementAt(i).getTotalSampleCount() < thresholdCount)

							sampleCount += profiledThreads.elementAt(i)

									.getSampleCount(graphIndex);

					thresholdThread

							.setSampleCount(this.graphIndex, sampleCount);

				}

			} else if (graphIndex == PIPageEditor.BINARIES_PAGE) {

				thresholdCount = (Integer) NpiInstanceRepository

						.getInstance()

						.getPersistState(uid,

								"com.nokia.carbide.cpp.pi.address.thresholdCountBinary"); //$NON-NLS-1$

				if (thresholdCount > 0) {

					for (int i = 0; i < profiledBinaries.size(); i++)

						if (profiledBinaries.elementAt(i).getTotalSampleCount() < thresholdCount)