/*

* 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.creator.job;

import java.io.File;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.dialogs.IDialogConstants;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.Shell;

import com.nokia.s60tools.creator.CreatorActivator;

import com.nokia.s60tools.creator.common.ProductInfoRegistry;

import com.nokia.s60tools.creator.preferences.CreatorPreferences;

import com.nokia.s60tools.creator.resources.Messages;

import com.nokia.s60tools.creator.util.CreatorEditorConsole;

import com.nokia.s60tools.hticonnection.services.AppStatus;

import com.nokia.s60tools.hticonnection.services.HTIServiceFactory;

import com.nokia.s60tools.hticonnection.services.IApplicationControlService;

import com.nokia.s60tools.hticonnection.services.IConnectionTestService;

import com.nokia.s60tools.hticonnection.services.IFTPListener;

import com.nokia.s60tools.hticonnection.services.IFTPRequestManager;

import com.nokia.s60tools.hticonnection.services.IFTPService;

import com.nokia.s60tools.util.exceptions.JobCancelledByUserException;

import com.nokia.s60tools.util.resource.FileUtils;

/**

 * Job for uploading files

 */

public class RunInDeviceJob extends Job implements IManageableJob, IFTPListener {

	private static final String CREATOR_EXE_NAME = ProductInfoRegistry.getCreatorSymbianExcecutableName();

	private String srcFilePath;

	private String destFilePath;

	private static int timeout = 30*1000; // Default timeout 30 s.

	private IProgressMonitor monitor;

	private String destFileName;

	private int confirmDialogSelection = -1;

	private IFTPRequestManager FTPReguestManager;

	/**

	 * Constructor

	 * @param name Name for job

	 * @param srcFilePath Source file path

	 * @param destFilePath Destination file path

	 */

	public RunInDeviceJob(String name, String srcFilePath, String destFilePath, String destFileName ) {

		super(name);

		this.srcFilePath = srcFilePath;

		this.destFilePath = destFilePath;

		this.destFileName = destFileName;

		setUser(true);

		setTimeOut();

	}

	/**

	 * Setting the timeout for operation.

	 */

	private void setTimeOut() {

		File srcFile = new File(srcFilePath);

		Long bytes = new Long( srcFile.length());

		//Setting time out to be 10 ms for byte, e.g script with few element is 300 bytes long, then timeout will be 30s

		int countTimeOut = bytes.intValue() * 10;

		//

		int maxTimeOut = 2*60*1000;

		//If we count longer than default time out, and it does not reach maximum time out, we set new timeout

		if(countTimeOut > timeout && countTimeOut < maxTimeOut ){

			timeout = countTimeOut;

		}

		//if we count longer than max timeout, using max timeout

		else if(countTimeOut > maxTimeOut){

			timeout = maxTimeOut;

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.core.runtime.jobs.Job#run(org.eclipse.core.runtime.IProgressMonitor)

	 */

	protected IStatus run(IProgressMonitor monitor) {

		this.monitor = monitor;

		try{

			CreatorJobManager.getInstance().registerJob(this);			

			//First check if HTI is running

			IFTPService service = HTIServiceFactory

					.createFTPService(CreatorEditorConsole.getInstance());			

			IConnectionTestService connService = HTIServiceFactory

				.createConnectionTestService(CreatorEditorConsole.getInstance());

			checkCancel();			

			//If HTI is not running, returning error

			if(!connService.isReady()){

				String msg = Messages.getString("RunInDeviceJob.HTINotRunning_ErrMsg");

				CreatorEditorConsole.getInstance().println(

						msg, CreatorEditorConsole.MSG_ERROR); //$NON-NLS-1$

				return new Status(

						Status.ERROR,

						CreatorActivator.PLUGIN_ID,

						msg); //$NON-NLS-1$				

			}

			checkCancel();

			//Then upload file

			try {

				monitor.beginTask(getName(), IProgressMonitor.UNKNOWN); //$NON-NLS-1$

				boolean replace = CreatorPreferences.getDontAskFileReplaceInDevice();

				if(!replace){

					monitor.subTask(Messages.getString("RunInDeviceJob.CheckFileExistence_TaskName")); //$NON-NLS-1$

					replace = true;

					//Before load, check if there is file allready

					checkCancel();					

					String deviceSaveFolded = CreatorPreferences.getDeviceSaveFolded();

					String[] files = service.listFiles(deviceSaveFolded, 0);

					if(files != null && files.length > 0){

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

							if(destFileName.equalsIgnoreCase(files[i])){

								//File allready exist

								replace = showReplaceFileDialog();

								break;

							}

						}

					}

				}

				//If replacing (or file does not exist) uploading file to device, 

				//if user does not upload file, existing file will be executed in device.

				if(replace){

					checkCancel();

					monitor.subTask(Messages.getString("RunInDeviceJob.Upload_File_SubTaskName")); //$NON-NLS-1$

					StringBuffer buf = FileUtils.loadDataFromFile(srcFilePath);

					if (buf != null) {

						String fileString = buf.toString();

						checkCancel();	

						service.uploadFile(fileString.getBytes(), destFilePath, this, timeout);

					}					

				}

			}

			catch(JobCancelledByUserException e){

				return Status.CANCEL_STATUS;

			}			

			catch (Exception e) {			

				String msg = Messages.getString("RunInDeviceJob.Upload_Failed_ConsoleErrorMsg");

				return returnErrorStatus(e, msg);

			} 

			checkCancel();

			try {

				IApplicationControlService appService = HTIServiceFactory.createApplicationControlService(CreatorEditorConsole.getInstance());

				String programName = CREATOR_EXE_NAME;

				String parameters = destFilePath;							

				//Checking Creator application status in device

				checkCancel();

				monitor.subTask(Messages.getString("RunInDeviceJob.CheckIfRunning_SubTaskName")); //$NON-NLS-1$							

				AppStatus status = appService.getApplicationStatusByName(programName, timeout);

				//If creator is running, stopping it

				checkCancel();				

				if(status.getStatus() == AppStatus.RUNNING){

					//Showing dialog to as if user wants to shutdown creator

					//If user selects Cancel, JobCancelledByUserException is thrown

					showShutdownDialog();

					monitor.subTask(Messages.getString("RunInDeviceJob.StopCreator_SubTaskName")); //$NON-NLS-1$					

					appService.stopApplicationByName(programName, timeout);

				}

				//Showing user that he/she should follow progress in device/emulator

				showInformation();																													

				//Start to run script

				checkCancel();				

				monitor.subTask(Messages.getString("RunInDeviceJob.Run_File_SubTaskName")); //$NON-NLS-1$							

				appService.startProcess(programName, parameters, timeout);

			}

			catch(JobCancelledByUserException e){

				return Status.CANCEL_STATUS;

			}

			catch (Exception e){

				String msg = Messages.getString("RunInDeviceJob.Run_Failed_ConsoleErrorMsg");

				return returnErrorStatus(e, msg);

			}		

		}

		catch(JobCancelledByUserException e){

			return Status.CANCEL_STATUS;

		}

		finally {

			finished();

		}

		return Status.OK_STATUS;

	}

	/**

	 * Showing user a dialog to shutdown Creator in device or not,

	 * @throws JobCancelledByUserException if user selects Cancel

	 */

	private void showShutdownDialog() throws JobCancelledByUserException {		

		if(!CreatorPreferences.getDontAskShutdownCreator()){

			Runnable runDlg = new Runnable(){

				public void run() {

					//

					ShutdownCreatorInDeviceDialog dlg = new ShutdownCreatorInDeviceDialog(CreatorActivator.getCurrentlyActiveWbWindowShell());

					dlg.open();

					confirmDialogSelection = dlg.getSelection();

				}

			};

			Display.getDefault().syncExec(runDlg);

			if(confirmDialogSelection == IDialogConstants.CANCEL_ID){

				throwJobCancelledException();

			}

		}

	}

	/**

	 * Shows user an information dialog to follow execution in device.

	 */

	private void showInformation() {

		if(!CreatorPreferences.getDontAskShowInformation()){

		Runnable showInfo = new Runnable(){

			public void run() {

				WatchDeviceInformationDialog dlg = new WatchDeviceInformationDialog(

						CreatorActivator.getCurrentlyActiveWbWindowShell(),

						destFileName);

				dlg.open();

			}

		};

		Display.getDefault().asyncExec(showInfo);

		}

	}

	/**

	 * Check if job is canceled, and throws an exception if it's.

	 * @throws JobCancelledByUserException

	 */

	private void checkCancel() throws JobCancelledByUserException {

		if(monitor.isCanceled()){

			if(FTPReguestManager != null){

				FTPReguestManager.cancel();

			}

			throwJobCancelledException();

		}

	}

	/**

	 * Throw cancel exception

	 * @throws JobCancelledByUserException

	 */

	private void throwJobCancelledException() throws JobCancelledByUserException {

		throw new JobCancelledByUserException(Messages.getString("RunInDeviceJob.JobCanceledByUser_Msg"));

	}

	/**

	 * Check if user wants to replace existing file

	 * @return <code>true</code> if replace, <code>false</code> otherwise.

	 * @throws JobCancelledByUserException 

	 */

	private boolean showReplaceFileDialog() throws JobCancelledByUserException {

		Runnable runDlg = new Runnable(){

			public void run() {

				//

				Shell shell = CreatorActivator.getCurrentlyActiveWbWindowShell();

				ConfirmFileReplaceDialog dlg = new ConfirmFileReplaceDialog(

						shell, destFilePath);

				dlg.open();

				confirmDialogSelection = dlg.getSelection();

			}

		};

		Display.getDefault().syncExec(runDlg);

		if(confirmDialogSelection == IDialogConstants.CANCEL_ID){

			throwJobCancelledException();

		}

		boolean replace = confirmDialogSelection == IDialogConstants.YES_ID ? true : false;		

		return replace;

	}

	/**

	 * Returns Error status

	 * @param e

	 * @param msg

	 * @return {@link Status} with {@link Status#ERROR}

	 */

	private IStatus returnErrorStatus(Exception e, String msg) {

		CreatorEditorConsole.getInstance().println(

				msg, CreatorEditorConsole.MSG_ERROR); //$NON-NLS-1$

		e.printStackTrace();			

		return new Status(

				Status.ERROR,

				CreatorActivator.PLUGIN_ID,

				msg, e); //$NON-NLS-1$

	}

	/**

	 * Done and unregister job

	 */

	private void finished() {

		monitor.done();

		CreatorJobManager.getInstance().unregisterJob(this);

	}

	/* (non-Javadoc)

	 * @see com.nokia.s60tools.remotecontrol.job.IManageableJob#forcedShutdown()

	 */

	public void forcedShutdown() {

		cancel();

	}

	/* (non-Javadoc)

	 * @see com.nokia.s60tools.hticonnection.services.IFTPListener#requestEnded(com.nokia.s60tools.hticonnection.services.IFTPRequestManager)

	 */

	public void requestEnded(IFTPRequestManager manager) {

		// not needed		

	}

	/* (non-Javadoc)

	 * @see com.nokia.s60tools.hticonnection.services.IFTPListener#requestInQueue(com.nokia.s60tools.hticonnection.services.IFTPRequestManager)

	 */

	public void requestInQueue(IFTPRequestManager manager) {

		// not needed

	}

	/* (non-Javadoc)

	 * @see com.nokia.s60tools.hticonnection.services.IFTPListener#requestStarted(com.nokia.s60tools.hticonnection.services.IFTPRequestManager)

	 */

	public void requestStarted(IFTPRequestManager manager) {

		FTPReguestManager = manager;

	}

}