/*
* Copyright (c) 2008 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.crashanalyser.ui.wizards;

import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.swt.SWT;
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.FileDialog;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.dnd.DND;
import org.eclipse.swt.dnd.DropTarget;
import org.eclipse.swt.dnd.DropTargetEvent;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.events.*;
import org.eclipse.ui.PlatformUI;
import com.nokia.s60tools.ui.wizards.S60ToolsWizardPage;
import com.nokia.s60tools.crashanalyser.export.ICrashFileProvider;
import com.nokia.s60tools.crashanalyser.files.CrashAnalyserFile;
import com.nokia.s60tools.crashanalyser.model.*;
import com.nokia.s60tools.crashanalyser.resources.*;
import com.nokia.s60tools.crashanalyser.data.*;
import java.io.*;

/**
 * This 1st Wizard page queries the user for a crash file or folder from which Crash 
 * files are found. 
 *
 */
public class FileOrPathSelectionPage extends S60ToolsWizardPage implements SelectionListener,
																			ModifyListener,
																			DropTargetListener {

	Combo comboFileOrPath;
	Button buttonBrowseFolder;
	Button buttonBrowseFile;
	Button buttonReadFilesFromDevice;
	Label labelComboTitle;
	Label labelOr;
	DecoderEngine engine;
	ErrorLibrary errorLibrary;
	String providedFileOrFolder;
	CrashAnalyserWizard parentWizard;
	ICrashFileProvider fileProvider = null;
	
	/**
	 * Constructor
	 * @param decEng decoder engine 
	 * @param library error library
	 */
	public FileOrPathSelectionPage(DecoderEngine decEng, 
									ErrorLibrary library,
									String prefilledFileOrFolder,
									CrashAnalyserWizard parent,
									ICrashFileProvider crashFileProvider) {
		super("");
			
		setTitle("Crash Files Selection");
			
		setDescription("MobileCrash File (*.bin), D_EXC File (*.txt), Decoded File (*.crashxml), ELF Core Dump File (*.elf)");
		
		engine = decEng;
		errorLibrary = library;
		providedFileOrFolder = prefilledFileOrFolder;
		parentWizard = parent;
		fileProvider = crashFileProvider;

		// User cannot finish the page before some valid 
		// selection is made.
		setPageComplete(false);
		
	 }
	
	
	@Override
	public void recalculateButtonStates() {
		// no implementation needed
	}

	@Override
	public void setInitialFocus() {
		comboFileOrPath.setFocus();
	}
	

	/**
	 * Creates all UI controls
	 */
	public void createControl(Composite parent) {
		Composite composite =  new Composite(parent, SWT.NULL);
		
	    // create the desired layout for this wizard page
		GridLayout gl = new GridLayout();
		gl.numColumns = 3;
		composite.setLayout(gl);
		
		GridData titleGD = new GridData(GridData.FILL_HORIZONTAL);
		titleGD.horizontalSpan = 3;

		// Combo title
		labelComboTitle = new Label(composite, SWT.LEFT);
		labelComboTitle.setText("A Crash File or a Folder Containing Crash Files:");
		titleGD.horizontalSpan = 3;
		labelComboTitle.setLayoutData(titleGD);
		
		// MobileCrash path combo
		comboFileOrPath = new Combo(composite, SWT.BORDER);
		GridData comboGD = new GridData(GridData.FILL_HORIZONTAL);
		comboFileOrPath.setLayoutData(comboGD);
		comboFileOrPath.addModifyListener(this);
		

		// Restore previous values to MobileCrash path combo
		UserEnteredData data = new UserEnteredData();
		String[] lastUsed = data.getPreviousValues(UserEnteredData.ValueTypes.CRASH_FILE_OR_PATH);
		if (lastUsed != null) {
			comboFileOrPath.setItems(lastUsed);
			comboFileOrPath.select(0);
		}
		
		// Browse folder button
		buttonBrowseFolder = new Button(composite, SWT.PUSH);
		buttonBrowseFolder.setText("Folder...");
		buttonBrowseFolder.addSelectionListener(this);

		// Browse file button
		buttonBrowseFile = new Button(composite, SWT.PUSH);
		buttonBrowseFile.setText("File...");
		buttonBrowseFile.addSelectionListener(this);
		
		// OR label
		labelOr = new Label(composite, SWT.LEFT);
		labelOr.setText("OR");
		labelOr.setLayoutData(titleGD);
		if (fileProvider == null)
			labelOr.setVisible(false);
		
		// Read Files from Device button
		buttonReadFilesFromDevice = new Button(composite, SWT.PUSH);
		if (fileProvider == null) {
			buttonReadFilesFromDevice.setVisible(false);
		} else {
			buttonReadFilesFromDevice.setText(fileProvider.getFunctionalityName());
			buttonReadFilesFromDevice.setToolTipText(fileProvider.getFunctionalityDescription());
		}
		buttonReadFilesFromDevice.addSelectionListener(this);
		
		setHelps();

		setInitialFocus();
		
		setControl(composite);
		
		if (!"".equals(providedFileOrFolder)) {
			comboFileOrPath.setText(providedFileOrFolder);
		}
		
		Transfer[] types = new Transfer[] { FileTransfer.getInstance() };
	    DropTarget dropTarget = new DropTarget(composite, DND.DROP_COPY);
	    dropTarget.setTransfer(types);
	    dropTarget.addDropListener(this);		
	}
	
	
	public void widgetDefaultSelected(SelectionEvent e)	{
		// no implementation needed
	}
	
	public void widgetSelected(SelectionEvent e) {
		
		// browse directory button
		if (e.widget == buttonBrowseFolder) {
			// open directory dialog for selecting directory which contains crash files
			DirectoryDialog dialog = new DirectoryDialog(this.getShell());
			dialog.setText("Select crash files path");
			String result = dialog.open();
			comboFileOrPath.setText(result);
			
		// browse file button
		} else if (e.widget == buttonBrowseFile){
			// open file dialog for selecting a crash file
			FileDialog dialog = new FileDialog(this.getShell());
			dialog.setText("Select a crash file");
			String[] filterExt = { "*."+CrashAnalyserFile.MOBILECRASH_FILE_EXTENSION, 
									"*."+CrashAnalyserFile.OUTPUT_FILE_EXTENSION,
									"*."+CrashAnalyserFile.D_EXC_FILE_EXTENSION,
									"*."+CrashAnalyserFile.ELF_CORE_DUMP_FILE_EXTENSION};
	        dialog.setFilterExtensions(filterExt);			
			String result = dialog.open();
			comboFileOrPath.setText(result);
			
		// Read Files from Device button
		} else if (e.widget == buttonReadFilesFromDevice) {
			parentWizard.moveToSecondPageRequest(true);
		}
	}
	
	public void modifyText(ModifyEvent event) {
		if(event.widget.equals(comboFileOrPath)){
			try {
				getWizard().getContainer().updateButtons();
			} catch (Exception e) {
			}
		}
	}
	
	/**
	 * Checks if user has selected a valid directory or file
	 */
	public boolean canFlipToNextPage() {
		try {
			// nothing is selected
			if (comboFileOrPath.getText().length() <= 0) {
				this.setErrorMessage(null);
				return false;
			}
			
			File file = new File(comboFileOrPath.getText());
			
			// user has selected a directory
			if (file.isDirectory() && file.exists()) {
				// if selected path has crash files, we can proceed to next page
				if (engine.isPathValid(comboFileOrPath.getText(), DecoderEngine.PathTypes.CRASH)) {
					this.setErrorMessage(null);
					return true;
				}
				// selected path does not contain crash files, show error
				else {
					this.setErrorMessage("Selected path does not contain any crash files");
					return false;
				}
			// user has selected a single file
			} else if (file.isFile() && file.exists()) {
				// file seems to be a known crash file type
				if (DecoderEngine.isFileValidCrashFile(file)) {
					this.setErrorMessage(null);
					return true;
				// file type is not a crash file
				} else {
					this.setErrorMessage("Invalid file");
					return false;
				}
			// user has not selected a folder nor a file
			} else {
				this.setErrorMessage("Invalid file or folder.");
				return false;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}	
	
	/**
	 * Returns the user provided crash file directory if it is a directory
	 * @return the user provided crash file directory if it is a directory, otherwise ""
	 */
	public String getSelectedFolder() {
		if (comboFileOrPath.getText().length() <= 0) {
			return "";
		}
		
		File file = new File(comboFileOrPath.getText());
		
		// user has selected a directory
		if (file.isDirectory() && file.exists()) {
			return comboFileOrPath.getText();
		}
		
		return "";
	}
	
	/**
	 * Returns the user provided crash file or crash file directory
	 * @return the user provided crash file or crash file directory
	 */
	public String getSelectedFileOrFolder() {
		return comboFileOrPath.getText();
	}
	
	/**
	 * When next press has been processed, this should be called to inform
	 * if any errors were found during next press processing
	 * @param error
	 */
	public void errorInProcessingNextPress(boolean error) {
		if (error)
			this.setErrorMessage("Could not read files");
		else
			this.setErrorMessage(null);
	}
	
	/**
	 * Saves current combo value so that it will be the default value
	 * next time this wizard is shown.
	 */
	public void saveUserEnteredData() {
		UserEnteredData userData = new UserEnteredData();
		userData.saveValue(UserEnteredData.ValueTypes.CRASH_FILE_OR_PATH, comboFileOrPath.getText());			
	}
	
	/**
	 * Sets this page's context sensitive helps
	 *
	 */
	protected void setHelps() {
		PlatformUI.getWorkbench().getHelpSystem().setHelp(comboFileOrPath,
				HelpContextIDs.CRASH_ANALYSER_HELP_IMPORT_CRASH_FILES);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(buttonBrowseFolder,
				HelpContextIDs.CRASH_ANALYSER_HELP_IMPORT_CRASH_FILES);		
		PlatformUI.getWorkbench().getHelpSystem().setHelp(buttonBrowseFile,
				HelpContextIDs.CRASH_ANALYSER_HELP_IMPORT_CRASH_FILES);		
	}
	
	/**
	 * Executes drop functionality when files are drag&dropped to wizard page.
	 * Checks whether dropped files are supported and starts "presses next automatically"
	 * @param files drag&dropped files (paths)
	 */
	void executeDrop(String[] files) {
		// just one (supported) file dropped
		if (files.length == 1 && DecoderEngine.isFileValidCrashFile(files[0])) {
			comboFileOrPath.setText(files[0]);
			parentWizard.moveToSecondPageRequest(files);
		// multiple files dropped
		} else if (files.length > 1) {
			String path = "";
			// go through all dropped files, and check that they are from same folder
			// (wizard doesn't know how to handle multiple files from multiple locations)
			for (int i = 0; i < files.length; i++) {
				if (DecoderEngine.isFileValidCrashFile(files[i])) {
					if ("".equals(path)) {
						path = FileOperations.getFolder(files[i]);
					} else if (!FileOperations.getFolder(files[i]).equalsIgnoreCase(path)){
						showMessage("Multiple files from different folders are not supported");
						break;
					}
				} else {
					showMessage("Unsupported file type");
					break;
				}
			}
			comboFileOrPath.setText(path);
			parentWizard.moveToSecondPageRequest(files);
		} else {
			showMessage("Unsupported file type");
		}
	}
	
	/**
	 * Shows a message box with given message
	 * @param message
	 */
	private void showMessage(String message) {
		MessageDialog.openInformation(
			comboFileOrPath.getShell(),
			"Crash Analyser",
			message);
	}
	
	public void dragEnter(DropTargetEvent event) {
		event.detail = DND.DROP_COPY;
	}

	public void dragLeave(DropTargetEvent event) {
		// nothing to be done
	}

	public void dragOperationChanged(DropTargetEvent event) {
		// nothing to be done
	}

	public void dragOver(DropTargetEvent event) {
		event.feedback = DND.FEEDBACK_NONE;
	}

	public void drop(DropTargetEvent event) {
		// we accept only file drops
		if (FileTransfer.getInstance().isSupportedType(event.currentDataType)) {
			if (event.data != null) {
				String[] files = (String[])event.data;
				executeDrop(files);
			}
		}
	}

	public void dropAccept(DropTargetEvent event) {
		// nothing to be done
	}
	
}