/*

* 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 the License "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.carbide.cdt.builder;

import java.io.File;

import java.io.FilenameFilter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import org.eclipse.cdt.core.CCorePlugin;

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.preferences.IEclipsePreferences;

import org.eclipse.core.runtime.preferences.InstanceScope;

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

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

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

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

import com.nokia.carbide.cpp.epoc.engine.BldInfDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.BldInfViewRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.EpocEnginePlugin;

import com.nokia.carbide.cpp.epoc.engine.ImageMakefileDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.MMPDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.MMPViewRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.PKGViewRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.image.IBitmapSource;

import com.nokia.carbide.cpp.epoc.engine.image.IImageSource;

import com.nokia.carbide.cpp.epoc.engine.image.IMultiImageSource;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IBldInfData;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IBldInfView;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IExport;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IExtension;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMMPReference;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMakMakeReference;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMakefileReference;

import com.nokia.carbide.cpp.epoc.engine.model.makefile.image.IImageMakefileData;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.EMMPLanguage;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.EMMPStatement;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPAIFInfo;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPBitmap;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPData;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPResource;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPView;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPViewConfiguration;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.AcceptedNodesViewFilter;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.AllNodesViewFilter;

import com.nokia.carbide.cpp.internal.api.sdk.BuildContextSBSv1;

import com.nokia.carbide.cpp.internal.api.sdk.ISBSv1BuildContext;

import com.nokia.carbide.cpp.internal.api.sdk.ISBSv1BuildInfo;

import com.nokia.carbide.cpp.internal.api.sdk.ISBSv2BuildContext;

import com.nokia.carbide.cpp.internal.api.sdk.SymbianBuildContextDataCache;

import com.nokia.carbide.cpp.sdk.core.ISymbianBuildContext;

import com.nokia.carbide.cpp.sdk.core.ISymbianBuilderID;

import com.nokia.carbide.cpp.sdk.core.ISymbianSDK;

import com.nokia.carbide.internal.api.cpp.epoc.engine.model.pkg.EPKGLanguage;

import com.nokia.carbide.internal.api.cpp.epoc.engine.model.pkg.IPKGEmbeddedSISFile;

import com.nokia.carbide.internal.api.cpp.epoc.engine.model.pkg.IPKGInstallFile;

import com.nokia.carbide.internal.api.cpp.epoc.engine.model.pkg.IPKGView;

import com.nokia.carbide.internal.api.cpp.epoc.engine.model.pkg.PKGModelHelper;

import com.nokia.cpp.internal.api.utils.core.CommonPathFinder;

import com.nokia.cpp.internal.api.utils.core.FileUtils;

import com.nokia.cpp.internal.api.utils.core.Logging;

import com.nokia.cpp.internal.api.utils.core.PathUtils;

import com.nokia.cpp.internal.api.utils.core.TextUtils;

public class EpocEngineHelper {

	/**

	 * Get the file system path to a project-relative path.  Uses the view's

	 * parser configuration to resolve the project location, thus can

	 * work even in views created outside the workspace.  This tries to correct

	 * any case discrepancies between the file system and the model.

	 * <p>

	 * <b>Don't use this for MMP IPath resolution -- use 

	 * {@link MMPViewPathHelper} instead!</b>

	 * @param data

	 * @param relativePath

	 * @return path, never null

	 */

	private static IPath getFullPath(IBldInfData data, IPath relativePath) {

		String absolutePath = data.getProjectPath().addTrailingSeparator().append(relativePath).toOSString();

		try {

			absolutePath = new File(absolutePath).getCanonicalPath();

		} catch (IOException e) {

		}

		return PathUtils.createPath(absolutePath);

	}

	/**

	 * Return list of filesystem paths to all MMPs and makefiles referenced by the given

	 * bld.inf full path.  This function differentiates between PRJ_TESTMMPFILES and PRJ_MMPFILES.

	 * Note that this does not include PRJ_EXTENSIONS or PRJ_TESTEXTENSIONS as they are a special

	 * case.  See {@link #getExtensions(IPath, List, List, List, IProgressMonitor)}.

	 * @param bldInfFilePath - The IPath to the bld.inf file that is to be preprocessed.

	 * @param buildConfigs - List of build configuration to parse for.

	 * @param normalMakMakePaths - The list of PRJ_MMPFILES IPath objects for the bld.inf

	 * @param testMakMakePaths - The list of PRJ_TESTMMPFILES IPath objects for the bld.inf.  Those

	 * with the "ignore" attribute are not returned.

	 * @param monitor

	 */

	public static void getMakMakeFiles(final IPath bldInfFilePath, List<ISymbianBuildContext> buildConfigs, 

		List<IPath> normalMakMakePaths, List<IPath> testMakMakePaths, IProgressMonitor monitor) {

		// get a bld.inf view for each build target.  take the union of all mmp and make files for each view

		// of the bld.inf file.

		final Set<IPath> normalFiles = new LinkedHashSet<IPath>();

		final Set<IPath> testFiles = new LinkedHashSet<IPath>();

		monitor.beginTask("Scanning bld.inf for mmp and make files", buildConfigs.size());

		try {

			// let cache know we're iterating a lot

			SymbianBuildContextDataCache.startProjectOperation();

			for (final ISymbianBuildContext context : buildConfigs) {

				if (monitor.isCanceled())

					break;

				EpocEnginePlugin.runWithBldInfData(bldInfFilePath, 

						new DefaultViewConfiguration(context, bldInfFilePath, new AcceptedNodesViewFilter()), 

						new BldInfDataRunnableAdapter() {

							public Object run(IBldInfData data) {

								for (IMakMakeReference ref : data.getMakMakeReferences()) {

									normalFiles.add(getFullPath(data, ref.getPath()));

								}

								for (IMakMakeReference ref : data.getTestMakMakeReferences()) {

									boolean ignore = false;

									for (String att : ref.getAttributes()) {

										if (att.equalsIgnoreCase("ignore")) { //$NON-NLS-1$

											ignore = true;

											break;

										}

									}

									if (!ignore) {

										testFiles.add(getFullPath(data, ref.getPath()));

									}

								}

								return null;

							}

					});

				monitor.worked(1);

			}

			monitor.done();

		} finally {

			SymbianBuildContextDataCache.endProjectOperation();

		}

		for (IPath normalPath : normalFiles){

			normalMakMakePaths.add(normalPath);

		}

		for (IPath testPath : testFiles){

			testMakMakePaths.add(testPath);

		}

	}

	/**

	 * Return list of file system paths to all project extensions referenced by the given

	 * bld.inf full path.  This function differentiates between PRJ_EXTENSIONS and PRJ_TESTEXTENSIONS

	 * @param bldInfFilePath - The IPath to the bld.inf file that is to be preprocessed.

	 * @param buildConfigs - List of build configuration to parse for.

	 * @param normalExtensionPaths - The list of PRJ_EXTENSIONS IPath objects for the bld.inf

	 * @param testExtensionPaths - The list of PRJ_TESTEXTENSIONS IPath objects for the bld.inf

	 * @param monitor

	 */

	public static void getExtensions(final IPath bldInfFilePath, List<ISymbianBuildContext> buildConfigs, 

		List<IPath> normalExtensionPaths, List<IPath> testExtensionPaths, IProgressMonitor monitor) {

		// get a bld.inf view for each build target.  take the union of all extensions for each view

		// of the bld.inf file.

		final Set<IPath> normalFiles = new LinkedHashSet<IPath>();

		final Set<IPath> testFiles = new LinkedHashSet<IPath>();

		monitor.beginTask("Scanning bld.inf project extensions", buildConfigs.size());

		try {

			// let cache know we're iterating a lot

			SymbianBuildContextDataCache.startProjectOperation();

			for (final ISymbianBuildContext context : buildConfigs) {

				if (monitor.isCanceled())

					break;

				EpocEnginePlugin.runWithBldInfData(bldInfFilePath, 

						new DefaultViewConfiguration(context, bldInfFilePath, new AcceptedNodesViewFilter()), 

						new BldInfDataRunnableAdapter() {

							public Object run(IBldInfData data) {

								BldInfViewPathHelper helper = new BldInfViewPathHelper(data, context);

								for (IExtension extension : data.getExtensions()) {

									IPath extensionMakefileBase = helper.convertExtensionTemplateToFilesystem(extension.getTemplatePath());

									IPath makefile = getControllingFile(extensionMakefileBase);

									normalFiles.add(makefile);

								}

								for (IExtension extension : data.getTestExtensions()) {

									IPath extensionMakefileBase = helper.convertExtensionTemplateToFilesystem(extension.getTemplatePath());

									IPath makefile = getControllingFile(extensionMakefileBase);

									testFiles.add(makefile);

								}

								return null;

							}

							private IPath getControllingFile(

									IPath extensionMakefileBase) {

								IPath candidate = extensionMakefileBase.addFileExtension("mk"); //$NON-NLS-1$

								if (candidate.toFile().exists())

									return candidate;

								if ("export".equals(extensionMakefileBase.getFileExtension())) //$NON-NLS-1$

									candidate = extensionMakefileBase.removeFileExtension().addFileExtension("flm"); //$NON-NLS-1$

								else

									candidate = extensionMakefileBase.addFileExtension("flm"); //$NON-NLS-1$

								return candidate;

							}

					});

				monitor.worked(1);

			}

		} finally {

			SymbianBuildContextDataCache.endProjectOperation();

			monitor.done();

		}

		for (IPath normalPath : normalFiles){

			normalExtensionPaths.add(normalPath);

		}

		for (IPath testPath : testFiles){

			testExtensionPaths.add(testPath);

		}

	}

	/**

	 * Return list of all named project extensions referenced by the given

	 * bld.inf full path.  This function differentiates between PRJ_EXTENSIONS and PRJ_TESTEXTENSIONS

	 * @param bldInfFilePath - The IPath to the bld.inf file that is to be preprocessed.

	 * @param buildConfigs - List of build configuration to parse for.

	 * @param normalExtensions - The list of named PRJ_EXTENSIONS for the bld.inf

	 * @param testExtensions - The list of named PRJ_TESTEXTENSIONS for the bld.inf

	 * @param monitor

	 */

	public static void getNamedExtensions(final IPath bldInfFilePath, List<ISymbianBuildContext> buildConfigs, 

		List<IExtension> normalExtensions, List<IExtension> testExtensions, IProgressMonitor monitor) {

		// get a bld.inf view for each build target.  take the union of all extensions for each view

		// of the bld.inf file.

		final Set<IExtension> normalFiles = new LinkedHashSet<IExtension>();

		final Set<IExtension> testFiles = new LinkedHashSet<IExtension>();

		monitor.beginTask("Scanning bld.inf project extensions", buildConfigs.size());

		try {

			// let cache know we're iterating a lot

			SymbianBuildContextDataCache.startProjectOperation();

			for (final ISymbianBuildContext context : buildConfigs) {

				if (monitor.isCanceled())

					break;

				EpocEnginePlugin.runWithBldInfData(bldInfFilePath, 

						new DefaultViewConfiguration(context, bldInfFilePath, new AcceptedNodesViewFilter()), 

						new BldInfDataRunnableAdapter() {

							public Object run(IBldInfData data) {

								for (IExtension extension : data.getExtensions()) {

									if (extension.getName() != null) {

										normalFiles.add(extension);

									}

								}

								for (IExtension extension : data.getTestExtensions()) {

									if (extension.getName() != null) {

										testFiles.add(extension);

									}

								}

								return null;

							}

					});

				monitor.worked(1);

			}

		} finally {		

			monitor.done();

			SymbianBuildContextDataCache.endProjectOperation();

		}

		for (IExtension normal : normalFiles){

			normalExtensions.add(normal);

		}

		for (IExtension test : testFiles){

			testExtensions.add(test);

		}

	}

	/**

	 * Determines if the given bld.inf file contains any unnamed project extensions

	 * @param bldInfFilePath - The IPath to the bld.inf file that is to be preprocessed.

	 * @param buildConfigs - List of build configuration to parse for.

	 * @param monitor

	 * @return

	 */

	public static boolean hasUnnamedExtensions(final IPath bldInfFilePath, List<ISymbianBuildContext> buildConfigs, IProgressMonitor monitor) {

		final Set<IExtension> extensions = new LinkedHashSet<IExtension>();

		monitor.beginTask("Scanning bld.inf project extensions", buildConfigs.size());

		try {

			// let cache know we're iterating a lot

			SymbianBuildContextDataCache.startProjectOperation();

			for (final ISymbianBuildContext context : buildConfigs) {

				if (monitor.isCanceled())

					break;

				EpocEnginePlugin.runWithBldInfData(bldInfFilePath, 

						new DefaultViewConfiguration(context, bldInfFilePath, new AcceptedNodesViewFilter()), 

						new BldInfDataRunnableAdapter() {

							public Object run(IBldInfData data) {

								for (IExtension extension : data.getExtensions()) {

									if (extension.getName() == null) {

										extensions.add(extension);

									}

								}

								for (IExtension extension : data.getTestExtensions()) {

									if (extension.getName() == null) {

										extensions.add(extension);

									}

								}

								return null;

							}

					});

				monitor.worked(1);

			}

		} finally {		

			monitor.done();

			SymbianBuildContextDataCache.endProjectOperation();

		}

		return extensions.size() > 0;

	}

	/**

	 * Returns two paths in a list - the first is the suggested root directory

	 * for the project.  This is calculated by taking the shortest common path

	 * containing the bld.inf, mmp and make files, exports, source, resource, and include paths.

	 * <p>

	 * The second path is the "minimum" root directory for the project.  This is

	 * the shortest common source path containing the bld.inf, mmp and make files.

	 * <p>

	 * The third path is the "desired" root directory for the project.  This is 

	 * the shortest common source path containing the bld.inf, mmp and make files,

	 * and the sources and resources.  (added as of 1.3)

	 * @param bldInfFilePath full path to bld.inf

	 * @param contexts the list of selected SDKs

	 * @param monitor the progress monitor for this operation

	 * @return list of exactly 3 IPaths

	 */

	public static List<IPath> getProjectRoots(final IPath bldInfFilePath, List<ISymbianBuildContext> contexts, final IProgressMonitor monitor) {

		// Get the "all" view of the bld.inf/mmp files.  We want to find the true

		// project root here.  It may be more narrow

		// for the selected set of build configs, but if they later add other

		// build configs then those files may not be

		// under the project root.  Find the shortest common path from the

		// bld.inf, mmp files, sourcepaths, user includes,

		// resources, bitmaps, etc. and use that as the project root.

		// We track the required paths -- to find the MMPs and makefiles --

		// the desired paths -- to find sources and resources --

		// and the optional paths -- sources and includes.  The optional paths

		// may diverge to something crazy like the drive root if an include

		// or source path is on a different drive or is an absolute path,

		// so revert to the desired paths in that case.  If those path still

		// diverge, revert to the required root.

		final Set<IPath> requiredPaths = new LinkedHashSet<IPath>();

		final Set<IPath> optionalPaths = new LinkedHashSet<IPath>();

		final Set<IPath> desiredPaths = new LinkedHashSet<IPath>();

		// Get a default SDK for use in resolving SDK-relative #includes

		// (e.g. for *.mmh or *.h files).  Try to get one whose directory exists

		// and which has a variant.mmh file, to cover the greediest import scenario.

		//

		// This doesn't affect the path calculation since SDK-relative paths are

		// filtered out by our use of MMPViewPathHelper,

		// but it avoids a lot of errors about missing #includes showing up in

		// the error log.

		ISymbianBuildContext defaultContext = null;

		for (ISymbianBuildContext context : contexts) {

			if (context.getSDK() != null 

					&& context.getSDK().getEPOCROOT() != null

					&& new File(context.getSDK().getEPOCROOT()).exists()) {

				defaultContext = context;

				ISymbianSDK sdk = defaultContext.getSDK();

				if (context instanceof ISBSv2BuildContext){

					if (sdk.getPrefixFile(ISymbianBuilderID.SBSV2_BUILDER) != null)

						break;

				} else {

					if (sdk.getPrefixFile(ISymbianBuilderID.SBSV1_BUILDER) != null)

						break;

				}

			}

		}

		final ISymbianBuildContext defaultContextToUse = defaultContext;

		requiredPaths.add(bldInfFilePath.removeLastSegments(1));

		EpocEnginePlugin.runWithBldInfData(bldInfFilePath, 

				new DefaultViewConfiguration(defaultContextToUse, bldInfFilePath, new AllNodesViewFilter()), 

				new BldInfDataRunnableAdapter() {

					public Object run(IBldInfData data) {

						IMMPReference[] refs = data.getAllMMPReferences();

						IMakefileReference[] makeRefs = data.getAllMakefileReferences();

						IExtension[] extensions = data.getAllExtensions();

						monitor.beginTask("Calculating root directory and default name for project", refs.length + makeRefs.length + extensions.length);

						try {

							for (IMMPReference ref : refs) {

								IPath path = ref.getPath();

								path = getFullPath(data, path);

								// add the path to the mmp file

								requiredPaths.add(path.removeLastSegments(1));

								getMMPPathReferences(bldInfFilePath, defaultContextToUse, path, optionalPaths, desiredPaths);

								monitor.worked(1);

							}

							for (IMakefileReference ref : makeRefs) {

								IPath path = ref.getPath();

								path = getFullPath(data, path);

								// add the Makefile's path

								requiredPaths.add(path.removeLastSegments(1));

								getMakefilePathReferences(bldInfFilePath, defaultContextToUse, path, optionalPaths);

								monitor.worked(1);

							}

							// note, all extension makefiles are in EPOCROOT,

							// so it's futile to force the project root to include them

							/*

							BldInfViewPathHelper helper = new BldInfViewPathHelper(view, defaultContextToUse);

							for (IExtension extension : extensions) {

								IPath path = extension.getTemplatePath();

								path = helper.convertExtensionTemplateToFilesystem(path);

								// add the extension's path, optionally, since it's in EPOCROOT

								optionalPaths.add(path.removeLastSegments(1));

								getMakefilePathReferences(bldInfFilePath, defaultContextToUse, path, optionalPaths, desiredPaths);

								monitor.worked(1);

							}

							*/

							monitor.worked(extensions.length);

							// check the export paths

							for (IExport export : data.getExports()) {

								IPath path = getFullPath(data, export.getSourcePath());

								optionalPaths.add(path.removeLastSegments(1));

								monitor.worked(1);

							}

							// check the test export paths

							for (IExport testExport : data.getTestExports()) {

								IPath path = getFullPath(data, testExport.getSourcePath());

								optionalPaths.add(path.removeLastSegments(1));

								monitor.worked(1);

							}

						} catch (CoreException e) {

							CarbideBuilderPlugin.log(e);

						} finally {

							monitor.done();

						}

						return null;

					}

			});

		IPath root = null;

		IPath desiredRoot = null;