/*
 * 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.awt.event.MouseEvent;
import java.util.Vector;
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.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.swt.SWT;
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.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;
import com.nokia.carbide.cpp.internal.pi.visual.GenericTable;

/**
 *	Software thread interrupt table 
 */
public class SwiThreadTable extends GenericTable implements ICheckStateListener {
	
	private IrqTraceGraph myGraph;
	private Composite parent;
	
    protected Vector<SwiThreadWrapper> tableItemData;

	// sort direction
	private boolean sortAscending = true;
	
	/**
	 * Constructor
	 * @param myGraph irq graph
	 * @param parent parent where table is placed
	 */
	public SwiThreadTable(IrqTraceGraph 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();
		
		// add the check state handler, label provider and content provider
		this.tableViewer.addCheckStateListener(this);
		this.tableViewer.setLabelProvider(new SwiThreadLabelProvider(this.table));
		this.tableViewer.setContentProvider(new TableContentProvider());
		this.tableViewer.setSorter(new SharedSorter());

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

		// Check column
		column = new TableColumn(this.table, SWT.CENTER);
		column.setText(Messages.SwiThreadTable_0);
		column.setWidth(20);
		column.setData(COLUMN_ID_SWI_CHECK);
		column.setMoveable(true);
		column.setResizable(true);
		column.addSelectionListener(new ColumnSelectionHandler());
		
		// Thread Name column
		column = new TableColumn(this.table, SWT.LEFT);
		column.setText(Messages.SwiThreadTable_1);
		column.setWidth(COLUMN_WIDTH_THREAD_IRQ_LINE);
		column.setData(COLUMN_ID_SWI_THREAD);
		column.setMoveable(true);
		column.setResizable(true);
		column.addSelectionListener(new ColumnSelectionHandler());

		// Thread address
		column = new TableColumn(tableViewer.getTable(), SWT.RIGHT);
		column.setText(Messages.SwiThreadTable_2);
		column.setWidth(COLUMN_WIDTH_ADDRESS_COUNT);
		column.setData(COLUMN_ID_ADDRESS);
		column.setMoveable(true);
		column.setResizable(true);
		column.addSelectionListener(new ColumnSelectionHandler());

		// add mouse listener and set other table settings
		this.table.addMouseListener(new TableMouseListener());
		this.table.setHeaderVisible(true);
		this.table.setLinesVisible(true);
		this.table.setRedraw(true);
		
		// format data into table
		this.updateItemData(true);
		((SharedSorter) tableViewer.getSorter()).doSort(COLUMN_ID_SWI_THREAD);

		// Select initially no lines
		this.tableViewer.setAllChecked(false);
		
		// listen for key sequences such as Ctrl-A and Ctrl-C
		table.addKeyListener(new TableKeyListener());
		
		tableViewer.refresh();
		table.redraw();
	}
	
	
	/**
	 * Content provider for table
	 */
	private static class TableContentProvider implements IStructuredContentProvider {
		
		/**
		 * Constructor
		 */
		public TableContentProvider() {
			super();
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)
		 */
		@SuppressWarnings("unchecked")
		public Object[] getElements(Object inputElement) {
			return ((Vector<SwiThreadWrapper>) inputElement).toArray();
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IContentProvider#dispose()
		 */
		public void dispose() {
		}

		/*
		 * (non-Javadoc)
		 * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer, java.lang.Object, java.lang.Object)
		 */
		public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {
		}
	}
	
	/*
	 * (non-Javadoc)
	 * @see com.nokia.carbide.cpp.internal.pi.visual.GenericTable#action(java.lang.String)
	 */
	public void action(String actionString)
	{
		if (actionString.equals("add")){ //$NON-NLS-1$
			checkOrUncheckSelectedItems(true);
		}
		else if (actionString.equals("remove")){ //$NON-NLS-1$
			checkOrUncheckSelectedItems(false);
		}
		else if (actionString.equals("addall")){ //$NON-NLS-1$
			checkOrUncheckAllItems(true);
		}
		else if (actionString.equals("removeall")){ //$NON-NLS-1$
			checkOrUncheckAllItems(false);
		}
	    else if (actionString.equals("copy")) //$NON-NLS-1$
	    {
	    	actionCopyOrSave(true, this.table, CHECKBOX_TEXT, false, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
	        return; // no redraw needed
	    }
	    else if (actionString.equals("copyTable")) //$NON-NLS-1$
	    {
	    	actionCopyOrSave(true, this.table, CHECKBOX_TEXT, true, "\t", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
	        return; // no redraw needed
	    }
		else if (actionString.equals("selectAll")) //$NON-NLS-1$
	    {
	    	actionSelectAll();
	        return;
	    }
		
	    else if (actionString.equals("saveTable")) //$NON-NLS-1$
	    {
	    	actionCopyOrSave(false, this.table, CHECKBOX_TEXT, true, ",", "\n"); //$NON-NLS-1$ //$NON-NLS-2$
	        return; // no redraw needed
	    }
	}
	
	/**
	 * Checks or unchecks all selected threads from table
	 * @param value true if items are checked 
	 */
	private void checkOrUncheckSelectedItems(boolean value)
	{
		
		TableItem[] selectedItems = this.table.getSelection();
		for (int i = 0; i < selectedItems.length; i++)
		{
			if(selectedItems[i].getData().getClass() == SwiThreadWrapper.class){
				selectedItems[i].setChecked(value);
				SwiThreadWrapper wrapper = (SwiThreadWrapper)selectedItems[i].getData();
				if(value){
					myGraph.threadChecked(wrapper.threadName);
				}
				else{
					myGraph.threadUnchecked(wrapper.threadName);

				}
			}
		}
		myGraph.updateIrqCountsInLegendsAsynch(IrqTraceGraph.TYPE_SWI);
		myGraph.repaint();

	}
	
	/**
	 * Checks or unchecks all table items
	 * @param value true if all items are checked
	 */
	private void checkOrUncheckAllItems(boolean value)
	{
		
		TableItem[] allItems = this.table.getItems();
		for (int i = 0; i < allItems.length; i++)
		{
			if(allItems[i].getData().getClass() == SwiThreadWrapper.class){
				allItems[i].setChecked(value);
				SwiThreadWrapper wrapper = (SwiThreadWrapper)allItems[i].getData();
				if(value){
					myGraph.threadChecked(wrapper.threadName);
				}
				else{
					myGraph.threadUnchecked(wrapper.threadName);

				}
			}

			
		}
		myGraph.repaint();
		myGraph.updateIrqCountsInLegendsAsynch(IrqTraceGraph.TYPE_SWI);

	}
	
	/**
	 * Formats item data into table
	 * @param setInput true if table needs to be refreshed
	 */
	public void updateItemData(boolean setInput)
	{
		tableItemData = ((IrqTrace)this.myGraph.getTrace()).getAllThreadWrappers();

		// refresh the table, if needed
		if (setInput)
			refreshTableViewer();
	}
	
	/**
	 * Refreshes table viewer
	 */
	public void refreshTableViewer()
	{
		this.tableViewer.setInput(tableItemData);
	}

	/**
	 * @return tableviewer of the thread table
	 */
	public CheckboxTableViewer getTableViewer(){
		return this.tableViewer;
	}

	/*
	 * (non-Javadoc)
	 * @see org.eclipse.jface.viewers.ICheckStateListener#checkStateChanged(org.eclipse.jface.viewers.CheckStateChangedEvent)
	 */
	public void checkStateChanged(CheckStateChangedEvent event) {
		if(event.getElement().getClass() == SwiThreadWrapper.class){
			SwiThreadWrapper wrapper = (SwiThreadWrapper) event.getElement();
			if(event.getChecked()){
				myGraph.threadChecked(wrapper.threadName);
			}
			else{
				myGraph.threadUnchecked(wrapper.threadName);
			}
			myGraph.repaint();
			myGraph.updateIrqCountsInLegendsAsynch(IrqTraceGraph.TYPE_SWI);
			
		}
		
	}
	
	/**
	 * Mouse listener of the table
	 */
	private class TableMouseListener implements MouseListener
	{
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.swt.events.MouseListener#mouseDoubleClick(org.eclipse.swt.events.MouseEvent)
		 */
		public void mouseDoubleClick(org.eclipse.swt.events.MouseEvent e) {
			
		}
		
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.swt.events.MouseListener#mouseDown(org.eclipse.swt.events.MouseEvent)
		 */
		public void mouseDown(org.eclipse.swt.events.MouseEvent e) {
		}
		
		/*
		 * (non-Javadoc)
		 * @see org.eclipse.swt.events.MouseListener#mouseUp(org.eclipse.swt.events.MouseEvent)
		 */
		public void mouseUp(org.eclipse.swt.events.MouseEvent e) {

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

				// save all
				new MenuItem(contextMenu, SWT.SEPARATOR);
				getSaveTableItem(contextMenu, table.getItemCount() > 0);
				
				// Recolor highlighted items
				new MenuItem(contextMenu, SWT.SEPARATOR);
				getRecolorItem(contextMenu, Messages.SwiThreadTable_3, table.getSelectionCount() > 0);

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

			    table.setMenu(contextMenu);
			}
		}
	}
	
	/**
	 * Column selection handler for the table
	 */
	private class ColumnSelectionHandler extends SelectionAdapter
	{
		public void widgetSelected(SelectionEvent e)
        {
        	if (!(e.widget instanceof TableColumn))
        		return;
        	
        	sortOnColumnSelection((TableColumn) e.widget);
        }
	}
	
	/**
	 * @param tableColumn which column is sorted
	 */
	public void sortOnColumnSelection(TableColumn tableColumn) {
    	int columnID = ((Integer) tableColumn.getData()).intValue();
    	((SharedSorter) tableViewer.getSorter()).doSort(columnID);

		this.refreshTableViewer();
		this.table.redraw();
	}
	
	/**
	 * Sorter for the table
	 */
	private class SharedSorter extends ViewerSorter {
		// last column sorted
		private int column = -1;
		
		/* 
		 * decide on which column to sort by, and the sort ordering
		 */
		public void doSort(int column) {
			// ignore the column passed in and use the id set by the column selection handler
			if (column == this.column) {
				// sort in other order
				sortAscending = !sortAscending;
			} else {
				// changed columns, so sort in the default order
				switch (column) {
					case COLUMN_ID_SWI_CHECK:
					{
		            	// sort in ascending order
		            	sortAscending = true;
		                break;
					}
					case COLUMN_ID_SWI_THREAD:
					case COLUMN_ID_ADDRESS:
					{
		            	// sort in descending order
		            	sortAscending = false;
		                break;
					}
					default:
					{
						// ignore the column
						return;
					}
				}
				this.column = column;
			}

			// find the TableColumn corresponding to column, and give it a column direction
			TableColumn sortByColumn = null;
			for (int i = 0; i < table.getColumnCount(); i++) {
				if (table.getColumn(i).getData() instanceof Integer) {
					if (((Integer)table.getColumn(i).getData()) == column) {
						sortByColumn = table.getColumn(i);
						break;
					}
				}
			}

			if (sortByColumn != null) {
				table.setSortColumn(sortByColumn);
				table.setSortDirection(sortAscending ? SWT.UP : SWT.DOWN);
			}
		}
		
		/*
		 * compare two items from a table column
		 */
		public int compare(Viewer viewer, Object e1, Object e2) {
			int returnCode = 0;
			
			SwiThreadWrapper elem1 = (SwiThreadWrapper)e1;
			SwiThreadWrapper elem2 = (SwiThreadWrapper)e2;

			// find the memory information for the two threads
			
			// compare based on the memory information
			switch (column) {
			case COLUMN_ID_SWI_CHECK:
				if(tableViewer.getChecked(e1) == true && tableViewer.getChecked(e2) == false){
					returnCode = -1;
				}
				else{
					returnCode = 1;
				}
				break;
			case COLUMN_ID_SWI_THREAD:
				returnCode = elem1.threadName.compareToIgnoreCase(elem2.threadName);
				break;
			case COLUMN_ID_ADDRESS:
				returnCode = elem1.threadAddress > elem2.threadAddress ? 1 : -1;
				break;
			default:
				break;
			}

			// for descending order, reverse the sense of the compare
			if (!sortAscending)
				returnCode = -returnCode;

			return returnCode;
		}
	}
	
	
	/**
	 * sets sort direction
	 * @param sortAscending new sort direction
	 */
	public void setSortAscending(boolean sortAscending) {
		this.sortAscending = sortAscending;
	}
	
}