/*

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

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Iterator;

import java.util.LinkedList;

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.viewers.CheckboxTableViewer;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.MouseMoveListener;

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.Label;

import org.eclipse.swt.widgets.Sash;

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.GenericSampledTrace;

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.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.internal.pi.visual.PIEventListener;

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

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

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

public class GppTraceGraph extends GenericTraceGraph implements ActionListener, 

																FocusListener, 

																PIEventListener,

																MouseMotionListener,

																MouseListener,

																MouseMoveListener

{

	private GppTraceGraph thisTraceGraph;

	// amount of space at bottom of graph to contain things like x-axis units and button icons

	public static final int xLegendHeight = 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.

	private static int granularityValue = 100;

	private GppVisualiserPanel vPanel;

	/*

	 *  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

	 */

	private AddrThreadTable   threadTable;

	private AddrBinaryTable   binaryTable;

	private 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.

	 */

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

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

	private 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>();

	private ProfiledThreshold thresholdThread   = new ProfiledThreshold("dummy[0]::dummy_0"); //$NON-NLS-1$

	private ProfiledThreshold thresholdBinary   = new ProfiledThreshold("\\dummy"); //$NON-NLS-1$

	private ProfiledThreshold thresholdFunction = new ProfiledThreshold("dummy::dummy()"); //$NON-NLS-1$

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

	private Sash leftSash;

	private Sash rightSash;

	public static final int NOFILL       = 0;

	public static final int FILLSELECTED = 1;

	public static final int FILLALL      = 2;

	public static final int BAR_MODE_ON  = 3;

	public static final int BAR_MODE_OFF = 4;

	private int drawMode = Defines.THREADS;

	public int barMode   = BAR_MODE_OFF;

	private int uid;

	private static class BarGraphData

	{

		public int x;

		public Color color;

	}

	private Vector<BarGraphData> barGraphData;

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

	{

		super((GenericSampledTrace)trace);

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

		this.thisTraceGraph = this;

		this.graphIndex     = graphIndex;

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

		ProfileVisualiser pV = NpiInstanceRepository.getInstance().getProfilePage(uid, graphIndex);

		Composite holdTables = new Composite(pV.getBottomComposite(), SWT.NONE);

		holdTables.setLayout(new FormLayout());

		this.threadTable   = new AddrThreadTable(this, holdTables);

		this.binaryTable   = new AddrBinaryTable(this, holdTables);

		this.functionTable = new AddrFunctionTable(this, holdTables);

		this.uid = uid;

		Label graphTitle = pV.getTitle();

		Label graphTitle2 = pV.getTitle2();

		if 	(graphTitle2 != null)

			graphTitle2.setText(""); //$NON-NLS-1$

		// initialize the threshold counts

		int totalSampleCount = trace.getSampleAmount();

		NpiInstanceRepository.getInstance().setPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountThread", new Integer(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", new Integer(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", new Integer(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

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

		thresholdThread.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

		{

			thresholdThread.zeroActivityMarkValues(i * samplingInterval);

		}

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

		thresholdBinary.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

		{

			thresholdBinary.zeroActivityMarkValues(i * samplingInterval);

		}

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

		thresholdFunction.setActivityMarkCount((trace.samples.size() + granularityValue) / granularityValue + 1);

		for (int i = 0; i < trace.samples.size() + granularityValue; i += granularityValue)

		{

			thresholdFunction.zeroActivityMarkValues(i * samplingInterval);

		}

		// all the trace data is known, and you have it sorted 3 different ways

		// so set the drawmode, create the page's base table, and set the graph title

		if (graphIndex == PIPageEditor.THREADS_PAGE) {

			this.drawMode = Defines.THREADS;

			// tables will show threads in decreasing total sample order, but

			// then put them back in increasing sample order so that the graph

			// shows most common (e.g., EKern) threads on top

			this.profiledThreads.clear();

			for (int i = trace.getSortedThreads().size() - 1; i >= 0; i--)

				this.profiledThreads.add(trace.getSortedThreads().get(i));

			filterSortedByThreshold(graphIndex, 

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

									thresholdThread, this.profiledThreads);

			this.threadTable.setTableViewer(Defines.THREADS);

			this.profiledThreads = trace.getSortedThreads();

			graphTitle.setText(Messages.getString("GppTraceGraph.threadLoad"));  //$NON-NLS-1$

		} else

		if (graphIndex == PIPageEditor.BINARIES_PAGE) {

			this.drawMode = Defines.BINARIES;

			// tables will show binaries in decreasing total sample order, but

			// then put them back in increasing sample order so that the graph

			// shows most common (e.g., EKern) binaries on top

			this.profiledBinaries.clear();

			for (int i = trace.getSortedBinaries().size() - 1; i >= 0; i--)

				this.profiledBinaries.add(trace.getSortedBinaries().get(i));

			filterSortedByThreshold(graphIndex, (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountBinary"), //$NON-NLS-1$

								thresholdBinary, this.profiledBinaries);

			this.binaryTable.setTableViewer(Defines.BINARIES);

			this.profiledBinaries = trace.getSortedBinaries();

			graphTitle.setText(Messages.getString("GppTraceGraph.binaryLoad"));  //$NON-NLS-1$

		} else

		if (graphIndex == PIPageEditor.FUNCTIONS_PAGE) {

			this.drawMode = Defines.FUNCTIONS;

			// tables will show functions in decreasing total sample order, but

			// then put them back in increasing sample order so that the graph

			// shows most common (e.g., EKern) functions on top

			this.profiledFunctions.clear();

			for (int i = trace.getSortedFunctions().size() - 1; i >= 0; i--)

				this.profiledFunctions.add(trace.getSortedFunctions().get(i));

			filterSortedByThreshold(graphIndex, (Integer)NpiInstanceRepository.getInstance().getPersistState(uid, "com.nokia.carbide.cpp.pi.address.thresholdCountFunction"), //$NON-NLS-1$

								thresholdFunction, this.profiledFunctions);

			this.functionTable.setTableViewer(Defines.FUNCTIONS);

			this.profiledFunctions = trace.getSortedFunctions();

			graphTitle.setText(Messages.getString("GppTraceGraph.FunctionLoad"));  //$NON-NLS-1$

		} else

		{

			try {

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

			} catch (Exception e) {

				e.printStackTrace();

			}

		}

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

	}

	/*

	 * Combine all vectors elements that are below the threshold into a single

	 * vector element. Assumes that the input vector is sorted by decreasing sample count.

	 */

	private void filterSortedByThreshold(int graphIndex, int thresholdCount, ProfiledThreshold pThreshold, Vector<ProfiledGeneric> pGenerics)

	{

		// count and remove items below the threshold 

		for (int i = pGenerics.size() - 1; i >= 0; i--) {

			if (pGenerics.elementAt(i).getTotalSampleCount() < thresholdCount) {

				pThreshold.addItem(graphIndex, pGenerics.elementAt(i), 0);

				pGenerics.removeElementAt(i);

			} else {

				break;

			}

		}

	}

	public GppTrace getGppTrace() {

		return (GppTrace)this.getTrace();

	}

	public int getGraphIndex()

	{

		return this.graphIndex;

	}

	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

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

				trace.setSelectedArea();

				// 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)

								sampleCount += profiledBinaries.elementAt(i).getSampleCount(graphIndex);

						thresholdBinary.setSampleCount(this.graphIndex, sampleCount);

					}

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

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

					if (thresholdCount > 0) {

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

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

								sampleCount += profiledFunctions.elementAt(i).getSampleCount(graphIndex);

						thresholdFunction.setSampleCount(this.graphIndex, sampleCount);

					}

				}

				double startTime = PIPageEditor.currentPageEditor().getStartTime();

				double endTime   = PIPageEditor.currentPageEditor().getEndTime();

				// send this message to the 2 other GPP graphs

				PIEvent be2 = new PIEvent(be.getValueObject(),

						PIEvent.SELECTION_AREA_CHANGED2);

				// update the selection area shown

				for (int i = 0; i < 3; i++)

				{

					GppTraceGraph graph = trace.getGppGraph(i, getUid());

					if (graph != this) {

						graph.piEventReceived(be2);

						// once per graph, update the selection interval shown

						graph.getCompositePanel().getVisualiser().getTimeString().setText(ProfileVisualiser.getTimeInterval(startTime, endTime));

					}

					// change the graph's selected time interval

					graph.setSelectionStart((double) startTime * 1000);

					graph.setSelectionEnd((double) endTime * 1000);

					graph.parentComponent.setSelectionFields((int)(startTime * 1000), (int)(endTime * 1000));

				}

				this.parentComponent.getSashForm().redraw();

				be = be2;

				// FALL THROUGH

			case PIEvent.SELECTION_AREA_CHANGED2:

			{

				// this code lets each graph's base thread/binary/function table update the other tables

				switch (drawMode)

				{

					case Defines.THREADS:

					case Defines.THREADS_FUNCTIONS:

					case Defines.THREADS_FUNCTIONS_BINARIES:

					case Defines.THREADS_BINARIES:

					case Defines.THREADS_BINARIES_FUNCTIONS:

				    {

				        this.threadTable.piEventReceived(be);

				        break;

				    }

					case Defines.BINARIES:

					case Defines.BINARIES_THREADS:

					case Defines.BINARIES_THREADS_FUNCTIONS:

					case Defines.BINARIES_FUNCTIONS:

					case Defines.BINARIES_FUNCTIONS_THREADS:

					{

				        this.binaryTable.piEventReceived(be);

						break;

					}

					case Defines.FUNCTIONS:

					case Defines.FUNCTIONS_THREADS:

					case Defines.FUNCTIONS_THREADS_BINARIES:

					case Defines.FUNCTIONS_BINARIES:

					case Defines.FUNCTIONS_BINARIES_THREADS:

					{

				        this.functionTable.piEventReceived(be);

						break;

					}

				}

				this.vPanel.refreshCumulativeThreadTable();

				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

				this.repaint();

				break;

			}

			// in the graph, show all values from the rightmost table

			case PIEvent.SET_FILL_ALL_THREADS:

				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

				this.vPanel.piEventReceived(be);

				break;

			// in the graph, don't fill between the lines will the color of

			// the line above

			case PIEvent.SET_FILL_OFF:

				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

				this.vPanel.piEventReceived(be);

				break;

			// in the graph, show bars

			case PIEvent.GPP_SET_BAR_GRAPH_ON:

				this.vPanel.piEventReceived(be);

				break;

			// in the graph, show polylines 

			case PIEvent.GPP_SET_BAR_GRAPH_OFF:

				this.vPanel.piEventReceived(be);

				break;

			// in the graph, show only the values from selected rows in the

			// rightmost table

			case PIEvent.SET_FILL_SELECTED_THREAD:

				this.setGraphImageChanged(true);	// any selection change to drill down will change graph

				this.vPanel.piEventReceived(be);

				break;

			// Redraw the graph because the thread table's selected values have changed.

			// The thread table is handled (setting of array of selected threads

			// and table redraw) by the table selection listener or mouse listener.

			case PIEvent.CHANGED_THREAD_TABLE:

				switch (drawMode)

				{

					case Defines.THREADS_BINARIES:

					case Defines.THREADS_BINARIES_FUNCTIONS:

					case Defines.THREADS_FUNCTIONS:

					case Defines.THREADS_FUNCTIONS_BINARIES: