/*

* 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 "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.s60tools.memspy.ui.wizards;

import java.io.File;

import java.lang.reflect.InvocationTargetException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.swt.SWT;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.SelectionListener;

import org.eclipse.swt.layout.GridData;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.FileDialog;

import org.eclipse.swt.widgets.Group;

import org.eclipse.swt.widgets.Label;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.TableColumn;

import org.eclipse.swt.widgets.TableItem;

import org.eclipse.swt.widgets.Text;

import org.eclipse.ui.PlatformUI;

import com.nokia.s60tools.memspy.containers.SWMTLogInfo;

import com.nokia.s60tools.memspy.containers.ThreadInfo;

import com.nokia.s60tools.memspy.containers.ThreadInfo.HeapDumpType;

import com.nokia.s60tools.memspy.interfaces.IMemSpyTraceListener;

import com.nokia.s60tools.memspy.model.MemSpyFileOperations;

import com.nokia.s60tools.memspy.model.MemSpyLogParserEngine;

import com.nokia.s60tools.memspy.model.TraceCoreEngine;

import com.nokia.s60tools.memspy.model.UserEnteredData;

import com.nokia.s60tools.memspy.model.UserEnteredData.ValueTypes;

import com.nokia.s60tools.memspy.plugin.MemSpyPlugin;

import com.nokia.s60tools.memspy.resources.HelpContextIDs;

import com.nokia.s60tools.memspy.ui.UiUtils;

import com.nokia.s60tools.ui.preferences.PreferenceUtils;

import com.nokia.s60tools.ui.wizards.S60ToolsWizardPage;

import com.nokia.s60tools.util.debug.DbgUtility;

public class DeviceOrFileSelectionPage extends S60ToolsWizardPage implements

		SelectionListener, ModifyListener, IMemSpyTraceListener {

	/**

	 * Selection index for import from device via TraceViewer radio button

	 */

	private static final int DEVICE_RADIO_BUTTON_SELECTION_INDEX = 2;

	public enum PageType{ IMPORT_PAGE, COMPARE_FIRST_HEAP, COMPARE_SECOND_HEAP };

	// UI elements

	private Combo fileCombo;

	private Button buttonBrowseFile;

	private Button fileRadioButton;

	private Button deviceRadioButton;

	private Button loadThreadListButton;

	private Button connectionSettingsButton;

	private Button getHeapButton;

	private Label heapsReceivedLabel;

	private Label connectionTextLabel;

	private Label connectionNameInUseLabel;

	private GridData threadSelectionGridData;

	private GridData fileSelectionGridData;

	private GridData deviceThreadTableGridData;

	private GridData importedHeapTableGridData;

	private GridData loadThreadListGridData;

	private GridData connectionGridData;

	private GridData connectionButtonGridData;

	private GridData connectionNameInUseGridData;

	private GridData threadFilterTypesGridData;

	private GridData threadFilterGridData;

	private Group compareGroup;

	private Group fileSelectionGroup;

	private Composite fileLocationGroup;

	private Composite fileThreadListGroup;

	private Group radioButtonGroup;

	private Group threadSelectionGroup;

	private Composite threadListGroup;

	private Composite threadButtonGroup;

	/**

	 * Table that is shown when getting heap From File System.

	 */

	private Table fileThreadTable;

	/**

	 * Table which contents can be loaded/refreshed from the device.

	 */

	private Table deviceThreadTable;

	/**

	 * Table that contains two heaps that are to be compared when Import and compare is selected.

	 */

	private Table comparedHeapsTable;

	/**

	 * Table in second page, where only imported heap can be selected.

	 */

	private Table importedHeapTable;

	/**

	 * Text field for setting filter text.

	 */

	private String filterText;

	/**

	 * Filter text.

	 */

	private Text threadFilterText;

	/**

	 * Combo for filtering types.

	 */

	private Combo threadFilterTypesCombo;

	// Thread list from one file

	private ArrayList<ThreadInfo> fileThreadList;

	// selected thread from thread list

	private ThreadInfo comparedThread;

	// Decoder Engine

	private MemSpyLogParserEngine engine;

	// Thread list received from usb/musti

	ArrayList<ThreadInfo> deviceThreadList;

	// TraceCore engine

	TraceCoreEngine traceEngine;

	// List of received heaps:

	ArrayList<ThreadInfo> receivedHeaps;

	// Heap that is currently received

	ThreadInfo receivedHeap;

	// this pages UserEnterData section

	ValueTypes section;

	// viewed error message

	String errorMessage;

	// Type of this page

	PageType pageType;

	// boolean variable, which is set to true if some MemSpy operation is running.

	boolean memSpyOperationRunning;

	// MemSpy operation processes:

	// receive thread list

	IRunnableWithProgress receiveThreadListProcess;

	// receive heap

	IRunnableWithProgress receiveHeapProcess;

	//Strings

	private final static String  FILE_SELECTION_DIALOG_TEXT 		= "Select Heap Dump File";

	private final static String  GET_HEAP_RADIO_BUTTON 				= "Get Heap:";

	private final static String  GET_HEAP_FROM_FILE_RADIO_BUTTON 	= "From File System";

	private final static String  GET_HEAP_FROM_DEVICE_RADIO_BUTTON 	= "From Device via TraceViewer";

	private final static String  HEAP_DUMP_LOCATION_TEXT 			= "Define Location of Heap Dump File:";

	private final static String  BROWSE_TEXT 						= "Browse...";

	private final static String  HEAP_CONTAINS_TEXT_IMPORT 			= "Selected file contains heaps from following threads.";

	private final static String  HEAP_CONTAINS_TEXT_COMPARE			= "Selected file contains heaps from following threads, select thread which heap needs to be compared.";

	private final static String  THREAD_NAME_TEXT 					= "Thread Name";

	private final static String  SELECT_THREAD_TEXT 				= GET_HEAP_FROM_DEVICE_RADIO_BUTTON;

	private final static String  SELECT_FILE_TEXT 					= GET_HEAP_FROM_FILE_RADIO_BUTTON;

	private final static String  LOAD_REFRESH_THREAD_LIST_BUTTON 	= "Load/Refresh Thread List";

	private final static String  CONNECTION_SETTINGS_BUTTON 		= "Connection Settings...";

	private final static String  CURRENTLY_USING_TEXT 				= "Currently using:";

	private final static String  GET_HEAP_NOW_BUTTON 				= "Get Selected Heap Now";

	private final static String  HEAP_DUMP_RECEIVED					= "Heap Dump Received";

	private final static String  RECEIVING_THREAD_LIST  			= "Receiving Thread List: ";

	private final static String  RECEIVING_HEAP_DUMP  				= "Receiving Heap Dump: ";

	private final static String  HEAP_DUMPS_RECEIVED				= " Heap Dumps Received";

	private final static String  COMPARE_HEAPS						= "Compared heaps";

	// Error/warning messages

	private final static String  ERROR_INVALID_FILE 				= "Invalid heap dump file. The file doesn't contain any threads with binary data information.";

	private final static String  ERROR_FILE_NOT_FOUND  				= "File not found";

	private final static String  SELECT_COMPARED_THREAD				= "Select thread which heap needs to be compared";

	private final static String  WARNING_HEAPS_NOT_FROM_SAME_THREAD = "Compared heaps are not from same thread";

	private final static String  ERROR_DRM_THREAD					= "Heaps from threads which name contains word \"drm\" cannot be received due to security policies.";

	private final static String  ERROR_DBGTRS_THREAD				= "Heaps from threads which name contains word \"dbgtrcserver::!DbgTrcServer\" cannot be received due to Trace restrictions.";

	/**

	 * DeviceOrFileSelectionPage(String pageName)

	 * Constructor

	 * @param pagename name of this wizard page

	 */

	protected DeviceOrFileSelectionPage( String pageName, String title, String description, ValueTypes section, 

										 PageType pageType, TraceCoreEngine traceEngine ) {

		super(pageName);

		setTitle( title );

		setDescription( description );

		this.engine = new MemSpyLogParserEngine();

		this.fileThreadList = new ArrayList<ThreadInfo>();

		this.deviceThreadList = new ArrayList<ThreadInfo>();

		this.traceEngine = traceEngine;

		this.receivedHeaps = new ArrayList<ThreadInfo>();

		this.receivedHeap = new ThreadInfo();

		this.section = section; 

		this.errorMessage = "";

		this.pageType = pageType;

		this.comparedThread = null;

		memSpyOperationRunning = false;

		this.createMemSpyProcesses();

		this.filterText = "";

	}	

	/**

	 * (non-Javadoc)

	 * @see com.nokia.s60tools.ui.wizards.S60ToolsWizardPage#setInitialFocus()

	 */

	public void setInitialFocus() {

		fileCombo.setFocus();

	}

	/**

	 * (non-Javadoc)

	 * @see org.eclipse.swt.events.SelectionListener#widgetDefaultSelected(org.eclipse.swt.events.SelectionEvent)

	 */

	public void widgetDefaultSelected(SelectionEvent e) {

		this.getHeapButtonPressed();

	}

	/**

	 * (non-Javadoc)

	 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)

	 */

	public void widgetSelected(SelectionEvent e) {

		if (e.widget == buttonBrowseFile) {

			// open file dialog for selecting a Heap Dump file

			FileDialog dialog = new FileDialog(this.getShell());

			dialog.setText(FILE_SELECTION_DIALOG_TEXT);

			String[] filterExt = { "*.txt", "*.log", "*.*" };

			dialog.setFilterExtensions(filterExt);

			dialog.setFilterPath(fileCombo .getText());

			String result = dialog.open();

			if (result != null ){

				fileCombo.setText(result);

			}

		}

		// Update controls after radio buttons state changes to false

		else if ( ( e.widget == deviceRadioButton && deviceRadioButton.getSelection() == false ) ||

			 ( e.widget == fileRadioButton && fileRadioButton.getSelection() == false ) ){

			this.hideAndRevealItems();

			getWizard().getContainer().updateButtons();

			MemSpyWizard wizard = (MemSpyWizard) getWizard();

			if( this.pageType != PageType.IMPORT_PAGE ){

				wizard.setComparedHeaps();

			}

		}		

		// Open connection settings.

		else if ( e.widget == connectionSettingsButton ){

			// Open connection Trace viewers connection settings.

			Shell shell = MemSpyPlugin.getCurrentlyActiveWbWindowShell();

			PreferenceUtils.openPreferencePage(MemSpyPlugin.getTraceProvider().getTraceSourcePreferencePageId(), shell);

			// Disconnect trace source so that new settings are used when sending next request

			MemSpyPlugin.getTraceProvider().disconnectTraceSource();

			MemSpyWizard wizard = (MemSpyWizard) this.getWizard();

			// update new settings to each wizard page.

			wizard.updateConnectionSettings();

		}

		// Load thread list from device

		else if ( e.widget == loadThreadListButton ){

			this.loadThreadListButtonPressed();

		}

		else if ( e.widget == getHeapButton ){

			this.getHeapButtonPressed();

		}

		else if( e.widget == deviceThreadTable ){

			this.enableAndDisableGetHeapButton();

		}

		else if( e.widget == importedHeapTable ){

			this.enableAndDisableGetHeapButton();

		}

		else if( e.widget == fileThreadTable ){

			// get selection index from thread table

			int selectionIndex = fileThreadTable.getSelectionIndex();

			// set selected heap as compared heap

			comparedThread = fileThreadList.get( selectionIndex );

			// get wizard and update compared thread names

			MemSpyWizard wizard = (MemSpyWizard)this.getWizard();

			wizard.setComparedHeaps();

			wizard.showImportedHeapsInComparePage( false );

			// update buttons

			getWizard().getContainer().updateButtons();

			// Set selection back to table after updatebuttons has cleared it.

			fileThreadTable.setSelection( selectionIndex );

		}

		else if( e.widget == threadFilterTypesCombo) {

			updateThreadList();

		}

	}

	/**

	 * (non-Javadoc)

	 * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)

	 */

	public void modifyText(ModifyEvent event) {

		if (event.widget.equals(fileCombo)) {

			try {

				getWizard().getContainer().updateButtons();

			} catch (Exception e) {

			}

		}

		else if (event.widget.equals(threadFilterText)) {

			filterText = threadFilterText.getText();

			updateThreadList();

		}	

	}

	/**

	 * (non-Javadoc)

	 * @see com.nokia.s60tools.ui.wizards.S60ToolsWizardPage#recalculateButtonStates()

	 */

	public void recalculateButtonStates() {

	}

	/**

	 * hideAndRevealItems()

	 * Hides and reveals controls according to radiobutton states.

	 */

	private void hideAndRevealItems() {

		// get radiobutton selection

		boolean fileSelected = true;

		if( deviceRadioButton.getSelection() == false ){

			fileSelected = false;

		}

		// exlude/include needed controls

		fileSelectionGridData.exclude = fileSelected;

		threadSelectionGridData.exclude = !fileSelected;

		if( fileSelected ){

			// Since excluded groups size and location are not updated, do it now

			threadSelectionGroup.setSize( fileSelectionGroup.getSize() );

			threadSelectionGroup.setLocation(fileSelectionGroup.getLocation());

		}

		else{

			// Since excluded groups size and location are not updated, do it now

			fileSelectionGroup.setSize( threadSelectionGroup.getSize() );

			fileSelectionGroup.setLocation(threadSelectionGroup.getLocation());

		}

		// Hide/show needed controls

		fileSelectionGroup.setVisible(!fileSelected);

		threadSelectionGroup.setVisible(fileSelected);

	}

	/**

	 * canFinish()

	 * Returns false, because symbol files must be defined always.

	 */

	public boolean canFinish()

	{

		return false;

	}

	public boolean refreshFileThreadList(){

		File file = new File(fileCombo.getText());

		// If file exists

		if (file.isFile() && file.exists()) {

			// Empty thread list table

			fileThreadTable.removeAll();

			fileThreadList.clear();

			// Check that file is Heap Dump file and display thread names in table.

			if ( engine.isFileHeapDumpFile(file, fileThreadList) ) {

				this.setErrorMessage(null);

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

					TableItem newItem = new TableItem(fileThreadTable, SWT.NONE,i);

					newItem.setText(fileThreadList.get(i).getThreadName());	

				}

				if( fileThreadList.size() == 1 ){

					comparedThread = fileThreadList.get(0);

					((MemSpyWizard)this.getWizard()).setComparedHeaps();

				}

				// If comparing heaps and no heap is selected as compared heap

				if( comparedThread == null && this.pageType != PageType.IMPORT_PAGE){

					this.setErrorMessage(SELECT_COMPARED_THREAD);

					return false;

				}

				else{

					// if importing heaps, set first heap as compared heap.

					if( this.pageType == PageType.IMPORT_PAGE ){

						comparedThread = fileThreadList.get(0);

					}

					return true;

				}

			} 

			else {

				this.setErrorMessage(ERROR_INVALID_FILE);

				return false;

			}

		} 

		else {

			this.setErrorMessage(ERROR_FILE_NOT_FOUND );

			return false;

		}

	}

	/**

	 * (non-Javadoc)

	 * @see org.eclipse.jface.wizard.WizardPage#canFlipToNextPage()

	 */

 	public boolean canFlipToNextPage() {

 		if( fileRadioButton.getSelection() ){

			try {

				if( !this.refreshFileThreadList() ){

					return false;

				}

			}

			catch (Exception e) {

				e.printStackTrace();

				return false;

			}

 		}

 		else{ // deviceRadioButton.getSelection()

 			if( receivedHeaps.size() > 0 ){

 				this.setErrorMessage(null);

 			}

 			else{

 				this.setErrorMessage(null);

 				return false;

 			}

 		}

 		if( this.pageType == PageType.COMPARE_FIRST_HEAP || this.pageType == PageType.COMPARE_SECOND_HEAP ){

 			MemSpyWizard wizard = (MemSpyWizard)this.getWizard();

 	 		if( !wizard.areComparedHeapsFromSameThread() ){

 	 			this.setMessage(WARNING_HEAPS_NOT_FROM_SAME_THREAD, ERROR);

 	 			if( this.pageType == PageType.COMPARE_SECOND_HEAP ){

 	 				return false;

 	 			}

 	 		}

 	 		else{

 	 			this.setMessage(null);

 	 		}

 		}

		return true;

	}

 	/**

 	 * loadUserEnteredData

 	 * Loads previously used values and selections into UI components

 	 */

 	private void loadUserEnteredData(){