/*

 * 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.model;

import java.io.*;

import com.nokia.s60tools.crashanalyser.files.*;

import com.nokia.s60tools.crashanalyser.interfaces.IDecodingObserver;

import com.nokia.s60tools.crashanalyser.plugin.*;

import com.nokia.s60tools.crashanalyser.corecomponents.interfaces.CommandLineManager;

import com.nokia.s60tools.crashanalyser.data.*;

import java.util.ArrayList;

import java.util.List;

import org.eclipse.core.runtime.*;

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

/**

 * This class handles the actual decoding Crash files process. Data entered by

 * user in Wizard pages are passed to this class and this class then handles it

 * properly.

 * 

 */

public class DecoderEngine extends Job {

	protected static final String TOOLS_FOLDER = "tools";

	protected static final String WORK_FOLDER = "work";

	protected static final String TEMPORARY_FOLDER = "temp";

	protected static final String CRASH_FILES_FOLDER = "CrashFiles";

	protected static final String MAP_FILES_ZIP_FOLDER = "MapFilesZip";

	protected static final String SELGE_EVENT_INI = "selge_event.ini";

	protected static final String ERROR_FILE_EXTENSION = "error";

	protected static final int MAX_FILE_COUNT = 500;

	public static enum PathTypes {

		CRASH, SYMBOL

	}

	private List<CrashFileBundle> crashFiles = null;

	private IDecodingObserver decodingObserver = null;

	private DecodingData decodingData = null;

	/**

	 * Constructor

	 */

	public DecoderEngine() {

		super("Handling Crash Files (Note! This might take several minutes)");

	}

	/**

	 * Returns path where selge_event.ini

	 * 

	 * @return path where selge_event.ini is located

	 */

	public static String getSelgeEventIniFile() {

		return FileOperations.addSlashToEnd(CrashAnalyserPlugin

				.getPluginInstallPath())

				+ FileOperations.addSlashToEnd(TOOLS_FOLDER) + SELGE_EVENT_INI;

	}

	/**

	 * Checks whether given file is a known crash file

	 * 

	 * @param file

	 *            crash file

	 * @return true if file seems to be a known crash file, false if not

	 */

	public static boolean isFileValidCrashFile(String file) {

		return isFileValidCrashFile(new File(file));

	}

	/**

	 * Checks whether given file is a known crash file

	 * 

	 * @param file

	 *            crash file

	 * @return true if file seems to be a known crash file, false if not

	 */

	public static boolean isFileValidCrashFile(File file) {

		try {

			// file must be a file and it must exist

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

				String fileName = file.getName();

				// file extension must match known extension types

				if (fileName

						.endsWith(CrashAnalyserFile.MOBILECRASH_FILE_EXTENSION)

						|| fileName

								.endsWith(CrashAnalyserFile.OUTPUT_FILE_EXTENSION)

						|| fileName

								.endsWith(CrashAnalyserFile.D_EXC_FILE_EXTENSION)

						|| fileName

								.endsWith(CrashAnalyserFile.ELF_CORE_DUMP_FILE_EXTENSION))

					return true;

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return false;

	}

	/**

	 * Checks if given path contains any Crash files.

	 * 

	 * @param path

	 *            from where Crash files should be found

	 * @return true if given path contains Crash files, false if not

	 */

	protected boolean isCrashPathValid(String path) {

		try {

			File file = new File(path);

			if (!file.isDirectory())

				return false;

			// We are looking for files *.bin, or *.txt or *.crashxml

			FilenameFilter filter = new FilenameFilter() {

				public boolean accept(File dir, String name) {

					return (name

							.endsWith(CrashAnalyserFile.MOBILECRASH_FILE_EXTENSION)

							|| name

									.endsWith(CrashAnalyserFile.OUTPUT_FILE_EXTENSION)

							|| name

									.endsWith(CrashAnalyserFile.D_EXC_FILE_EXTENSION)

							|| name

									.endsWith(CrashAnalyserFile.ELF_CORE_DUMP_FILE_EXTENSION));

				}

			};

			File[] files = file.listFiles(filter);

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

				return true;

			return false;

		} catch (Exception e) {

			return false;

		}

	}

	/**

	 * Returns an empty working folder under workspace.

	 * 

	 * @param clean

	 *            defines whether the folder should be cleared

	 * @return E.g.

	 *         C:\My_Workspace\.metadata\.plugins\com.nokia.s60tools.crashanalyser

	 *         \work\

	 */

	public static String getWorkingFolder(boolean clean) {

		String workingFolder = FileOperations

				.addSlashToEnd(getPluginWorkingLocation());

		workingFolder += FileOperations.addSlashToEnd(WORK_FOLDER);

		// creates the folder. if the folder already exists, deletes its content

		FileOperations.createFolder(workingFolder, clean);

		return workingFolder;

	}

	/**

	 * Creates a new folder for crash file. E.g.

	 * C:\My_Workspace\.metadata\.plugins

	 * \com.nokia.s60tools.crashanalyser\CrashFiles\5\

	 * 

	 * @return created folder, or null if failed

	 */

	public static String getNewCrashFolder() {

		String crashFilesFolder = FileOperations

				.addSlashToEnd(getCrashFilesFolder());

		for (int i = 1; i < MAX_FILE_COUNT; i++) {

			File freeFolder = new File(crashFilesFolder + Integer.toString(i));

			if (!freeFolder.exists()) {

				FileOperations.createFolder(freeFolder.getAbsolutePath());

				return freeFolder.getAbsolutePath();

			}

		}

		return null;

	}

	/**

	 * Creates a new folder for temporary crash files. This folder is used for

	 * crash files which are read from device.

	 * 

	 * @param clean

	 *            defines whether the folder should be cleared

	 * @return E.g.

	 *         C:\My_Workspace\.metadata\.plugins\com.nokia.s60tools.crashanalyser

	 *         \temp

	 */

	public static String getTemporaryCrashFileFolder(boolean clean) {

		String tempFolder = FileOperations

				.addSlashToEnd(getPluginWorkingLocation());

		tempFolder += TEMPORARY_FOLDER;

		// creates the folder. if the folder already exists, deletes its content

		FileOperations.createFolder(tempFolder, clean);

		return tempFolder;

	}

	/**

	 * Checks whether given path is valid (i.e. contains correct files etc)

	 * 

	 * @param path

	 *            path to be checked

	 * @param pathType

	 *            defines "how" the path is validated

	 * @return true if path is valid, false if not

	 */

	public boolean isPathValid(String path, PathTypes pathType) {

		boolean retVal = false;

		if (PathTypes.CRASH.equals(pathType))

			retVal = isCrashPathValid(path);

		return retVal;

	}

	/**

	 * Decoder Engine owns crash files which are being handled by Crash Analyser

	 * wizard. This will get all files which are currently being handled.

	 * 

	 * @return list of crash files.

	 */

	public List<CrashFileBundle> getCrashFiles() {

		return crashFiles;

	}

	/**

	 * This method is used to set crash files which are to be decoded. This

	 * method is used when user has selected files to be re-decoded.

	 * 

	 * @param files

	 *            files to be decoded

	 */

	public void setCrashFiles(List<CrashFileBundle> files) {

		crashFiles = files;

	}

	/**

	 * This method executes CrashAnalyser.exe for summary information for given

	 * file or folder.

	 * 

	 * @param fileOrFolder

	 *            a file or a folder

	 * @param errorLibrary

	 *            Error Library

	 * @param progress

	 *            progress monitor

	 * @return true if any files were found for summary info, false if not

	 */

	public boolean processSummaryInfoForFiles(String fileOrFolder,

			ErrorLibrary errorLibrary, IProgressMonitor progress) {

		if (crashFiles != null)

			crashFiles.clear();

		String workingFolder = DecoderEngine.getWorkingFolder(true);

		if (!"".equals(fileOrFolder)) {

			String originatingDirectory = fileOrFolder;

			File f = new File(fileOrFolder);

			// if only one .crashxml file is selected, no need to run command

			// line

			if (f.isFile()

					&& fileOrFolder

							.endsWith(CrashAnalyserFile.OUTPUT_FILE_EXTENSION)) {

				FileOperations.copyFile(f, workingFolder, true);

				originatingDirectory = FileOperations.getFolder(fileOrFolder);

				// one binary file is selected, run CrashAnalyser.exe for

				// summary data

			} else if (f.isFile()) {

				CommandLineManager.executeSummary(workingFolder, fileOrFolder,

						CrashAnalyserFile.SUMMARY_FILE_EXTENSION, progress);

				originatingDirectory = FileOperations.getFolder(fileOrFolder);

				// directory was given

			} else {

				// copy .crashxml files to working folder.

				// copySummaryFilesToWorkingDirectory will return true if folder

				// contained only .crashxml files -> so if false is returned, it

				// means that we need to run CrashAnalyser.exe for other files

				// in the directory.

				if (!copyCrashFilesToWorkingDirectory(fileOrFolder,

						workingFolder))

					CommandLineManager.executeSummary(workingFolder,

							fileOrFolder,

							CrashAnalyserFile.SUMMARY_FILE_EXTENSION, progress);

			}

			readSummaryFiles(workingFolder, originatingDirectory, errorLibrary);

		}

		if (crashFiles.isEmpty())

			return false;

		return true;

	}

	/**

	 * copies all crashfiles (.crashxml) from given folder to given workfolder.

	 * 

	 * @param fromFolder

	 *            folder where crash files are copied from

	 * @param workingFolder

	 *            folder where crash files are copied to

	 * @return true if fromFolder contained only crash files (.crashxml), false

	 *         if folder contained other files also

	 */

	boolean copyCrashFilesToWorkingDirectory(String fromFolder,

			String workingFolder) {

		boolean retval = true;

		File from = new File(fromFolder);

		// given from folder needs to be an existing directory

		if (from.isDirectory() && from.exists()) {

			String[] files = from.list(); // get all files

			// if files were found

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

				// go through all files in fromFolder

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

					String file = files[i];

					// files is .crashxml

					if (file.endsWith(CrashAnalyserFile.OUTPUT_FILE_EXTENSION)) {

						FileOperations.copyFile(new File(FileOperations

								.addSlashToEnd(fromFolder)

								+ file), workingFolder, true);

						// file was not .crashxml

					} else {

						retval = false;

					}

				}

			}

		}

		return retval;

	}

	/**

	 * Reads all summary and crash files (.xml & .crashxml) from given

	 * directory. Creates a CrashFileBundle for all found files and adds them to

	 * this.crashFiles

	 * 

	 * @param summaryFileDirectory

	 *            directory where files are to be read from

	 * @param originatingDirectory

	 *            directory from where the original files are being imported

	 * @param errorLibrary

	 *            Error Library

	 */

	void readSummaryFiles(String summaryFileDirectory,

			String originatingDirectory, ErrorLibrary errorLibrary) {

		File file = new File(summaryFileDirectory);

		crashFiles = new ArrayList<CrashFileBundle>();

		// read all files from the directory

		if (file.isDirectory()) {

			// accept summary and output files (.xml & .crashxml)

			FilenameFilter filter = new FilenameFilter() {

				public boolean accept(File dir, String name) {

					return (name

							.endsWith(CrashAnalyserFile.OUTPUT_FILE_EXTENSION) || name

							.endsWith("."

									+ CrashAnalyserFile.SUMMARY_FILE_EXTENSION));

				}

			};

			File[] files = file.listFiles(filter);

			// go through all found files

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

				File crashFile = files[i];

				// file is output.crashxml type

				if (crashFile.getName().endsWith(

						CrashAnalyserFile.OUTPUT_FILE_EXTENSION)) {

					CrashFile crashxml = CrashFile

							.read(crashFile, errorLibrary);

					if (crashxml != null)

						crashFiles.add(new CrashFileBundle(crashxml,

								originatingDirectory));

					// file is summary file

				} else {

					SummaryFile summaryXml = SummaryFile.read(crashFile,

							errorLibrary);

					if (summaryXml != null)

						crashFiles.add(new CrashFileBundle(summaryXml,

								originatingDirectory));

				}

			}

		}

	}

	/**

	 * Used for passing decoding parameters

	 * 

	 * @param data

	 *            decoding parameters

	 */

	public void setDecodingData(DecodingData data) {

		decodingData = data;

	}

	/**

	 * Returns a path where Crash Analyser plugin can do various tasks (located

	 * under workspace).

	 * 

	 * @return E.g.

	 *         C:\My_Workspace\.metadata\.plugins\com.nokia.s60tools.crashanalyser

	 *         \

	 */

	protected static String getPluginWorkingLocation() {

		IPath location = Platform.getStateLocation(CrashAnalyserPlugin

				.getDefault().getBundle());

		return location.toOSString();

	}

	/**

	 * Returns the folder under which crash file folders are located

	 * 

	 * @return E.g.

	 *         C:\My_Workspace\.metadata\.plugins\com.nokia.s60tools.crashanalyser

	 *         \CrashFiles

	 */

	public static String getCrashFilesFolder() {

		String crashFilesFolder = FileOperations

				.addSlashToEnd(getPluginWorkingLocation())

				+ CRASH_FILES_FOLDER;

		FileOperations.createFolder(crashFilesFolder);

		return crashFilesFolder;

	}

	/**

	 * Start the decoding process

	 * 

	 * @param observer

	 *            observer for the decoding process

	 */

	public void decode(IDecodingObserver observer) {

		decodingObserver = observer;

		setPriority(Job.SHORT);

		setUser(true);

		schedule();

	}

	/**

	 * Runs CrashAnalyser.exe for full analysis for (user) selected files. This

	 * also handles already decoded files (.crashxml) so that they are not given

	 * to CrashAnalyser.exe. Outcome of this method is that all decoded files

	 * are under given workingFolder.

	 * 

	 * @param workingFolder

	 *            where files are to be decoded

	 * @param monitor

	 *            for progress bar

	 */

	void importCrashFiles(String workingFolder, IProgressMonitor monitor) {

		if (crashFiles != null) {

			List<String> filesToBeDecoded = new ArrayList<String>();

			// go through all crash files

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

				CrashFileBundle crashFile = crashFiles.get(i);

				// we are importing already decoded file (.crashxml)

				if (crashFile.isFullyDecoded()) {

					CrashFile f = crashFile.getCrashFile();

					// this index was not chosen by user to be imported, delete

					// this .crash from working folder

					if (f != null && !decodingData.crashFileIndexes.contains(i)) {

						FileOperations.deleteFile(f.getFilePath());

					}

					// we are decoding a crash file

				} else {

					// this index was not chosen by user to be imported, skip

					// this crash file

					if (!decodingData.crashFileIndexes.contains(i))

						continue;

					SummaryFile f = crashFile.getSummaryFile();

					filesToBeDecoded.add(f.getSourceFilePath());

				}

			}

			if (!filesToBeDecoded.isEmpty()) {

				String mapFilesFolder = decodingData.mapFilesFolder;

				// if MapFiles.zip is provided

				if (mapFilesFolder != null && "".equals(mapFilesFolder)

						&& decodingData.mapFilesZip != null

						&& !"".equals(decodingData.mapFilesZip)) {

					String zipFolder = FileOperations

							.addSlashToEnd(workingFolder)

							+ FileOperations

									.addSlashToEnd(MAP_FILES_ZIP_FOLDER);

					FileOperations.createFolder(zipFolder, true);

					FileOperations.unZipFiles(

							new File(decodingData.mapFilesZip), zipFolder);

					mapFilesFolder = zipFolder;

				}

				CommandLineManager.executeFullAnalysis(workingFolder,

						filesToBeDecoded.toArray(new String[filesToBeDecoded

								.size()]), decodingData.symbolFiles,

						mapFilesFolder, decodingData.imageFiles,

						CrashAnalyserFile.OUTPUT_FILE_EXTENSION,

						ERROR_FILE_EXTENSION, getSelgeEventIniFile(), monitor);

			}

		}

	}

	/**

	 * Searches the crash file bundle for the given crashFile

	 * 

	 * @param crashFile

	 *            .xml or .crashxml file

	 * @return CrashFileBundle for given file if found, null if not found

	 */

	CrashFileBundle getCrashFileBundle(File crashFile) {

		if (crashFiles != null) {

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

				CrashFileBundle cfb = crashFiles.get(i);

				String fileName = "";

				SummaryFile sf = cfb.getSummaryFile();

				if (sf != null) {