/*

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

 *

 */

package com.nokia.s60tools.analyzetool.builder;

import java.util.AbstractList;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Status;

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

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.ui.PlatformUI;

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.carbide.cdt.builder.BuildArgumentsInfo;

import com.nokia.s60tools.analyzetool.Activator;

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

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

import com.nokia.s60tools.analyzetool.ui.CustomInputDialog;

/**

 * Base class for AnalyzeTool builders.

 *

 * This class modifies Carbide builder settings during the AnalyzeTool build.

 * This class can be used to built whole project or selected components with

 * AnalyzeTool

 *

 * @author kihe

 *

 */

public class AnalyzeToolBuilder extends CarbideCPPBuilder {

	/** Pre-builder id. */

	public static final String AT_BUILDER_ID = "com.nokia.s60tools.analyzetool.analyzeToolPreBuilder";

	/** CarbideCommandLauncher reference. */

	protected static CarbideCommandLauncher cmdLauncher = null;

	/** Used mmp files. */

	protected List<String> mmpFiles;

	/** Verbose atool.exe output? */

	private boolean verbose;

	/**

	 * Gets shared instance of CarbideCommandLauncher.

	 *

	 * @return CarbideCommandLauncher reference

	 */

	protected static CarbideCommandLauncher getCarbideCommandLauncher() {

		return cmdLauncher;

	}

	/**

	 * Checks is SBS v2 build activated for the project.

	 *

	 * @param cpi

	 *            ICarbideProjectInfo

	 * @return True if SBS v2 build is activated otherwise False

	 */

	public static boolean isSBSBuildActivated(final ICarbideProjectInfo cpi) {

		try {

			final Class<?> buildManagerClass = Class

					.forName("com.nokia.carbide.cdt.builder.ICarbideBuildManager");

			java.lang.reflect.Method[] methods = buildManagerClass.getMethods();

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

				java.lang.reflect.Method oneMethod = methods[i];

				if (oneMethod.toString().contains("isCarbideSBSv2Project")) {

					IProject project = cpi.getProject();

					if (project == null) {

						return false;

					}

					Object[] objs = new Object[1];

					objs[0] = project;

					Boolean obj = (Boolean) oneMethod.invoke(

							CarbideBuilderPlugin.getBuildManager(), objs);

					return obj.booleanValue();

				}

			}

		} catch (ClassNotFoundException cnfe) {

			cnfe.printStackTrace();

			return false;

		} catch (SecurityException se) {

			se.printStackTrace();

			return false;

		} catch (IllegalAccessException iae) {

			iae.printStackTrace();

			return false;

		} catch (IllegalArgumentException iare) {

			iare.printStackTrace();

			return false;

		} catch (java.lang.reflect.InvocationTargetException ite) {

			ite.printStackTrace();

			return false;

		}

		return false;

	}

	/**

	 * Ask data file name from the user and after that executes atool.exe.

	 *

	 * @param monitor

	 *            {@link IProgressMonitor} reference

	 * @param cpi

	 *            {@link ICarbideProjectInfo} reference

	 * @param files

	 *            Used mmp files

	 *

	 * @return COMMAND_LINE_ERROR_CODE.OK if no errors, otherwise error code

	 */

	private int askFileNameAndBuild(final IProgressMonitor monitor,

			final ICarbideProjectInfo cpi, final List<IFile> files) {

		// ask for the user data file name

		CustomInputDialog dialog = new CustomInputDialog(

				Constants.ANALYZE_TOOL_TITLE,

				Constants.DIALOG_INPUT_DATA_FILE_NAME, "");

		dialog.open();

		//get data file name

		String dataFileName = dialog.getUserInput();

		int errorCode = Constants.COMMAND_LINE_ERROR_CODE.OK.getCode();

		// user press "Cancel"

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

			buildCancelled(monitor, true);

		} else { // if user specify data file name

			errorCode = executeAtool(dataFileName, Constants.ATOOL_INST,

					Constants.LOGGING_S60, files, cpi, monitor);

		}

		return errorCode;

	}

	/**

	 * Ask logging mode from the user.

	 *

	 * @return User selected logging mode

	 */

	private String askLoggingMode() {

		IPreferenceStore store = Activator.getPreferences();

		// logging modes

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

		modes.add(Constants.PREFS_EXT);

		// if fast data gathering mode is enabled => add to selection list

		if( store.getBoolean(Constants.LOGGING_FAST_ENABLED ) ) {

			modes.add(Constants.PREFS_EXT_FAST);

		}

		modes.add(Constants.PREFS_S60);

		// open selection dialog

		String userSelection = Util.openSelectionDialog(

				Constants.DIALOG_SELECT_LOGGING_MODE, null, modes);

		// get used logging mode for the atool.exe

		// user selected logging mode can not be used straight because it is

		// different in the UI and which atool.exe uses

		String modeSelection = "";

		if (userSelection == Constants.PREFS_EXT) {

			modeSelection = Constants.LOGGING_EXT;

		} else if (userSelection == Constants.PREFS_S60) {

			modeSelection = Constants.LOGGING_S60;

		} else if( userSelection == Constants.PREFS_EXT_FAST) {

			modeSelection = Constants.LOGGING_EXT_FAST;

		}

		return modeSelection;

	}

	/**

	 * Cancels AnalyzeTool build.

	 *

	 * @param monitor

	 *            Currently running progress monitor

	 * @param continueBuild

	 *            Stop the whole build chain (including Carbide other builders)

	 *            or not

	 */

	public final void buildCancelled(final IProgressMonitor monitor,

			final boolean continueBuild) {

		IPreferenceStore store = Activator.getPreferences();

		store.setValue(Constants.PREFS_BUILD_CANCELLED, true);

		// if user wants to continue build

		if (!continueBuild) {

			// write info to the Carbide console view

			getCarbideCommandLauncher().writeToConsole(

					Constants.BUILD_CANCELLED);

			// update monitor state

			monitor.setCanceled(true);

			monitor.done();

		}

		boolean promptMPPChange = store.getBoolean(Constants.PREFS_PROMPT_MMP);

		boolean manageDeps = store.getBoolean(Constants.PREFS_MANAGE_DEPS);

		boolean useConcBuild = store.getBoolean(Constants.PREFS_CONC_BUILD);

		// build canceled set project preference back to normal

		IPreferenceStore cStore = CarbideBuilderPlugin.getDefault()

				.getPreferenceStore();

		cStore

				.setValue(

						com.nokia.carbide.cdt.builder.BuilderPreferenceConstants.PREF_MMP_CHANGED_ACTION_PROMPT,

						promptMPPChange);

		cStore

				.setValue(

						com.nokia.carbide.cdt.builder.BuilderPreferenceConstants.PREF_MANAGE_DEPENDENCIES,

						manageDeps);

		cStore

				.setValue(

						com.nokia.carbide.cdt.builder.BuilderPreferenceConstants.PREF_USE_CONCURRENT_BUILDING,

						useConcBuild);

		// CarbideCPPBuilder to forgot build state

		super.forgetLastBuiltState();

	}

	/**

	 * Builds user selected components.

	 *

	 * Normally this method is called from the CompileSymbianComponent

	 *

	 * @param selectedFiles

	 *            User selected files

	 */

	public final void buildComponents(final List<IFile> selectedFiles) {

		// create new job

		Job buildJob = new Job(Constants.BUILD_AND_INSTRUMENT) {

			@Override

			protected IStatus run(final IProgressMonitor monitor) {

				try {

					// get project

					IProject lastProject = selectedFiles.get(0).getProject();

					// get CarbideProjectInfo

					ICarbideProjectInfo cpi = CarbideBuilderPlugin

							.getBuildManager().getProjectInfo(lastProject);

					// get command launcher

					cmdLauncher = new CarbideCommandLauncher(lastProject,

							monitor, Constants.atoolParserIds, cpi

									.getINFWorkingDirectory());

					cmdLauncher.showCommand(true);

					// run pre steps for the build

					if (!runPreSteps(cmdLauncher, monitor, cpi)) {

						return new Status(IStatus.ERROR, Constants.ANALYZE_TOOL_TITLE,

								IStatus.ERROR, Constants.CANCELLED, null);

					}

					// build selected components

					runBuild(Constants.ATOOL_INST, monitor, cpi, selectedFiles);

					// run post steps

					runPostSteps(cpi);

					//after the build is finished => open the console view

					Util.openConsoleView();

				} finally {

					monitor.done();

				}

				return new Status(IStatus.OK, Constants.ANALYZE_TOOL_TITLE,

						IStatus.OK, Constants.COMPLETE, null);

			}

		};

		buildJob.setPriority(Job.BUILD);

		buildJob.schedule();

	}

	/**

	 * Checks that platform is ARMV5, GCEE or WINSCW

	 *

	 * @param cpi

	 *            ICarbideProjectInfo

	 * @return True if platform is set to ARMV5, GCCE or WINSCW otherwise False

	 */

	public final boolean checkPlatform(final ICarbideProjectInfo cpi) {

		String platform = cpi.getDefaultConfiguration().getPlatformString();

		if ( platform.equals(Constants.BUILD_TARGET_ARMV5) || platform.equals(Constants.BUILD_TARGET_WINSCW)

				|| platform.equals(Constants.BUILD_TARGET_GCEE) ) {

			return true;

		}

		return false;

	}

	/**

	 * Executes atool.exe with options.

	 *

	 * @param dataFileName

	 *            Used data file name

	 * @param type

	 *            Type of execution. Possible types ATOOL_INST or ATOOL_UNINST

	 * @param loggingModeCommand

	 *            Used logging mode

	 * @param userSelectedMmpFiles

	 *            List of user selected mmp files

	 * @param cpi

	 *            ICarbideProjectInfo reference

	 * @param monitor

	 *            Progress monitor reference

	 *

	 * @return COMMAND_LINE_ERROR_CODE.OK if no errors, otherwise error code

	 */

	protected final int executeAtool(final String dataFileName,

			final String type, final String loggingModeCommand,

			final List<IFile> userSelectedMmpFiles,

			final ICarbideProjectInfo cpi, final IProgressMonitor monitor) {

		// get used platform

		String platform = cpi.getDefaultConfiguration().getPlatformString().toLowerCase(Locale.US);

		// get build target

		String buildTarget = cpi.getDefaultConfiguration().getTargetString().toLowerCase(Locale.US);

		// used arguments to atool.exe

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

		// which logging mode is used

		if( loggingModeCommand.equalsIgnoreCase(Constants.LOGGING_EXT) )

		{

			usedArguments.add(Constants.ATOOL_INST_E);

		}

		else if( loggingModeCommand.equalsIgnoreCase(Constants.LOGGING_EXT_FAST)) {

			usedArguments.add(Constants.ATOOL_INST_EF);

		}

		else

		{

			usedArguments.add(Constants.ATOOL_INST_I);

		}

		// if data file is set

		if (dataFileName != null && !("").equals(dataFileName)) {

			usedArguments.add("-f");

			usedArguments.add(dataFileName);

		}

		// if "verbose atool.exe output" is enabled

		if (verbose) {

			usedArguments.add(Constants.ATOOL_SHOW_DEBUG);

		}

		IPreferenceStore store = Activator.getPreferences();

		if( store.getBoolean(Constants.USE_CALLSTACK_SIZE) ) {

			int callstackSize = store.getInt(Constants.CALLSTACK_SIZE);

			usedArguments.add(Constants.CALLSTACK_SIZE_OPTION);

			usedArguments.add(Integer.toString(callstackSize));

		}

		//add build command

		// if project using SBSv2 build system

		boolean sbsBuild = isSBSBuildActivated(cpi);

		if (sbsBuild) {

			usedArguments.add("sbs");

			usedArguments.add("-c");

			StringBuffer buildCommand = new StringBuffer();

			buildCommand.append(platform);

			buildCommand.append('_');

			buildCommand.append(buildTarget);

			usedArguments.add(buildCommand.toString());

		}

		else

		{

			usedArguments.add("abld");

			usedArguments.add("build");

			usedArguments.add(platform);

			usedArguments.add(buildTarget);

		}

		int errorCode = Constants.COMMAND_LINE_ERROR_CODE.OK.getCode();

		// if user has selected custom setup of components =>build them

		// this means that call is come from CompileSymbianComponent class

		if (userSelectedMmpFiles != null && !userSelectedMmpFiles.isEmpty()) {

			//get atool.exe command

			Iterator<IFile> files = userSelectedMmpFiles.iterator();

			while(files.hasNext()) {

				IFile file = files.next();

				IPath location = file.getLocation();

				String mmpFileName = getMMPFileName(location, true);

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

					continue;

				}

				// if this is first mmp file add it parameter list

				usedArguments.add("-p");

				usedArguments.add(mmpFileName);

			}

			//now the command is ready

			//execute command

			// execute atool.exe via CommandLauncher class

			cmdLauncher.showCommand(true);

			String[] arguments = new String[usedArguments.size()];

		    usedArguments.toArray(arguments);

		    errorCode = cmdLauncher.executeCommand(new Path(Util

					.getAtoolInstallFolder()), arguments,

					CarbideCPPBuilder.getResolvedEnvVars(cpi

							.getDefaultConfiguration()), cpi

							.getINFWorkingDirectory());

			// if user press "Cancel"

			if (monitor.isCanceled()) {

				buildCancelled(monitor, false);

				monitor.done();

			}

			// thru selected files and build with the Carbide builder

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

				// get one file

				IFile file = userSelectedMmpFiles.get(i);

				// get file location

				IPath fileLocation = file.getLocation();

				// invoke normal Carbide build

				try {

					CarbideCPPBuilder.invokeSymbianComponenetAction(cpi

							.getDefaultConfiguration(),

							CarbideCPPBuilder.BUILD_COMPONENT_ACTION,

							fileLocation, cmdLauncher, monitor, true);

				} catch (CoreException e) {

					e.printStackTrace();

				}

				// if user press "Cancel"

				if (monitor.isCanceled()) {

					buildCancelled(monitor, false);

					monitor.done();

				}

			}

			// Carbide build is finished

			// now remove AnalyzeTool made modifications

			// if project contains build erros => only uninstrument mmp

			// file

			if (CarbideCPPBuilder.projectHasBuildErrors(cpi

					.getProject())) {

				usedArguments.set(0, Constants.ATOOL_UNINST_FAILED);

			}

			// project succesfully build => uninstrumet project

			runUninstrument(Constants.ATOOL_UNINST, cpi, monitor);

		}

		// if build from bld.inf file

		else if (cpi.isBuildingFromInf()) {

			cmdLauncher.showCommand(true);

			String[] arguments = new String[usedArguments.size()];

		    usedArguments.toArray(arguments);

		    errorCode = cmdLauncher.executeCommand(new Path(Util.getAtoolInstallFolder()),

					arguments,

					CarbideCPPBuilder.getResolvedEnvVars(cpi

							.getDefaultConfiguration()), cpi

							.getINFWorkingDirectory());

			if (mmpFiles != null) {

				mmpFiles.clear();

			}

			// if user press "Cancel"

			if (monitor.isCanceled()) {

				buildCancelled(monitor, false);

				monitor.done();

			}

		} else { // instrument only defined components

			// get build components

			mmpFiles = cpi.getInfBuildComponents();

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

				usedArguments.add("-p");

				usedArguments.add(mmpFiles.get(i));

			}

			cmdLauncher.showCommand(true);

			String[] arguments = new String[usedArguments.size()];

		    usedArguments.toArray(arguments);

		    errorCode = cmdLauncher.executeCommand(new Path(Util

					.getAtoolInstallFolder()), arguments,

					CarbideCPPBuilder.getResolvedEnvVars(cpi

							.getDefaultConfiguration()), cpi

							.getINFWorkingDirectory());

			// if user press "Cancel"

			if (monitor.isCanceled()) {

				buildCancelled(monitor, false);

				monitor.done();

			}

		}

		return errorCode;

	}