/*

* 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 com.nokia.carbide.cdt.builder.builder.CarbideCPPBuilder;

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

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

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.SymbianBuildContext;

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

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

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 new Path(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());

		for (final ISymbianBuildContext context : buildConfigs) {

			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();

		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());

		for (final ISymbianBuildContext context : buildConfigs) {

			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());

								normalFiles.add(extensionMakefileBase.addFileExtension("mk")); //$NON-NLS-1$

							}

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

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

								testFiles.add(extensionMakefileBase.addFileExtension("mk")); //$NON-NLS-1$

							}

							return null;

						}

				});

			monitor.worked(1);

		}

		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());

		for (final ISymbianBuildContext context : buildConfigs) {

			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);

		}

		monitor.done();

		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());

		for (final ISymbianBuildContext context : buildConfigs) {

			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);

		}

		monitor.done();

		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;

				if (defaultContext.getSDK().getPrefixFile() != 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;

		IPath requiredRoot = null;

		if (requiredPaths.size() > 0) {

			// requiredPaths contains a list of required paths

			// (for MMPs).  Take the shortest common source path of all.

			CommonPathFinder finder = new CommonPathFinder();

			for (IPath path : requiredPaths) {

				finder.addDirectory(path);

			}

			requiredRoot = finder.getCommonPath();

			root = requiredRoot;

		}

		if (desiredPaths.size() > 0) {

			// desiredPaths contains a list of source paths.  

			// Take the shortest common source path of all.

			CommonPathFinder finder = new CommonPathFinder();

			finder.addDirectory(root);

			for (IPath path : desiredPaths) {

				// boog 9221, bad root can be chosen for non-existent sourcepaths in MMPs

				// so ingore those

				if (path.toFile().exists()){

					finder.addDirectory(path);

				} 

			}

			desiredRoot = finder.getCommonPath();

			root = finder.getCommonPath();

		}

		if (optionalPaths.size() > 0) {

			// optionalPaths contains a list of source and include paths.

			// Take the shortest common source path of all.

			CommonPathFinder finder = new CommonPathFinder();

			finder.addDirectory(root);

			for (IPath path : optionalPaths) {

				// boog 9221, bad root can be chosen for non-existent sourcepaths in MMPs

				// so ingore those

				if (path.toFile().exists()){

					finder.addDirectory(path);

				} 

			}

			root = finder.getCommonPath();

		}

		if (root != null) {

			// Ensure the root is sane

			if (root.segmentCount() == 0 && desiredRoot != null && desiredRoot.segmentCount() > 0) {

				CarbideBuilderPlugin.log(Logging.newStatus(CarbideBuilderPlugin.getDefault(), 

						IStatus.WARNING,

						"Project appears to reference the drive's root directory or another drive (" + root + "); reverting to desired root: " + desiredRoot));

				root = desiredRoot;

			}

			if (root.segmentCount() == 0 && requiredRoot != null && requiredRoot.segmentCount() > 0) {

				CarbideBuilderPlugin.log(Logging.newStatus(CarbideBuilderPlugin.getDefault(), 

						IStatus.WARNING,

						"Project appears to reference the drive's root directory or another drive (" + root + "); reverting to required root: " + requiredRoot));

				root = requiredRoot;

			}

		}

		if (root == null) {

			// try something else

			root = bldInfFilePath.removeLastSegments(1);

	        if (root.segmentCount() > 0 && root.lastSegment().compareToIgnoreCase("group") == 0) { //$NON-NLS-1$

	        	root = root.removeLastSegments(1);

	        }

		}

		List<IPath> pathsToReturn = new ArrayList<IPath>();

		pathsToReturn.add(root);

		pathsToReturn.add(requiredRoot);

		pathsToReturn.add(desiredRoot);

		return pathsToReturn;

	}

	/**

	 * Get the paths referenced from MMP

	 * @param optionalPaths the paths referenced, excluding those for sources and resources

	 * @param desiredPaths the paths referenced for sources and resources

	 */

	private static void getMMPPathReferences(IPath bldInfFilePath,

			ISymbianBuildContext defaultContext,

			final IPath mmpPath, 

			final Set<IPath> optionalPaths, final Set<IPath> desiredPaths) throws CoreException {

		EpocEnginePlugin.runWithMMPData(mmpPath, 

				new DefaultMMPViewConfiguration(defaultContext, bldInfFilePath, new AllNodesViewFilter()), 

				new MMPDataRunnableAdapter() {

				public Object run(IMMPData mmpData) {

					// no EPOCROOT here, since we want to weed out these paths

					MMPViewPathHelper helper = new MMPViewPathHelper(mmpData, null);

					// this covers sources, resource lists, and documents

					IPath[] sourcePaths = mmpData.getEffectiveSourcePaths();

					for (IPath path : sourcePaths) {

						IPath fullPath = helper.convertMMPToFilesystem(

								EMMPPathContext.SOURCEPATH, path);

						if (fullPath != null)

							desiredPaths.add(fullPath);

					}

					List<IPath> includePaths = mmpData.getUserIncludes();

					for (IPath includePath : includePaths) {

						IPath fullPath = helper.convertMMPToFilesystem(

								EMMPPathContext.USERINCLUDE, includePath);

						if (fullPath != null)

							optionalPaths.add(fullPath);

					}

					includePaths = mmpData.getSystemIncludes();

					for (IPath includePath : includePaths) {

						IPath fullPath = helper.convertMMPToFilesystem(

								EMMPPathContext.SYSTEMINCLUDE, includePath);

						if (fullPath != null)

							optionalPaths.add(fullPath);

					}

					List<IMMPResource> resources = mmpData.getResourceBlocks();

					for (IMMPResource resource : resources) {