/*

 * 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.awt.Toolkit;

import java.awt.datatransfer.Clipboard;

import java.awt.datatransfer.StringSelection;

import java.awt.event.MouseEvent;

import java.util.ArrayList;

import java.util.Enumeration;

import java.util.Vector;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.ActionContributionItem;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.action.IContributionManager;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.SubMenuManager;

import org.eclipse.jface.wizard.Wizard;

import org.eclipse.jface.wizard.WizardDialog;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.FocusListener;

import org.eclipse.swt.events.MouseListener;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Decorations;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.ui.IActionBars;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.actions.ActionFactory;

import org.eclipse.ui.ide.IIDEActionConstants;

import com.nokia.carbide.cpp.internal.pi.interfaces.ISaveSamples;

import com.nokia.carbide.cpp.internal.pi.interfaces.ISaveTable;

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.save.SaveTableWizard;

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

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

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

public abstract class GenericAddrTable extends GenericTable

{

	protected GppTraceGraph myGraph;

	protected Composite     parent;

	// sorting column and order

	protected int     sortColumn = COLUMN_ID_SAMPLE_COUNT;

	protected boolean sortAscending;

	protected GppTableSorter sorter;

	protected boolean sorting = false;

	abstract protected Menu getTableMenu(Decorations parent, int graphIndex, int drawMode);

	protected boolean isDrilldown = false;

	// menu items

	protected Action selectAllAction;

	protected Action copyTableAction;

	protected Action copyAction;

	protected Action copyDrilldownAction;

	protected Action saveTableAction;

	protected Action saveDrilldownAction;

	protected static int SAMPLES_AT_ONE_TIME = 1000;

	// class to pass sample data to the save wizard

    public class SaveSampleString implements ISaveSamples {

     	int graphIndex;

    	int drawMode;

    	int startIndex = 0;

    	public SaveSampleString(int graphIndex, int drawMode) {

    		this.graphIndex = graphIndex;

    		this.drawMode   = drawMode;

		}

    	public String getData() {

    		return getData(SAMPLES_AT_ONE_TIME);

		}

		public String getData(int size) {

			String returnString = getSampleString(graphIndex, drawMode, this.startIndex, this.startIndex + size);

    		if (returnString == null)

    			this.startIndex = 0;

    		else

    			this.startIndex += size;

			return returnString;

		}

		public int getIndex() {

			return this.startIndex;

		}

		public void clear() {

			this.startIndex = 0;

		}

    }

	protected MenuItem getSaveSamplesItem(Menu menu, String sampleType, boolean enabled) {

	    MenuItem saveSamplesItem = new MenuItem(menu, SWT.PUSH);

		saveSamplesItem.setText(Messages.getString("GenericAddrTable.saveSamples1") + sampleType + Messages.getString("GenericAddrTable.saveSamples2"));   //$NON-NLS-1$ //$NON-NLS-2$

		saveSamplesItem.setEnabled(enabled);

		if (enabled) {

			saveSamplesItem.addSelectionListener(new SelectionAdapter() { 

				public void widgetSelected(SelectionEvent e) {

					action("saveSamples"); //$NON-NLS-1$

				}

			});

		}

		return saveSamplesItem;

	}

	public GppTraceGraph getGraph() {

		return myGraph;

	}

	protected class TableMouseListener implements MouseListener

	{

		public void mouseDoubleClick(org.eclipse.swt.events.MouseEvent e) {

			if (e.button == MouseEvent.BUTTON1)

			{

				TableItem[] selectedItems = table.getSelection();

				if (selectedItems.length == 0)

					return;

				if (selectedItems[0].getData() instanceof ProfiledGeneric)

				{

					ProfiledGeneric pg = (ProfiledGeneric)(selectedItems[0].getData());

				    if (pg.isEnabled(myGraph.getGraphIndex()))

				        action("remove"); //$NON-NLS-1$

				    else

				        action("add"); //$NON-NLS-1$

				    action("doubleClick");  //$NON-NLS-1$

				}

			}

		}

		public void mouseDown(org.eclipse.swt.events.MouseEvent e) {

		}

		public void mouseUp(org.eclipse.swt.events.MouseEvent e) {

			if (e.button == MouseEvent.BUTTON3) {

				Menu menu = getTableMenu(table.getShell(), myGraph.getGraphIndex(), myGraph.getDrawMode());

				menu.setLocation(parent.toDisplay(e.x + table.getLocation().x, e.y + table.getLocation().y));

				table.setMenu(menu);

			}

		}

	}

	public void setVisualisationColumnVisible(boolean flag) {}

	public void valueChanged(SelectionEvent e) {}

	protected Vector<ProfiledGeneric> setTableItemData(Enumeration<ProfiledGeneric> enu) {

	    Vector<ProfiledGeneric> tmpItems = new Vector<ProfiledGeneric>();

	    while (enu.hasMoreElements())

		{

		    tmpItems.add(enu.nextElement());

		}

		return tmpItems;

	}

	protected void addDrillDownItems(Menu tableMenu, int drawMode)

	{

		switch (drawMode)

		{

			case Defines.THREADS:

			{

				// thread drill down items

				threadItem        (tableMenu, true);

				threadBinaryItem  (tableMenu, false);

				threadFunctionItem(tableMenu, false);

				break;

			}

			case Defines.THREADS_BINARIES:

			{

				// thread drill down items

				threadItem              (tableMenu, false);

				threadBinaryItem        (tableMenu, true);

				threadBinaryFunctionItem(tableMenu, false);

				break;

			}

			case Defines.THREADS_BINARIES_FUNCTIONS:

			{

				// thread drill down items

				threadItem              (tableMenu, false);

				threadBinaryItem        (tableMenu, false);

				threadBinaryFunctionItem(tableMenu, true);

				break;

			}

			case Defines.THREADS_FUNCTIONS:

			{

				// thread drill down items

				threadItem             (tableMenu, false);

				threadFunctionItem     (tableMenu, true);

				newThreadFunctionBinary(tableMenu, false);

				break;

			}

			case Defines.THREADS_FUNCTIONS_BINARIES:

			{

				// thread drill down items

				threadItem             (tableMenu, false);

				threadFunctionItem     (tableMenu, false);

				newThreadFunctionBinary(tableMenu, true);

				break;

			}

			case Defines.BINARIES:

			{

				// binary drill down items

				binaryItem        (tableMenu, true);

				binaryThreadItem  (tableMenu, false);

				binaryFunctionItem(tableMenu, false);

				break;

			}

			case Defines.BINARIES_THREADS:

			{

				// binary drill down items

				binaryItem              (tableMenu, false);

				binaryThreadItem        (tableMenu, true);

				binaryThreadFunctionItem(tableMenu, false);

				break;

			}

			case Defines.BINARIES_THREADS_FUNCTIONS:

			{

				// binary drill down items

				binaryItem              (tableMenu, false);

				binaryThreadItem        (tableMenu, false);

				binaryThreadFunctionItem(tableMenu, true);

				break;

			}

			case Defines.BINARIES_FUNCTIONS:

			{

				// binary drill down items

				binaryItem              (tableMenu, false);

				binaryFunctionItem      (tableMenu, true);

				binaryFunctionThreadItem(tableMenu, false);

				break;

			}

			case Defines.BINARIES_FUNCTIONS_THREADS:

			{

				// binary drill down items

				binaryItem              (tableMenu, false);

				binaryFunctionItem      (tableMenu, false);

				binaryFunctionThreadItem(tableMenu, true);

				break;

			}

			case Defines.FUNCTIONS:

			{

				// function drill down items 

				functionItem      (tableMenu, true);

				functionThreadItem(tableMenu, false);

				functionBinaryItem(tableMenu, false);

				break;

			}

			case Defines.FUNCTIONS_THREADS:

			{

				// function drill down items 

				functionItem            (tableMenu, false);

				functionThreadItem      (tableMenu, true);

				functionThreadBinaryItem(tableMenu, false);

				break;

			}

			case Defines.FUNCTIONS_THREADS_BINARIES:

			{

				// function drill down items 

				functionItem            (tableMenu, false);

				functionThreadItem      (tableMenu, false);

				functionThreadBinaryItem(tableMenu, true);

				break;

			}

			case Defines.FUNCTIONS_BINARIES:

			{

				// function drill down items 

				functionItem            (tableMenu, false);

				functionBinaryItem      (tableMenu, true);

				functionBinaryThreadItem(tableMenu, false);

				break;

			}

			case Defines.FUNCTIONS_BINARIES_THREADS:

			{

				// function drill down items 

				functionItem            (tableMenu, false);

				functionBinaryItem      (tableMenu, false);

				functionBinaryThreadItem(tableMenu, true);

				break;

			}

			default:

				break;

		}

	}

	/*

	 * Find if any threads with checkboxes checked

	 */

	protected boolean haveCheckedThread(GppTrace trace, int graphIndex)

	{

		ProfiledThread pThread;

		for (ProfiledGeneric pGeneric: trace.getIndexedThreads()) {

			if (pGeneric instanceof ProfiledThread) {

				pThread = (ProfiledThread) pGeneric;

				if (pThread.isEnabled(graphIndex))

					return true;

			}

		}

		return false;

	}

	/*

	 * Find if any binaries with checkboxes checked

	 */

	protected boolean haveCheckedBinary(GppTrace trace, int graphIndex)

	{

		ProfiledBinary pBinary;

		for (ProfiledGeneric pGeneric: trace.getIndexedBinaries()) {

			if (pGeneric instanceof ProfiledBinary) {

				pBinary = (ProfiledBinary) pGeneric;

				if (pBinary.isEnabled(graphIndex))

					return true;

			}

		}

		return false;

	}

	/*

	 * Find if any functions with checkboxes checked

	 */

	protected boolean haveCheckedFunction(GppTrace trace, int graphIndex)

	{

		ProfiledFunction pFunction;

		for (ProfiledGeneric pGeneric: trace.getIndexedFunctions()) {

			if (pGeneric instanceof ProfiledFunction) {

				pFunction = (ProfiledFunction) pGeneric;

				if (pFunction.isEnabled(graphIndex))

					return true;

			}

		}

		return false;

	}

	/* 

	 * get list of matching samples based on draw mode 

	 */

	private ArrayList<GppSample> getMatchingSamples(int drawMode, GppTrace trace, int startIndex, int endIndex, int graphIndex)

	{

		ArrayList<GppSample> samplesArray = new ArrayList<GppSample>(endIndex - startIndex > 1000 ? 1000 : endIndex - startIndex);

		Vector<ProfiledGeneric> traceThreads   = trace.getIndexedThreads();

		Vector<ProfiledGeneric> traceBinaries  = trace.getIndexedBinaries();

		Vector<ProfiledGeneric> traceFunctions = trace.getIndexedFunctions();

		GppSample[] samples = trace.getSortedGppSamples();

		GppSample sample;

		switch (drawMode)

		{

		case Defines.THREADS:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);

				if (pThread.isEnabled(graphIndex))

					samplesArray.add(sample);

			}

			break;

		case Defines.BINARIES:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);

				if (pBinary.isEnabled(graphIndex))

					samplesArray.add(sample);

			}

			break;

		case Defines.FUNCTIONS:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);

				if (pFunction.isEnabled(graphIndex))

					samplesArray.add(sample);

			}

			break;

		case Defines.THREADS_BINARIES:

		case Defines.BINARIES_THREADS:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);

				if (pThread.isEnabled(graphIndex)) {

					ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);

					if (pBinary.isEnabled(graphIndex)) {

						samplesArray.add(sample);

					}

				}

			}

			break;

		case Defines.THREADS_FUNCTIONS:

		case Defines.FUNCTIONS_THREADS:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);

				if (pThread.isEnabled(graphIndex)) {

					ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);

					if (pFunction.isEnabled(graphIndex)) {

						samplesArray.add(sample);

					}

				}

			}

			break;

		case Defines.BINARIES_FUNCTIONS:

		case Defines.FUNCTIONS_BINARIES:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);

				if (pBinary.isEnabled(graphIndex)) {

					ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);

					if (pFunction.isEnabled(graphIndex)) {

						samplesArray.add(sample);

					}

				}

			}

			break;

		case Defines.THREADS_FUNCTIONS_BINARIES:

		case Defines.THREADS_BINARIES_FUNCTIONS:

			for (int i = startIndex; i < endIndex; i++) {

				sample = samples[i];

				ProfiledThread pThread = (ProfiledThread) traceThreads.elementAt(sample.threadIndex);

				if (pThread.isEnabled(graphIndex)) {

					ProfiledBinary pBinary = (ProfiledBinary) traceBinaries.elementAt(sample.binaryIndex);

					if (pBinary.isEnabled(graphIndex)) {

						ProfiledFunction pFunction = (ProfiledFunction) traceFunctions.elementAt(sample.functionIndex);

						if (pFunction.isEnabled(graphIndex)) {

							samplesArray.add(sample);

						}

					}

				}

			}

			break;

		}

		samplesArray.trimToSize();

		return samplesArray;

	}

	/*

	 * return the thread, binary, or function samples selected in the interval 

	 */

	protected String getSampleString(int graphIndex, int drawMode, int startIndex, int endIndex)

	{

		boolean threads   = false;

		boolean binaries  = false;

		boolean functions = false;

		GppTraceGraph graph = (GppTraceGraph)(this.myGraph);

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

		// The current graph shows either threads, binaries, or functions

		switch (drawMode)

		{

		case Defines.THREADS:

		case Defines.BINARIES_THREADS:

		case Defines.BINARIES_FUNCTIONS_THREADS:

		case Defines.FUNCTIONS_THREADS:

		case Defines.FUNCTIONS_BINARIES_THREADS:

			threads = true;

			break;

		case Defines.BINARIES:

		case Defines.THREADS_BINARIES:

		case Defines.THREADS_FUNCTIONS_BINARIES:

		case Defines.FUNCTIONS_BINARIES:

		case Defines.FUNCTIONS_THREADS_BINARIES:

			binaries = true;

			break;

		case Defines.FUNCTIONS:

		case Defines.THREADS_FUNCTIONS:

		case Defines.THREADS_BINARIES_FUNCTIONS:

		case Defines.BINARIES_FUNCTIONS:

		case Defines.BINARIES_THREADS_FUNCTIONS:

			functions = true;

			break;

		default:

			break;

		}

		int startTime = trace.getStartSampleIndex();

		int endTime   = trace.getEndSampleIndex();

		// check if we have returned everything

		if (startIndex > (endTime - startTime))

			return null;

		ArrayList<GppSample> matchingSamples = getMatchingSamples(drawMode, trace, startTime, endTime, graphIndex);

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

		if (threads) {

			Vector<ProfiledGeneric> traceThreads   = trace.getIndexedThreads();

			if (startIndex == 0)

				returnString = Messages.getString("GenericAddrTable.threadSampleHeading");  //$NON-NLS-1$

			for (int i = startIndex; i < matchingSamples.size() && i < endIndex; i++) {

				GppSample sample = matchingSamples.get(i);

				returnString +=   sample.sampleSynchTime + ",0x" + Long.toHexString(sample.programCounter) + ","	  //$NON-NLS-1$ //$NON-NLS-2$; $NON-NLS-2$;

								+ traceThreads.get(sample.threadIndex).getNameString() + "\n";  //$NON-NLS-1$

			}

		} else if (binaries) {