/*

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

import java.awt.Toolkit;

import java.awt.datatransfer.Clipboard;

import java.awt.datatransfer.StringSelection;

import java.awt.event.ActionEvent;

import java.awt.event.FocusEvent;

import java.awt.event.MouseEvent;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Iterator;

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

import org.eclipse.jface.viewers.CheckboxTableViewer;

import org.eclipse.jface.viewers.ICheckStateListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerSorter;

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.graphics.Image;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Menu;

import org.eclipse.swt.widgets.MenuItem;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.ui.IActionBars;

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.memory.actions.MemoryStatisticsDialog;

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

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

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

public class MemThreadTable extends GenericTable

{

	private static final int COLUMN_ID_MEMORY_CHUNKS  = 14;

	private static final int COLUMN_ID_MEMORY_STACK   = 15;

	private static final int COLUMN_ID_MEMORY_TOTAL   = 16;

	private static final int COLUMN_ID_MEMORY_NAME    = 17;

	// sort direction

	private boolean sortAscending = true;

	// trace associated with this display

//	private MemTrace myTrace;

	private MemTraceGraph myGraph;

	private Composite parent;

	// override

    protected Vector<MemThread> tableItemData;

    // menu items

	private Action selectAllAction;

	private Action copyTableAction;

	private Action copyAction;

	private Action saveTableAction;

	// class to pass sample data to the save wizard

    public class SaveSampleString implements ISaveSamples {

    	boolean done = false;

    	public SaveSampleString() {

		}

    	public String getData() {

    		if (done)

    			return null;

			String returnString = getSampleString();

			done = true;

			return returnString;

		}

		public String getData(int size) {

			return getData();

		}

		public int getIndex() {

			return done ? 1 : 0;

		}

		public void clear() {

			done = false;

		}

    }

	/*

	 * return the memory samples selected in the interval 

	 */

	protected String getSampleString()

	{

		int startTime = (int) (PIPageEditor.currentPageEditor().getStartTime() * 1000.0 + 0.0005);

		int endTime   = (int) (PIPageEditor.currentPageEditor().getEndTime()   * 1000.0 + 0.0005);

		MemTrace trace = this.myGraph.getMemTrace();

		ArrayList<MemSampleByTime> drawDataByTime = trace.getDrawDataByTime();

		if (drawDataByTime == null || drawDataByTime.size() == 0)

			return "";	// should have been checked so this never happens //$NON-NLS-1$

		String returnString = Messages.getString("MemThreadTable.saveSamplesHeading"); //$NON-NLS-1$

		if (drawDataByTime.get(0).getTime() > startTime) {

			int graphIndex = this.myGraph.getGraphIndex();

			TableItem[] items = this.table.getItems();

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

				Object data = items[i].getData();

				if (!(data instanceof MemThread))

					continue;

				MemThread pmt = (MemThread) data;

				if (!pmt.enabled[graphIndex])

					continue;

				returnString +=   Messages.getString("MemThreadTable.notRecorded1") + items[i].getText() + Messages.getString("MemThreadTable.notRecorded2"); //$NON-NLS-1$ //$NON-NLS-2$

			}

		}

		// find least sampling time greater than or equal to the start time

		int i = 0;

		long sampleTime = 0;

		for ( ; i < drawDataByTime.size(); i++)	{

			sampleTime = drawDataByTime.get(i).getTime(); 

			if (sampleTime > startTime)

				break;

		}

		if (i != 0)

			i--;

		int graphIndex = myGraph.getGraphIndex();

		for ( ; i < drawDataByTime.size() && drawDataByTime.get(i).getTime() <= endTime; i++) {

			ArrayList<MemSample> samples = drawDataByTime.get(i).getSamples();

			for (MemSample sample : samples) {

				if (!sample.thread.enabled[graphIndex])

					continue;

				returnString +=   sample.sampleSynchTime + Messages.getString("MemThreadTable.comma") + sample.thread.fullName //$NON-NLS-1$

								+ Messages.getString("MemThreadTable.comma") + (sample.heapSize / 1024) + Messages.getString("MemThreadTable.comma") + (sample.stackSize / 1024) + "\n"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

			}

		}

		return returnString;

	}

	protected MenuItem getSaveSamplesItem(Menu menu, boolean enabled) {

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

		saveSamplesItem.setText(Messages.getString("MemThreadTable.saveCheckedSamples")); //$NON-NLS-1$

		saveSamplesItem.setEnabled(enabled);

		if (enabled) {

			saveSamplesItem.addSelectionListener(new SelectionAdapter() { 

				public void widgetSelected(SelectionEvent e) {

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

				}

			});

		}

		return saveSamplesItem;

	}

	public MemThreadTable(MemTraceGraph myGraph, Composite parent)

	{

		this.myGraph = myGraph;

		this.parent  = parent;

		this.tableViewer = CheckboxTableViewer.newCheckList(parent,

  				SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.FULL_SELECTION);

		this.table = this.tableViewer.getTable();

		this.table.setLayoutData(new GridData(GridData.FILL_BOTH));

		// add the check state handler, label provider and content provider

		this.tableViewer.addCheckStateListener(new CheckHandler());

		this.tableViewer.setLabelProvider(new SharedLabelProvider(this.table));

		this.tableViewer.setContentProvider(new MemoryTableContentProvider());

		this.tableViewer.setSorter(new SharedSorter());

		// give the table a heading for possible use in copying and exported

		this.table.setData(Messages.getString("MemThreadTable.memory")); //$NON-NLS-1$

		// create the columns

		TableColumn column;

		// data associated with the TableViewer will note which columns contain hex values

		// Keep this in the order in which columns have been created

		boolean[] isHex = {false, false, false, false};

		this.table.setData("isHex", isHex); //$NON-NLS-1$

		// select/deselect column

		column = new TableColumn(this.table, SWT.CENTER);

		column.setText(COLUMN_HEAD_MEMORY_NAME);

		column.setWidth(COLUMN_WIDTH_MEMORY_NAME + 15); // extra space for the checkbox

		column.setData(new Integer(COLUMN_ID_MEMORY_NAME));

		column.setMoveable(true);

		column.setResizable(true);

		column.addSelectionListener(new ColumnSelectionHandler());

		column = new TableColumn(tableViewer.getTable(), SWT.RIGHT);

		column.setText(COLUMN_HEAD_MEMORY_CHUNKS);

		column.setWidth(COLUMN_WIDTH_MEMORY_CHUNKS);

		column.setData(new Integer(COLUMN_ID_MEMORY_CHUNKS));

		column.setMoveable(true);

		column.setResizable(true);

		column.addSelectionListener(new ColumnSelectionHandler());

		column = new TableColumn(tableViewer.getTable(), SWT.RIGHT);

		column.setText(COLUMN_HEAD_MEMORY_STACK);

		column.setWidth(COLUMN_WIDTH_MEMORY_STACK);

		column.setData(new Integer(COLUMN_ID_MEMORY_STACK));

		column.setMoveable(true);

		column.setResizable(true);

		column.addSelectionListener(new ColumnSelectionHandler());

		column = new TableColumn(tableViewer.getTable(), SWT.RIGHT);

		column.setText(COLUMN_HEAD_MEMORY_TOTAL);

		column.setWidth(COLUMN_WIDTH_MEMORY_TOTAL);

		column.setData(new Integer(COLUMN_ID_MEMORY_TOTAL));

		column.setMoveable(true);

		column.setResizable(true);

		column.addSelectionListener(new ColumnSelectionHandler());

		// initially, all rows are checked

		this.tableViewer.setAllChecked(true);

		this.table.addMouseListener(new TableMouseListener());

		this.table.setHeaderVisible(true);

		this.table.setLinesVisible(true);

		this.table.setRedraw(true);

		updateItemData(true);

		((SharedSorter) tableViewer.getSorter()).doSort(COLUMN_ID_MEMORY_NAME);

		// initially, all rows are checked

		this.tableViewer.setAllChecked(true);

		createDefaultActions();

		// listen for key sequences such as Ctrl-A and Ctrl-C

		table.addKeyListener(new TableKeyListener());

		table.addFocusListener(new FocusListener() {

			IAction oldSelectAllAction = null;

			IAction oldCopyAction = null;

			public void focusGained(org.eclipse.swt.events.FocusEvent arg0) {

				IActionBars bars = PIPageEditor.getActionBars();

				oldSelectAllAction = PIPageEditor.getActionBars().getGlobalActionHandler(ActionFactory.SELECT_ALL.getId());

				oldCopyAction = PIPageEditor.getActionBars().getGlobalActionHandler(ActionFactory.COPY.getId());

				bars.setGlobalActionHandler(ActionFactory.COPY.getId(), copyAction);

				bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), selectAllAction);

				copyAction.setEnabled(table.getSelectionCount() > 0);

				selectAllAction.setEnabled(table.getItemCount() > 0);

				bars.updateActionBars();

				// add to the Edit menu

		        IMenuManager editMenuManager = bars.getMenuManager().findMenuUsingPath(IIDEActionConstants.M_EDIT);

		        if (editMenuManager instanceof SubMenuManager)

		        {

		        	IContributionManager editManager = ((SubMenuManager)editMenuManager).getParent();

		        	ActionContributionItem item;

					editMenuManager.remove("PICopyTable"); //$NON-NLS-1$

		        	copyTableAction.setEnabled(table.getItemCount() > 0);

		        	item = new ActionContributionItem(copyTableAction);

		        	item.setVisible(true);

		        	editManager.prependToGroup(IIDEActionConstants.CUT_EXT, item);

		        }

				// add to the File menu

		        IMenuManager fileMenuManager = bars.getMenuManager().findMenuUsingPath(IIDEActionConstants.M_FILE);

		        if (fileMenuManager instanceof SubMenuManager)

		        {

		        	IContributionManager fileManager = ((SubMenuManager)fileMenuManager).getParent();

		        	ActionContributionItem item;

		        	fileMenuManager.remove("PISaveTable"); //$NON-NLS-1$

		        	saveTableAction.setEnabled(table.getItemCount() > 0);

		        	item = new ActionContributionItem(saveTableAction);

		        	item.setVisible(true);

		        	fileManager.insertAfter("saveAll", item); //$NON-NLS-1$

		        }

			}

			public void focusLost(org.eclipse.swt.events.FocusEvent arg0) {

				IActionBars bars = PIPageEditor.getActionBars();

				bars.setGlobalActionHandler(ActionFactory.COPY.getId(), oldCopyAction);

				bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), oldSelectAllAction);

				bars.updateActionBars();

				SubMenuManager editMenuManager = (SubMenuManager) PIPageEditor.getMenuManager().find(IIDEActionConstants.M_EDIT);

				editMenuManager.remove("PICopyTable"); //$NON-NLS-1$

				editMenuManager.update();

				SubMenuManager fileMenuManager = (SubMenuManager) PIPageEditor.getMenuManager().find(IIDEActionConstants.M_FILE);

				fileMenuManager.remove("PISaveTable"); //$NON-NLS-1$

				fileMenuManager.update();

			}

		});

		tableViewer.refresh();

		table.redraw();

	}

	private 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 MemThread)

				{

					MemThread pMemThread = (MemThread)(selectedItems[0].getData());

				    if (pMemThread.isEnabled(myGraph.getGraphIndex()))

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

				    else

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

				}

			}

			selectAllAction.setEnabled(table.getItemCount() > 0);

			copyAction.setEnabled(table.getSelectionCount() > 0);

			copyTableAction.setEnabled(table.getItemCount() > 0);

		}

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

		}

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

			selectAllAction.setEnabled(table.getItemCount() > 0);

			copyAction.setEnabled(table.getSelectionCount() > 0);

			copyTableAction.setEnabled(table.getItemCount() > 0);

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

				// get rid of last Menu created so we don't have double menu

				// on click

				if (contextMenu != null) {

					contextMenu.dispose();

				}

				contextMenu = new Menu(table.getShell(), SWT.POP_UP);

				getCheckRows(contextMenu, table.getSelectionCount() > 0);

				// select all, copy, and copy all

				new MenuItem(contextMenu, SWT.SEPARATOR);

				getSelectAllItem(contextMenu, table.getItemCount() > 0);

				getCopyItem(contextMenu, table.getSelectionCount() > 0);

				getCopyTableItem(contextMenu, table.getItemCount() > 0);

				selectAllAction.setEnabled(table.getItemCount() > 0);

				copyAction.setEnabled(table.getSelectionCount() > 0);

				copyTableAction.setEnabled(table.getItemCount() > 0);

				// save all

				new MenuItem(contextMenu, SWT.SEPARATOR);

				getSaveTableItem(contextMenu, table.getItemCount() > 0);

				saveTableAction.setEnabled(table.getItemCount() > 0);

				// save samples

				int startTime = (int) (PIPageEditor.currentPageEditor().getStartTime() * 1000.0f);

				int endTime   = (int) (PIPageEditor.currentPageEditor().getEndTime()   * 1000.0f);

				getSaveSamplesItem(contextMenu,

					myGraph.haveEnabled() && (startTime != -1) && (endTime != -1) && (startTime != endTime));

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

			    contextMenu.setVisible(true);

				new MenuItem(contextMenu, SWT.SEPARATOR);

				MenuItem memoryStatsItem = new MenuItem(contextMenu, SWT.PUSH);

				memoryStatsItem.setText(Messages.getString("MemoryPlugin.memoryStats")); //$NON-NLS-1$

				memoryStatsItem.addSelectionListener(new SelectionAdapter() {

					public void widgetSelected(SelectionEvent e) {

						new MemoryStatisticsDialog(Display.getCurrent());

					}

				});

				table.setMenu(contextMenu);

			}

		}

	}

	private static class MemoryTableContentProvider implements IStructuredContentProvider {

		public MemoryTableContentProvider() {

			super();

		}

		public Object[] getElements(Object inputElement) {

			return ((Vector<MemThread>) inputElement).toArray();

		}

		public void dispose() {

		}

		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

		}

	}

	private class CheckHandler implements ICheckStateListener

	{

		public void checkStateChanged(CheckStateChangedEvent event) {

       		if (!(event.getElement() instanceof MemThread))

       			return;

       		// set the stored value to the checkbox value

       		MemThread pMemThread = (MemThread)event.getElement();

       		pMemThread.setEnabled(myGraph.getGraphIndex(), event.getChecked());

       		selectionChangeNotify();

       		table.deselectAll();

		}

	}

	void selectionChangeNotify() {

		this.tableViewer.refresh();

		this.table.redraw();

		PIEvent be = new PIEvent(null, PIEvent.CHANGED_MEMORY_TABLE);

		myGraph.piEventReceived(be);

    }

	private class SharedLabelProvider extends LabelProvider implements ITableLabelProvider {

        private DecimalFormat decimalFormat = new DecimalFormat(Messages.getString("MemThreadTable.kbFormat")); //$NON-NLS-1$

        Table table;

		public SharedLabelProvider(Table table) {

			super();

			this.table = table;

		}

		public String getColumnText(Object element, int columnIndex) {

	        int columnId = ((Integer) table.getColumn(columnIndex).getData()).intValue();

			if (!(element instanceof MemThread))

				return ""; //$NON-NLS-1$

			MemThread profiledItem = (MemThread) element;

			switch (columnId)

			{

				case COLUMN_ID_MEMORY_NAME:

				{

					return profiledItem.fullName;

				}

				case COLUMN_ID_MEMORY_CHUNKS:

			    {

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

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

					if ((startTime == -1) || (endTime   == -1) || (startTime == endTime))

						return ""; //$NON-NLS-1$

					return decimalFormat.format((profiledItem.maxMemoryItem.maxChunks + 512)/1024);

			    }

				case COLUMN_ID_MEMORY_STACK:

			    {

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

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

					if ((startTime == -1) || (endTime   == -1) || (startTime == endTime))

						return ""; //$NON-NLS-1$

					return decimalFormat.format((profiledItem.maxMemoryItem.maxStackHeap + 512)/1024);

			    }

				case COLUMN_ID_MEMORY_TOTAL:

			    {

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

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

					if ((startTime == -1) || (endTime   == -1) || (startTime == endTime))

						return ""; //$NON-NLS-1$

					return decimalFormat.format((profiledItem.maxMemoryItem.maxTotal + 512)/1024);

			    }

				default:

				{