/*

* 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.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.jface.dialogs.ErrorDialog;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.jface.operation.IRunnableWithProgress;

import org.eclipse.swt.SWT;

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

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.ui.PlatformUI;

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

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

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.preferences.MemSpyPreferences;

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;

/**

 * SWMT-log import page is used for importing SWMT-logs from file system or from device.

 */

public class SWMTLogPage extends S60ToolsWizardPage implements SelectionListener, IMemSpyTraceListener, SWMTCategorySelectionMediator{	

	/**

	 * Selection index for import from device via TraceViewer radio button

	 */

	private static final int DEVICE_RADIO_BUTTON_SELECTION_INDEX = 2;

	// Array list of logs that are imported

	// from files:

	private ArrayList<SWMTLogInfo> fileLogList;

	// from device:

	private ArrayList<SWMTLogInfo> deviceLogList;

	// SWMT-log that is currently received

	SWMTLogInfo receivedLog;

	// TraceCore engine

	private TraceCoreEngine traceEngine;

	// Cycle Number for SMWT-log file name

	private int cycleNumber;

	// Error message

	String errorMessage;

	// boolean value stating that error has been occurred and logs cannot be requested before removing 

	// all items and restarting from cycle 1.

	boolean missedLogs;

	//UI-components:

	private Group radioButtonGroup;

	private Button fileRadioButton;

	private Button deviceRadioButton;

	// Components for importing file from device 

	private Table fileLogsTable;

	private Composite fileSelectionButtonComposite;

	private Button addFileButton;

	private Button addDirectoryButton;

	private Button removeOneButton;

	private Button removeAllButton;

	private Group fileSelectionGroup;

	private Group deviceGroup;

	private GridData fileSelectionGridData;

	private GridData deviceGridData;

	// components for importing log from device	

	private Table deviceLogsTable;

	private Composite loggingComposite;

	private Button connectionSettingsButton;

	private Button getLogNowButton;

	private Button removeReceivedLogsButton;

	private Label connectionNameInUseLabel;

	// Timer related components

	private Label intervalLabel;

	private Label secondLabel;

	private Button startTimerButton;

	private Combo timerCombo;

	/**

	 * UI composite for SWMT Category group

	 */

	private SWMTCategoryGroupComposite categoryGroupComposite;	

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

	boolean memSpyOperationRunning;

	boolean memSpyStopping;

	boolean memSpyTimerRunning;

	// MemSpy operation processes:

	// receive SWMT-log manually

	IRunnableWithProgress receiveSWMTLogProcess;

	private final static String  GET_LOG_FROM_RADIO_BUTTON 			= "Get SWMT Log";

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

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

	private final static String  LOG_FILES							= "Log files:";

	private final static String  LOG_TYPE							= "Type";

	private final static String  ADD_FILE							= "Add File";

	private final static String  ADD_DIRECTORY						= "Add Directory";

	private final static String  REMOVE_ONE							= "Remove";

	private final static String  REMOVE_ALL							= "Remove All";

	private final static String  ADD_FILE_TEXT			 			= "Define Location of SWMT Log file:";

	private final static String  ADD_DIRECTORY_TEXT		 			= "Define Location of directory that contains SWMT Logs:";

	private final static String  LOG_TYPE_FILE						= "File";

	private final static String  LOG_TYPE_DIRECTORY					= "Directory";	

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

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

	private final static String  GET_LOG_NOW_BUTTON 				= "Get SWMT Log Now";

	private final static String  LOGS 								= "Logs";

	private final static String  RECEIVED							= "Received";

	private final static String  RECEIVING_SWMT_LOG 				= "Receiving SWMT Log: ";

	private final static String  WAITING_FOR_TIMER					= "Waiting for timer to expire: ";

	private final static String  STOPPING_TIMER						= "Stopping timer: ";

	private final static String  TEXT_GET_LOG_WITH_TIMER			= "Get Log with Timer";

	private final static String  TEXT_INTERVAL						= "Interval:";

	private final static String  START_TIMER						= "Start Timer";

	private final static String  TEXT_SECOND						= "Seconds";

	private final static String  ERROR_INTERVAL						= "Time interval needs to be integer and more than zero.";

    /**

     * Constructor.

     * @param pageName name of the page

     * @param traceEngine TraceCore engine that is used when requesting data from TC

     */

    protected SWMTLogPage(String pageName, TraceCoreEngine traceEngine) {

		super(pageName);

		setTitle("System Wide Memory Tracking Wizard");

		setDescription("Define Source For SWMT logs that are imported. Logs can be imported from already existing files or from device via TraceViewer.");

		this.fileLogList = new ArrayList<SWMTLogInfo>();

		this.deviceLogList = new ArrayList<SWMTLogInfo>();

		this.traceEngine = traceEngine;

		this.createMemSpyProcesses();

		this.memSpyTimerRunning = false;

		this.memSpyOperationRunning = false;

		this.memSpyStopping = false;

		this.cycleNumber = 0;

		this.missedLogs = false;

    }

	@Override

	public void recalculateButtonStates() {

		// no implementation needed

	}

	@Override

	public void setInitialFocus() {

		timerCombo.setFocus();

	}

    /*

     * (non-Javadoc)

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

     */

	public void widgetDefaultSelected(SelectionEvent e) {

		// Not needed in this case

	}

	/*

	 * (non-Javadoc)

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

	 */

	public void widgetSelected(SelectionEvent e) {

		// Update controls after radio buttons state changes to false

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

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

			//When selection is changed, we clear the previous results.

			removeReceivedLogs();

			this.hideAndRevealItems();

		}	

		// open file dialog

		else if (e.widget == addFileButton) {

			// open file dialog for selecting a crash file

			FileDialog dialog = new FileDialog(this.getShell(), SWT.MULTI);

			dialog.setText(ADD_FILE_TEXT);

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

			dialog.setFilterExtensions(filterExt);

			if (dialog.open() != null ){

		        String[] files = dialog.getFileNames();

		        String directory = dialog.getFilterPath();

		        directory = MemSpyFileOperations.addSlashToEnd( directory );

		        boolean noLogFound = false;

		        for( String item : files ){

		        	// confirm that file is smwt log

		        	if( MemSpyLogParserEngine.isFileSWMTLog( new File(directory + item)) ){

		        		this.addFileLog( directory + item );	

		        	}

		        	else{

		 				noLogFound = true;

		        	}

		        }

		        // if some of the selected files is not swmt-file show error message.

		        if( noLogFound ){

	        		Status status = new Status(IStatus.ERROR, MemSpyPlugin.PLUGIN_ID, 0, "Some of the selected files is not SWMT-log file.", null);

			        // Display the dialog

			 	    ErrorDialog.openError(Display.getCurrent().getActiveShell(),ERROR_MEMSPY, null, status);

		        }

			}

		}

		// open directory dialog  

		else if (e.widget == addDirectoryButton) {

			// open file dialog for selecting a crash file

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

			dialog.setText(ADD_DIRECTORY_TEXT);

			String result = dialog.open();

			if (result != null ){

				File[] allFiles = MemSpyFileOperations.getFilesFromDirectory( new File( result ) );

				int swmtFileCount = 0;

				for ( File item : allFiles ){

					if( MemSpyLogParserEngine.isFileSWMTLog( item ) ){

						swmtFileCount++;

						this.addFileLog( item.toString() );

					}

				}

				// if no SWMT-log files were found from selected directory, show error message.

				if(swmtFileCount == 0){

	 				Status status = new Status(IStatus.ERROR, MemSpyPlugin.PLUGIN_ID, 0, "No SWMT-logs were found from selected directory.", null);

	 				// Display the dialog

			 	    ErrorDialog.openError(Display.getCurrent().getActiveShell(),ERROR_MEMSPY, null, status);

				}

			}

		}

		// remove selected log file 

		else if (e.widget == removeOneButton ){

			if( fileLogsTable.getSelectionCount() == 1 ){

				fileLogList.remove( fileLogsTable.getSelectionIndex() );

				this.refreshFileLogTable();

			}

		}

		// remove all log files

		else if (e.widget == removeAllButton ){

			fileLogList.clear();

			this.refreshFileLogTable();

		}

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

			// get wizard pointer and cast it to MemSpyWizard

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

			// update new settings to each wizard page.

			wizard.updateConnectionSettings();

		}

		// get log now from TC

		else if (e.widget == getLogNowButton ){

			this.getLogNowPressed();

		}

		// Remove all log received from device-button

		else if( e.widget == removeReceivedLogsButton ){

			this.removeReceivedLogs();

		}

		// SWMT timer started

		else if( e.widget == startTimerButton ){

			this.getLogWithTimerPressed();

		}	

		// if file logs table selection changes or button is pressed, enable and disable buttons

		if( e.widget == this.fileLogsTable || 

			e.widget == this.removeAllButton || 

			e.widget == this.removeOneButton || 

			e.widget == this.addFileButton || 

			e.widget == this.addDirectoryButton ){

			this.enableAndDisableFileButtons();

		}

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

	}

	/**

	 * Checks if wizard can be finished or not.

	 * @return boolean value if wizard can finish

	 */

	public boolean canFinish(){

		// if traceEngines taskList is not empty, return false

		if( traceEngine.getFirstTask() != null ){

			return false;

		}

		// if file or device log lists are not empty(depending on radiobutton selection) return true

		if( fileRadioButton.getSelection() ){

			if( fileLogList.size() > 0 ){

				return true;

			}

		}

		else{

			if( deviceLogList.size() > 0 ){

				return true;

			}

		}

		return false;

	}

	/**

	 * Hides and reveals controls according to radio button states.

	 */

	private void hideAndRevealItems() {

		boolean fileSelected = true;

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

			fileSelected = false;

		}

		// exclude/include needed controls

		fileSelectionGridData.exclude = !fileSelected;

		deviceGridData.exclude = fileSelected;

		if( !fileSelected ){

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

			deviceGroup.setSize( fileSelectionGroup.getSize() );

			deviceGroup.setLocation(fileSelectionGroup.getLocation());		

		}

		else{

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

			fileSelectionGroup.setSize( deviceGroup.getSize() );

			fileSelectionGroup.setLocation(deviceGroup.getLocation());

		}

		// Hide/show needed controls

		fileSelectionGroup.setVisible(fileSelected);

		deviceGroup.setVisible(!fileSelected);

	}

	/**

	 * Adds a log file.

	 * @param location of log file

	 */

	private void addFileLog( String location ){

		// create SWMTLogInfo object for log file.

		SWMTLogInfo info = new SWMTLogInfo();

		info.setType( SWMTLogType.FILE );

		info.setPath( location );

		fileLogList.add(info);

		// get files name

		String fileName = location.substring( location.lastIndexOf("\\") + 1 );

		// add name into table

		TableItem item = new TableItem( fileLogsTable, SWT.NONE, fileLogsTable.getItemCount() );

		item.setText( new String[]{ fileName, LOG_TYPE_FILE });

	}

	/**

	 * Updates file log table so that it contains same data that file log list.

	 */

	private void refreshFileLogTable(){

		//Remove all items

		fileLogsTable.removeAll();

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

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

			// get item

			SWMTLogInfo log = fileLogList.get(i);

			String fileName = log.getPath();

			String fileType = LOG_TYPE_DIRECTORY;

			// Remove path if type is file

			if( log.getType() == SWMTLogType.FILE ){

				fileName = fileName.substring( fileName.lastIndexOf("\\") + 1 );

				fileType = LOG_TYPE_FILE;

			}

			newItem.setText( new String[]{ fileName, fileType } );

		}

	}

	/**

	 * Removed received logs.

	 */

	private void removeReceivedLogs(){

		// Delete all items in deviceLogList and deviceLogsTable

		deviceLogList.clear();

		deviceLogsTable.removeAll();

		// Delete all temp files

		MemSpyFileOperations.deleteTempMemSpyFiles();

		// set cycle number to zero

		cycleNumber = 0;

		// reset missed logs value

		missedLogs = false;

		// enable and disable buttons

		this.enableAndDisableDeviceButtonsAndSWMTCategoryGroup();

	}

	/**

	 * Gets list of log files that are in currently selected table.

	 * @return list of log files that are in currently selected table

	 */

	public ArrayList<SWMTLogInfo> getLogList(){

		if( fileRadioButton.getSelection() ){

			return fileLogList;

		}

		else{

			return deviceLogList;

		}

	}

 	/**

 	 * Updates connection text to match used settings.

 	 */

 	public void updateConnectionText(){

		// Updating connection name.

 		String displayName = MemSpyPlugin.getTraceProvider().getDisplayNameForCurrentConnection();

 		connectionNameInUseLabel.setText(displayName);

 		loggingComposite.layout(); 			

 	}

	/**

	 * Loads previous values into UI components.

	 */	

	private void loadUserEnteredData(){

		// if last value is not found, set selection file.		

		UserEnteredData data = new UserEnteredData();

		int lastUsedSource = data.getPreviousRadioButtonSelection( ValueTypes.SWMT );

		// Restoring previous state of radio buttons only if device import is also possible and was previously selected

		if(MemSpyPlugin.isTraceProviderAvailable() && lastUsedSource == DEVICE_RADIO_BUTTON_SELECTION_INDEX){

			deviceRadioButton.setSelection( true );

			fileRadioButton.setSelection( false );

		}

		else{

			deviceRadioButton.setSelection( false );

			fileRadioButton.setSelection( true );			

		}

		// Restore previous values to file combobox

		String[] lastUsedFiles = data.getPreviousValues( ValueTypes.SWMT );

		if (lastUsedFiles != null) {

			timerCombo.setItems(lastUsedFiles);

			timerCombo.select(0);