/*

* Copyright (c) 2006-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.internal.cpp.epoc.engine.model.mmp;

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

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

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

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

import com.nokia.carbide.internal.api.cpp.epoc.engine.dom.*;

import com.nokia.carbide.internal.api.cpp.epoc.engine.dom.mmp.*;

import com.nokia.carbide.internal.cpp.epoc.engine.model.*;

import com.nokia.carbide.internal.cpp.epoc.engine.parser.ITranslationUnitParser;

import com.nokia.carbide.internal.cpp.epoc.engine.parser.mmp.IMMPParserConfiguration;

import com.nokia.carbide.internal.cpp.epoc.engine.preprocessor.IConditionalBlock;

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

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.Path;

import org.osgi.framework.Version;

import java.util.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

/**

 * View onto MMP contents.

 *

 */

public class MMPView extends ViewASTBase implements IMMPView {

	static final String SOURCE_INFO_PATTERN = "SOURCE|SOURCEPATH"; //$NON-NLS-1$

	static final String BITMAP_KEYWORD = "BITMAP"; //$NON-NLS-1$

	static final String RESOURCE_KEYWORD = "RESOURCE"; //$NON-NLS-1$

	private static final String DEF_FILE_EXTENSION = "def"; //$NON-NLS-1$

	private static final Pattern VERSION_PATTERN = Pattern.compile("(.*)\\{.*\\}"); //$NON-NLS-1$

	private List<IPath> sources;

	private List<IPath> documents;

	private List<IPath> userIncludes;

	private List<IPath> systemIncludes;

	private Map<EMMPStatement, List<String>> stringListArgumentSettings;

	private List<IMMPBitmap> bitmaps;

	private Set<EMMPStatement> flagSettings;

	private Map<EMMPStatement, String> singleArgumentSettings;

	private List<IMMPResource> resourceBlocks;

	private List<IMMPAIFInfo> aifs;

	private List<IPath> userResources;

	private List<IPath> systemResources;

	private List<EMMPLanguage> languages;

	private String uid2;

	private String uid3;

	private Map<String, String> options, linkerOptions, replaceOptions;

	IPath defFileBase;

	private List<IASTStatement> knownStatements;

	protected OrderedObjectMap<IMMPAIFInfo, IASTMMPAifStatement> aifToStatementMap;

	protected OrderedObjectMap<IMMPResource, IASTMMPStartBlockStatement> resourceBlockToStatementMap;

	protected OrderedObjectMap<IMMPBitmap, IASTMMPStartBlockStatement> bitmapBlockToStatementMap;

	/** read-only list for now */

	private Set<IPath> sourcePaths;

	public MMPView(ModelBase model, ITranslationUnitParser parser,

			IMMPViewConfiguration viewConfiguration) {

		super(model, parser, viewConfiguration);

		//System.out.println("Parsing view for " + model.getPath());

		stringListArgumentSettings = new LinkedHashMap<EMMPStatement, List<String>>();

		singleArgumentSettings = new LinkedHashMap<EMMPStatement, String>();

		flagSettings = new LinkedHashSet<EMMPStatement>();

		for (EMMPStatement stmt : EMMPStatement.values()) {

			if (((IMMPViewConfiguration) getViewConfiguration()).isStatementSupported(stmt)) {

				switch (stmt.getCategory()) {

				case IMMPParserConfiguration.LIST_ARGUMENT_STATEMENT:

					if (isStringListArgumentSettingStatement(stmt)) {

						stringListArgumentSettings.put(stmt, new ArrayList<String>());

					}

					break;

				case IMMPParserConfiguration.SINGLE_ARGUMENT_STATEMENT:

					if (isSingleArgumentSettingStatement(stmt)) {

						singleArgumentSettings.put(stmt, null);

					}

					break;

				}

			} 

		}

		knownStatements = new ArrayList<IASTStatement>();

		sources = new ArrayList<IPath>();

		documents = new ArrayList<IPath>();

		userIncludes = new ArrayList<IPath>();

		systemIncludes = new ArrayList<IPath>();

		userResources = new ArrayList<IPath>();

		systemResources = new ArrayList<IPath>();

		resourceBlocks = new ArrayList<IMMPResource>();

		languages = new ArrayList<EMMPLanguage>();

		bitmaps = new ArrayList<IMMPBitmap>();

		aifs = new ArrayList<IMMPAIFInfo>();

		options = new LinkedHashMap<String, String>();

		linkerOptions = new LinkedHashMap<String, String>();

		replaceOptions = new LinkedHashMap<String, String>();

		defFileBase = convertModelToProjectPath(new Path("")); // //$NON-NLS-1$

		sourcePaths = new LinkedHashSet<IPath>();

		aifToStatementMap = new OrderedObjectMap<IMMPAIFInfo, IASTMMPAifStatement>();

		resourceBlockToStatementMap = new OrderedObjectMap<IMMPResource, IASTMMPStartBlockStatement>();

		bitmapBlockToStatementMap = new OrderedObjectMap<IMMPBitmap, IASTMMPStartBlockStatement>();

	}

	IASTMMPTranslationUnit mmp() {

		return (IASTMMPTranslationUnit) getFilteredTranslationUnit();

	}

	/**

	 * Identify a path which should not be converted to be project-relative.

	 * This includes actual absolute paths and special EPOCROOT\epoc32

	 * paths, which look relative but start with "+".

	 * @param mmpPath

	 * @return

	 */

	static boolean isAbsoluteLikePath(IPath mmpPath) {

		return (isAbsolutePath(mmpPath)

				|| (mmpPath.segmentCount() > 0 && mmpPath.segment(0).equals("+")));  //$NON-NLS-1$

	}

	/**

	 * Convert an MMP-relative string filename to a project-relative path if possible.

	 * @param filename 

	 * @return

	 */

	IPath fromMmpToProjectPath(IPath mmpPath) {

		if (isAbsoluteLikePath(mmpPath))

			return mmpPath;

		IPath path = currentDirectory != null ? currentDirectory.append(mmpPath) : mmpPath;

		if (FileUtils.isPathInParent(path)) {

			path = getProjectPath().append(path);

		}

		return path;

	}

	/**

	 * Convert an MMP-relative string filename to a project-relative path if possible.

	 * @param filename 

	 * @return

	 */

	IPath fromMmpToProjectPath(String mmpPath) {

		return fromMmpToProjectPath(FileUtils.createPossiblyRelativePath(mmpPath));

	}

	/**

	 * Convert an MMP-relative string filename to a project-relative path

	 * if possible.

	 * @param mmpPath text node from MMP

	 * @return

	 */

	IPath fromMmpToProjectPath(IASTLiteralTextNode mmpPath) {

		return fromMmpToProjectPath(mmpPath.getValue());

	}

	/**

	 * Convert a project-relative IPath to an MMP-relative path and

	 * leave other paths alone. 

	 * @param projectPath 

	 * @return MMP-relative directory (never blank) or self if not project-relative 

	 */

	IPath fromProjectToMmpPath(IPath projectPath) {

		if (isAbsoluteLikePath(projectPath))

			return projectPath;

		IPath path = fromProjectToRelativePath(currentDirectory, projectPath);

		if (path.segmentCount() == 0)

			return new Path("."); //$NON-NLS-1$

		else

			return path;

	}

	/**

	 * Create an EMMPLanguage list from the given LANG statement.

	 * @param prevLang

	 * @return

	 */

	public List<EMMPLanguage> createLanguageList(IASTMMPListArgumentStatement stmt) {

		List<EMMPLanguage> list = new ArrayList<EMMPLanguage>();

		for (IASTLiteralTextNode node : stmt.getArguments()) {

			try {

				list.add(EMMPLanguage.fromCode(node.getValue()));

			} catch (IllegalArgumentException e) {

				// ignore unknown language

				EpocEnginePlugin.log(

						Logging.newStatus(EpocEnginePlugin.getDefault(), 

								new IllegalArgumentException(

										"Warning, ignoring unknown language code: " + node.getValue() + " in " + stmt)

				));

			}

		}

		return list;

	}

	/**

	 * Create a LANG statement with the given languages.

	 * @param list

	 * @return

	 */

	public IASTMMPListArgumentStatement createLanguageStatement(Collection<EMMPLanguage> list) {

		IASTListNode<IASTLiteralTextNode> languages = ASTMMPFactory.createLiteralTextNodeList();

		for (EMMPLanguage lang : list)

			languages.add(ASTMMPFactory.createPreprocessorLiteralTextNode(lang.getCodeString()));

		return ASTMMPFactory.createMMPListArgumentStatement(

				ASTMMPFactory.createPreprocessorLiteralTextNode(EMMPStatement.LANG.toString()), 

				languages);

	}

	/**

	 * Tell if the statement is a list argument statement that we store

	 * in lists (rather than in some other manner).

	 * @return

	 */

	public boolean isStringListArgumentSettingStatement(EMMPStatement stmt) {

		if (stmt.getCategory() != IMMPParserConfiguration.LIST_ARGUMENT_STATEMENT)

			return false;

		 return stmt != EMMPStatement.SOURCE

			&& stmt != EMMPStatement.USERINCLUDE && stmt != EMMPStatement.SYSTEMINCLUDE

			&& stmt != EMMPStatement.RESOURCE && stmt != EMMPStatement.SYSTEMRESOURCE

			&& stmt != EMMPStatement.LANG && stmt != EMMPStatement.DOCUMENT;

	}

	/**

	 * Tell if the statement is a single argument statement that we store

	 * in the single-argument settings (rather than in some other manner).

	 * @return true: yup

	 */

	public boolean isSingleArgumentSettingStatement(EMMPStatement stmt) {

		if (stmt.getCategory() != IMMPParserConfiguration.SINGLE_ARGUMENT_STATEMENT)

			return false;

		return stmt != EMMPStatement.SOURCEPATH;	

	}

	/**

	 * Tell if the statement is a flag statement that we store in the

	 * flag settings

	 */

	public boolean isFlagSettingStatement(EMMPStatement stmt) {

		return stmt.getCategory() == IMMPParserConfiguration.FLAG_STATEMENT;

	}

	/**

	 * Get the default project-relative directory for source files.

	 * @return project-relative path, maybe empty if at project

	 */

	IPath defaultProjectRelativeSourcePath() {

		return currentDirectory;

	}

	/**

	 * Return an appropriate path for a SOURCEPATH statement

	 * @param mmpSourceElement filename

	 * @return the directory of the filename, or "." if at root

	 */

	IPath getSourcePathFromSource(IPath mmpSourceElement) {

		return mmpSourceElement.segmentCount() > 1 ? mmpSourceElement.removeLastSegments(1)

				: new Path("."); //$NON-NLS-1$

	}

	static public boolean equalPath(IPath path, IPath path2) {

		if (path == null || path2 == null)

			return false;

		if (path.segmentCount() == 0 && path2.segmentCount() == 1 && path2.segment(0).equals(".")) { //$NON-NLS-1$

			return true;

		}

		if (path2.segmentCount() == 0 && path.segmentCount() == 1 && path.segment(0).equals(".")) { //$NON-NLS-1$

			return true;

		}

		//return path.toOSString().equalsIgnoreCase(path2.toOSString());

		// don't ignore capitalization, otherwise there's no way the client can use the API

		// to repair it

		return path.equals(path2);

	}

	/**

	 * Tell whether a statement can be "seen" at a global level.

	 * This means anything at the top level and anything inside a START PLATFORM block.

	 * Stuff from other blocks are local to that block and not globally visible.

	 * @param stmt

	 * @return true if statement is global

	 */

	boolean isGloballyVisibleStatement(IASTStatement stmt) {

		if (stmt.getParent() == mmp().getNodes())

			return true;

		// only handle nested statements in START PLATFORM.

		IASTNode parent = stmt;

		while ((parent = parent.getParent()) != null) {

			if (parent instanceof IASTMMPStartBlockStatement) {

				String blockType = ((IASTMMPStartBlockStatement) parent).getBlockType().getValue();

				if (blockType.equals(RESOURCE_KEYWORD) || blockType.equals(BITMAP_KEYWORD))

					return false;

				return isMacroDefined(blockType.toUpperCase());

			}

		}

		// what is this statement?

		Check.checkState(false);

		return false;

	}

	/* (non-Javadoc)

	 * @see com.nokia.carbide.internal.cpp.epoc.engine.model.ViewBase#internalRevertChanges()

	 */

	@Override

	protected void internalRevertChanges() {

		knownStatements.clear();

		aifToStatementMap.clear();

		bitmapBlockToStatementMap.clear();

		resourceBlockToStatementMap.clear();

		MMPStatementScanner scanner = new MMPStatementScanner(this);

		flagSettings.clear();

		singleArgumentSettings.clear();

		stringListArgumentSettings.clear();

		for (EMMPStatement stmt : EMMPStatement.values()) {

			if (((IMMPViewConfiguration) getViewConfiguration()).isStatementSupported(stmt)) {

				switch (stmt.getCategory()) {

				case IMMPParserConfiguration.LIST_ARGUMENT_STATEMENT:

					if (isStringListArgumentSettingStatement(stmt)) {

						stringListArgumentSettings.put(stmt, new ArrayList<String>());

					}

					break;

				case IMMPParserConfiguration.SINGLE_ARGUMENT_STATEMENT:

					if (isSingleArgumentSettingStatement(stmt)) {

						singleArgumentSettings.put(stmt, null);

					}

					break;

				}

			} 

		}		

		sources.clear();

		documents.clear();

		userIncludes.clear();

		systemIncludes.clear();

		bitmaps.clear();

		flagSettings.clear();

		resourceBlocks.clear();

		aifs.clear();

		userResources.clear();

		systemResources.clear();

		languages.clear();

		uid2 = null;

		uid3 = null;

		options.clear();

		linkerOptions.clear();

		replaceOptions.clear();

		defFileBase = convertModelToProjectPath(new Path("")); // //$NON-NLS-1$

		sourcePaths.clear();

		for (IASTTopLevelNode tln : mmp().getNodes()) {

			if (!(tln instanceof IASTMMPStatement))

				continue;

			IASTMMPStatement statement = (IASTMMPStatement) tln;

			scanner.scanStatement(statement);

			// record slash direction

			recordSlashInfo(statement.getOriginalText());

		}

		if (debug) {

			System.out.println("#internalRevertChanges() for " + getModel().getPath() + ":\n"+ //$NON-NLS-1$ //$NON-NLS-2$

					"Incoming filtered TU:\n"+ //$NON-NLS-1$

					getFilteredTranslationUnit().getNewText());

			dumpModelStructure();

		}

	}

	private void dumpModelStructure() {

		dumpCollection("Sources", sources); //$NON-NLS-1$

		dumpCollection("Documents", documents); //$NON-NLS-1$

		dumpCollection("User Includes", userIncludes); //$NON-NLS-1$

		dumpCollection("System Includes", userIncludes); //$NON-NLS-1$

		dumpCollection("Flags", flagSettings); //$NON-NLS-1$

		dumpCollection("Single Arguments", singleArgumentSettings); //$NON-NLS-1$

		dumpCollection("String Lists", stringListArgumentSettings); //$NON-NLS-1$

		dumpCollection("Bitmaps", bitmaps); //$NON-NLS-1$

		dumpCollection("Resource Blocks", resourceBlocks); //$NON-NLS-1$

		dumpCollection("User Resources", userResources); //$NON-NLS-1$

		dumpCollection("System Resources", systemResources); //$NON-NLS-1$

		dumpCollection("Languages", languages); //$NON-NLS-1$

		dumpCollection("AIFs", aifs); //$NON-NLS-1$

		dumpCollection("Options", options); //$NON-NLS-1$

		dumpCollection("Linker Options", linkerOptions); //$NON-NLS-1$

		dumpCollection("Replace Options", replaceOptions); //$NON-NLS-1$

		System.out.println("DEF file: " + getSingleArgumentSettings().get(EMMPStatement.DEFFILE) + " in " + defFileBase); //$NON-NLS-1$ //$NON-NLS-2$

		System.out.println("UID: " + uid2 + " " + uid3); //$NON-NLS-1$ //$NON-NLS-2$

		dumpCollection("SourcePaths", sourcePaths); //$NON-NLS-1$

	}

	private void dumpCollection(String string, Collection coll) {

		if (!coll.isEmpty()) {

			System.out.println(string + ":"); //$NON-NLS-1$

			for (Object obj : coll) {

				System.out.println("\t" + obj); //$NON-NLS-1$

			}

		}

	}

	private void dumpCollection(String string, Map map) {

		if (!map.isEmpty()) {

			System.out.println(string + ":"); //$NON-NLS-1$

			for (Map.Entry ent : (Set<Map.Entry>)map.entrySet()) {

				if (ent.getValue() != null && !(ent.getValue() instanceof Collection && ((Collection)ent.getValue()).isEmpty()))

					System.out.println("\t" + ent.getKey() + ": " + ent.getValue()); //$NON-NLS-1$ //$NON-NLS-2$

			}

		}

	}

	/* (non-Javadoc)

	 * @see com.nokia.carbide.internal.cpp.epoc.engine.model.mmp.MMPView#internalGatherChanges(java.util.List, java.util.List)

	 */

	@Override

	protected void internalGatherChanges(List modifications, List messages) {

		if (debug) {

			System.out.println("#internalGatherChanges for " + getModel().getPath() + ":\n"); //$NON-NLS-1$ //$NON-NLS-2$

			dumpModelStructure();

		}

		MMPStatementUpdater updater = new MMPStatementUpdater(this, modifications, messages);

		updater.update();

		if (debug) {

			System.out.println(

					"New filtered TU:\n"+ //$NON-NLS-1$

					getFilteredTranslationUnit().getNewText());

		}

	}

	private boolean statementUsesSourcePath(IASTMMPStatement statement) {

		if (statement.getKeywordName() == null)

			return false;

		if (statement.getKeywordName().matches("(?i)SOURCE|RESOURCE|SYSTEMRESOURCE|DOCUMENT")) {//$NON-NLS-1$

			return true;

		}

		if (statement instanceof IASTMMPStartBlockStatement) {

			return "RESOURCE".equalsIgnoreCase(((IASTMMPStartBlockStatement) statement).getBlockType().getValue()); //$NON-NLS-1$

		}

		return false;

	}

	private void deleteStatement(IASTNode node) {

		((IASTListHolder) node.getParent()).getList().remove(node);

	}

	/**

	 * Remove stray SOURCEPATH statements

	 *

	 */

	private void cleanupSourcePaths(IASTTranslationUnit tu) {

		IASTMMPStatement lastSourcePath = null;

		IConditionalBlock lastSourcePathBlock = null;

		boolean usedSourcePath = true;

		IASTTopLevelNode[] nodes = (IASTTopLevelNode[]) tu.getNodes().toArray(new IASTTopLevelNode[tu.getNodes().size()]);

		for (IASTTopLevelNode node : nodes) {

			if (!(node instanceof IASTMMPStatement))

				continue;

			IASTMMPStatement stmt = (IASTMMPStatement) node;

			IConditionalBlock block = getLangNodeConditionalBlock(stmt);

			if (EMMPStatement.SOURCEPATH.matches(stmt)) {

				if (!usedSourcePath

				&&  (lastSourcePathBlock == block || (lastSourcePathBlock != null && lastSourcePathBlock.contains(block)))) {

					deleteStatement(lastSourcePath);

				}

				lastSourcePath = stmt;

				lastSourcePathBlock = block;

				usedSourcePath = false;

			}

			else if (statementUsesSourcePath(stmt)) {

				usedSourcePath = true;

			}

		}

		if (lastSourcePath != null && !usedSourcePath) {

			deleteStatement(lastSourcePath);

		}

	}

	private void addMissingSourcePaths(IASTTranslationUnit tu) {

		IASTMMPSingleArgumentStatement lastSourcePathStatement = null;

		updateCurrentDirectory(tu);

		IPath lastSourcePath = defaultProjectRelativeSourcePath();

		// scan top-level nodes (only -- not inside START or the like) to see

		// if every statement that has a reference to a SOURCEPATH is still

		// "seeing" the same node (or equivalent)