/*

 * Copyright (c) 2008-2010 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:  Definitions for the class UseAtool

 *

 */

package com.nokia.s60tools.analyzetool.engine;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.AbstractList;

import java.util.ArrayList;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.QualifiedName;

import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;

import com.nokia.carbide.cdt.builder.builder.CarbideCPPBuilder;

import com.nokia.carbide.cdt.builder.builder.CarbideCommandLauncher;

import com.nokia.carbide.cdt.builder.project.ICarbideBuildConfiguration;

import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;

import com.nokia.s60tools.analyzetool.global.Constants;

import com.nokia.s60tools.analyzetool.global.Util;

/**

 * Class to use atool.exe. Atool.exe is usually used in command prompt so that's

 * why we executes atool commands with using CarbideCommandLauncher class.

 * @author kihe

 */

public class UseAtool {

	/**

	 */

	}

	/**

	 * Check data file type. Gets first line of file and compares that to

	 * predefined constants.

	 * @param path

	 */

	public static int checkFileType(final String path) {

		// return value

		int retValue = Constants.DATAFILE_INVALID;

		// check that file exists

		if (path == null || ("").equals(path)) {

			return retValue;

		}

		if (!file.exists()) {

			return retValue;

		}

			return Constants.DATAFILE_XML;

		}

		// input

		BufferedReader input = null;

		FileInputStream fileInputStream = null;

		InputStreamReader inputReader = null;

		try {

			// get input

			fileInputStream = new FileInputStream(path);

				fileInputStream.close();

				return Constants.DATAFILE_EMPTY;

			}

			// file not empty read file contents

			inputReader = new InputStreamReader(fileInputStream, "UTF-8");

			input = new BufferedReader(inputReader);

					}

				}

			}

			input.close();

			inputReader.close();

			fileInputStream.close();

		} catch (FileNotFoundException ex) {

			ex.printStackTrace();

		} catch (IOException ex) {

			ex.printStackTrace();

		} finally {

			try {

				if (input != null) {

					input.close();

				}

			} catch (IOException ex) {

				ex.printStackTrace();

			}

			try {

				if (inputReader != null) {

					inputReader.close();

				}

			} catch (IOException ex) {

				ex.printStackTrace();

			}

			try {

				if (fileInputStream != null) {

					fileInputStream.close();

				}

			} catch (IOException ex) {

				ex.printStackTrace();

			}

		}

		return retValue;

	}

	/**

	 * Creates atool_temp folder to current mmp folder location.

	 * @param folderLocation

	 *            Current mmp folder location

	 * @return True if given location contains atool_temp folder otherwise false

	 */

	public static boolean createAToolFolderIfNeeded(final String folderLocation) {

		boolean returnValue = false;

		// check if folder location contains atool_temp folder

		if (folderLocation.indexOf(Constants.ATOOL_TEMP) != -1) {

			returnValue = true;

		}

		// create atool_temp folder

			File file = new File(folderLocation + "\\" + Constants.ATOOL_TEMP);

			if (!file.exists()) {

				returnValue = file.mkdir();

			}

		}

		return returnValue;

	}

	/**

	 * Constructor.

	 */

	public UseAtool() {

		// ConstructorDeclaration[@Private='false'][count(BlockStatement) = 0

		// and ($ignoreExplicitConstructorInvocation = 'true' or

		// not(ExplicitConstructorInvocation)) and @containsComment = 'false']

	}

	/**

	 * @param monitor

	 *            IProgressMonitor reference

	 * @param project

	 *            Project reference

	 * @param dataFilePath

	 *            Trace file location

	 * @param command

	 *            Command which is used to execute atool.exe

	 * @return XML file name and path if file was successfully created otherwise

	 *         null

	 */

		int fileType = 0;

		// get file type

		fileType = checkFileType(dataFilePath);

		if (fileType == Constants.DATAFILE_INVALID) {

			return Constants.COMMAND_LINE_ERROR_CODE.DATA_FILE_INVALID;

			return Constants.COMMAND_LINE_ERROR_CODE.DATA_FILE_EMPTY;

		}

			return Constants.COMMAND_LINE_ERROR_CODE.EXECUTE_ERROR;

		}

		ICarbideProjectInfo cpi = CarbideBuilderPlugin.getBuildManager()

				.getProjectInfo(project);

		// if ICarbideProjectInfo not found return null

			return Constants.COMMAND_LINE_ERROR_CODE.UNKNOWN_ERROR;

		}

		String absolutePath = cpi.getAbsoluteBldInfPath().toOSString();

		String bldInfFolder = null;

		int index = Util.getLastSlashIndex(absolutePath);

		if (index != -1) {

			bldInfFolder = absolutePath.substring(0, index);

		}

			createAToolFolderIfNeeded(bldInfFolder);

		}

		AbstractList<String> usedArguments = new ArrayList<String>();

		usedArguments.add(command);

		usedArguments.add(dataFilePath);

		try {

			String useRomText = project.getPersistentProperty(useRom);

						String[] split = symbolFileLocation.split(";");

									usedArguments.add("-s");

									usedArguments.add(split[i]);

								}

							}

						}

					}

				}

			}

			ce.printStackTrace();

		}

		usedArguments.add(bldInfFolder + "\\" + Constants.ATOOL_TEMP + "\\"

				+ Constants.FILENAME_CARBIDE);

		if (Util.verboseAtoolOutput()) {

			usedArguments.add(Constants.ATOOL_SHOW_DEBUG);

		}

		// if some error happens

			return error;

		}

	}

	/**

	 * Executes given command, uses CarbideCommandLauncher class for execution.

	 * @param args

	 *            Command argument list

	 * @param path

	 *            Where to run command

	 * @param monitor

	 *            Monitor

	 * @param project

	 *            Project

	 * @return Return value of executeCommand method

	 */

	public final int executeCommand(final String[] args, final String path,

			final IProgressMonitor monitor, final IProject project) {

		int error = Constants.DATAFILE_INVALID;

		try {

			// get project info

			ICarbideProjectInfo cpi = CarbideBuilderPlugin.getBuildManager()

					.getProjectInfo(project);

			if (cpi == null) {

				return Constants.DATAFILE_INVALID;

			}

			// get command launcher

			CarbideCommandLauncher cmdLauncher = new CarbideCommandLauncher(

					project, monitor, Constants.atoolParserIds, cpi

							.getINFWorkingDirectory());

			// start timing stats

			cmdLauncher.startTimingStats();

			// get default config

			ICarbideBuildConfiguration defaultConfig = cpi

					.getDefaultConfiguration();

			// show command on console view

			cmdLauncher.showCommand(true);

			// execute command

			error = cmdLauncher.executeCommand(new Path(Util

					.getAtoolInstallFolder()), args, CarbideCPPBuilder

					.getResolvedEnvVars(defaultConfig), new Path(path));

			cmdLauncher.writeToConsole(cmdLauncher.getTimingStats());

		} catch (OutOfMemoryError oome) {

			oome.printStackTrace();

		}

		return error;

	}

}