/*

* 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.bldinf;

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

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

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

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

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

import java.util.*;

/**

 * This class updates the bld.inf by updatening one statement at a time, 

 * maintaining state about what statements it has handled.  This

 * is a destructive operation because it changes the view as

 * it updates the TU.   

 *

 */

public class BldInfStatementUpdater extends BaseStatementUpdater {

	private BldInfView bldInfView;

	private Map<IMakMakeReference, IASTBldInfMakMakeStatement> makToStatementMap; 

	private Map<IMakMakeReference, IASTBldInfMakMakeStatement> testMakToStatementMap; 

	private Map<IExport, IASTBldInfExportStatement> exportToStatementMap;

	private Map<IExport, IASTBldInfExportStatement> testExportToStatementMap; 

	private Map<IExtension, IASTBldInfExtensionBlockStatement> extensionToStatementMap; 

	private Map<IExtension, IASTBldInfExtensionBlockStatement> testExtensionToStatementMap; 

	private Map<IASTBldInfMakMakeStatement, IMakMakeReference> statementToMakMap; 

	private Map<IASTBldInfMakMakeStatement, IMakMakeReference> statementToTestMakMap; 

	private Map<IASTBldInfExportStatement, IExport> statementToExportMap; 

	private Map<IASTBldInfExportStatement, IExport> statementToTestExportMap; 

	private Map<IASTBldInfExtensionBlockStatement, IExtension> statementToExtensionsMap; 

	private Map<IASTBldInfExtensionBlockStatement, IExtension> statementToTestExtensionsMap; 

	private ListIterator<String> platformIter;

	private IASTBldInfPrjPlatformsBlockStatement lastPlatformStatement;

	private boolean isTestMmpFiles, isTestExports, isTestExtensions;

	private IASTBldInfBlockStatement lastBlockStatement;

	private IASTStatement lastStatement;

	private IASTStatement lastMakStatement;

	private IASTStatement lastTestMakStatement;

	private IASTStatement lastExportStatement;

	private IASTStatement lastTestExportStatement;

	private IASTStatement lastExtensionStatement;

	private IASTStatement lastTestExtensionStatement;

	public BldInfStatementUpdater(BldInfView view, List<IViewModification> modifications, List<IMessage> messages) {

		super(view, modifications, messages);

		this.bldInfView = view;

		this.statementToExportMap = new IdentityHashMap<IASTBldInfExportStatement, IExport>();

		this.statementToTestExportMap = new IdentityHashMap<IASTBldInfExportStatement, IExport>();

		this.statementToMakMap = new IdentityHashMap<IASTBldInfMakMakeStatement, IMakMakeReference>();

		this.statementToTestMakMap = new IdentityHashMap<IASTBldInfMakMakeStatement, IMakMakeReference>();

		this.statementToExtensionsMap = new IdentityHashMap<IASTBldInfExtensionBlockStatement, IExtension>();

		this.statementToTestExtensionsMap = new IdentityHashMap<IASTBldInfExtensionBlockStatement, IExtension>();

		platformIter = view.getPlatforms().listIterator();

	}

	protected void scanStatements() {

		// Make an ordered map of model objects -> existing statements.

		// The ordering in the map will be used to drive the reordering modification

		// later on.  So if the model refers to new objects, store a null entry for those

		// until we later fix them up.

		makToStatementMap = scanStructuredBlocks(

				bldInfView.makToStatementMap, statementToMakMap, 

				bldInfView.getMakMakeReferences(), IASTBldInfPrjMmpfilesBlockStatement.class,

				new MakListConverter(bldInfView, BldInfView.PRJ_MMPFILES_KEYWORD));

		testMakToStatementMap = scanStructuredBlocks(

				bldInfView.testMakToStatementMap, statementToTestMakMap, 

				bldInfView.getTestMakMakeReferences(), IASTBldInfPrjMmpfilesBlockStatement.class,

				new MakListConverter(bldInfView, BldInfView.PRJ_TESTMMPFILES_KEYWORD));

		exportToStatementMap = scanStructuredBlocks(

				bldInfView.exportToStatementMap, statementToExportMap, 

				bldInfView.getExports(), IASTBldInfPrjExportsBlockStatement.class,

				new ExportListConverter(bldInfView, BldInfView.PRJ_EXPORTS_KEYWORD));

		testExportToStatementMap = scanStructuredBlocks(

				bldInfView.testExportToStatementMap, statementToTestExportMap, 

				bldInfView.getTestExports(), IASTBldInfPrjExportsBlockStatement.class,

				new ExportListConverter(bldInfView, BldInfView.PRJ_TESTEXPORTS_KEYWORD));

		extensionToStatementMap = scanStructuredBlocks(

				bldInfView.extensionToStatementMap, statementToExtensionsMap, 

				bldInfView.getExtensions(), IASTBldInfPrjExtensionsBlockStatement.class,

				new ExtensionListConverter(bldInfView, BldInfView.PRJ_EXTENSIONS_KEYWORD));

		testExtensionToStatementMap = scanStructuredBlocks(

				bldInfView.testExtensionToStatementMap, statementToTestExtensionsMap, 

				bldInfView.getTestExtensions(), IASTBldInfPrjExtensionsBlockStatement.class,

				new ExtensionListConverter(bldInfView, BldInfView.PRJ_TESTEXTENSIONS_KEYWORD));

	}

	/**

	 * Update a MMP statement from the model.

	 * @return false: statement was deleted, true: statement was retained

	 */

	private boolean updateMakMakeStatement(IASTBldInfMakMakeStatement makmake, boolean test) {

		if (!test) {

			return applyStructuredItemChange(bldInfView.getMakMakeReferences(),

					makmake,

					new MakListConverter(bldInfView, BldInfView.PRJ_MMPFILES_KEYWORD),

					makToStatementMap,

					statementToMakMap) != null;

		} else {

			return applyStructuredItemChange(bldInfView.getTestMakMakeReferences(),

					makmake,

					new MakListConverter(bldInfView, BldInfView.PRJ_TESTMMPFILES_KEYWORD),

					testMakToStatementMap,

					statementToTestMakMap) != null;

		}

	}

	/**

	 * Update an export statement from the model.

	 * @return false: statement was deleted, true: statement was retained

	 */

	private boolean updateExportStatement(IASTBldInfExportStatement export, boolean test) {

		if (!test) {

			return applyStructuredItemChange(bldInfView.getExports(),

					export,

					new ExportListConverter(bldInfView, BldInfView.PRJ_EXPORTS_KEYWORD),

					exportToStatementMap,

					statementToExportMap) != null;

		} else {

			return applyStructuredItemChange(bldInfView.getTestExports(),

					export,

					new ExportListConverter(bldInfView, BldInfView.PRJ_TESTEXPORTS_KEYWORD),

					testExportToStatementMap,

					statementToTestExportMap) != null;

		}

	}

	/**

	 * Update an extension statement from the model.

	 * @return false: statement was deleted, true: statement was retained

	 */

	private boolean updateExtensionStatement(IASTBldInfExtensionBlockStatement extension, boolean test) {

		if (!test) {

			return applyStructuredItemChange(bldInfView.getExtensions(),

					extension,

					new ExtensionListConverter(bldInfView, BldInfView.PRJ_EXTENSIONS_KEYWORD),

					extensionToStatementMap,

					statementToExtensionsMap) != null;

		} else {

			return applyStructuredItemChange(bldInfView.getTestExtensions(),

					extension,

					new ExtensionListConverter(bldInfView, BldInfView.PRJ_TESTEXTENSIONS_KEYWORD),

					testExtensionToStatementMap,

					statementToTestExtensionsMap) != null;

		}

	}

	/**

	 * update a string list.

	 */

	protected boolean updateStringListStatement(IASTListHolder<IASTLiteralTextNode> statement,

			List<String> list,

			ListIterator<String> listIterator) { 

		return updateListStatement(statement, list, listIterator,   

				new PlatformStatementListConverter());

	}

	@Override

	public void update() {

		resetInsertPoints();

		super.update();

	}

	protected void doUpdateStatement(IASTStatement statement) {

		if (lastStatement != null && lastStatement.getSourceRegion().getFirstDocument() != statement.getSourceRegion().getFirstDocument()) {

			resetInsertPoints();

		}

		if (statement instanceof IASTBldInfPrjPlatformsBlockStatement) {

			IASTBldInfPrjPlatformsBlockStatement platformsStatement = (IASTBldInfPrjPlatformsBlockStatement) statement;

			lastPlatformStatement = platformsStatement;

			if (updateStringListStatement(platformsStatement, 

					bldInfView.getPlatforms(), platformIter)) {

				lastPlatformStatement = null;

			} else {

				lastStatement = statement;

				lastBlockStatement = null;

			}

		}

		else if (statement instanceof IASTBldInfPrjExportsBlockStatement) {

			if (BldInfView.PRJ_EXPORTS_KEYWORD.equalsIgnoreCase(

					((IASTBldInfPrjExportsBlockStatement) statement).getKeywordName())) {

				isTestExports = false;

				lastExportStatement = statement;

			} else {

				isTestExports = true;

				lastTestExportStatement = statement;

			}

			lastBlockStatement = (IASTBldInfBlockStatement) statement;

			lastStatement = statement;

			changeStatement(statement);

		}

		else if (statement instanceof IASTBldInfExportStatement) {

			if (updateExportStatement((IASTBldInfExportStatement) statement, isTestExports)) {

				lastStatement = statement;

				if (!isTestExports)

					lastExportStatement = statement;

				else

					lastTestExportStatement = statement;

			}

		}

		else if (statement instanceof IASTBldInfPrjMmpfilesBlockStatement) {

			if (BldInfView.PRJ_MMPFILES_KEYWORD.equalsIgnoreCase(

					((IASTBldInfPrjMmpfilesBlockStatement) statement).getKeywordName())) {

				isTestMmpFiles = false;

				lastMakStatement = statement;

			} else {

				isTestMmpFiles = true;

				lastTestMakStatement = statement;

			}

			lastBlockStatement = (IASTBldInfBlockStatement) statement;

			lastStatement = statement;

			changeStatement(statement);

		}

		else if (statement instanceof IASTBldInfMakMakeStatement) {

			if (updateMakMakeStatement((IASTBldInfMakMakeStatement) statement, isTestMmpFiles)) {

				lastStatement = statement;

				if (!isTestMmpFiles)

					lastMakStatement = statement;

				else

					lastTestMakStatement = statement;

			}

		}

		else if (statement instanceof IASTBldInfPrjExtensionsBlockStatement) {

			if (BldInfView.PRJ_EXTENSIONS_KEYWORD.equalsIgnoreCase(

					((IASTBldInfPrjExtensionsBlockStatement) statement).getKeywordName())) {

				isTestExtensions = false;

				lastExtensionStatement = statement;

			} else {

				isTestExtensions = true;

				lastTestExtensionStatement = statement;

			}

			lastBlockStatement = (IASTBldInfBlockStatement) statement;

			lastStatement = statement;

			changeStatement(statement);

		}

		else if (statement instanceof IASTBldInfExtensionBlockStatement) {

			if (updateExtensionStatement((IASTBldInfExtensionBlockStatement) statement, isTestExtensions)) {

				lastStatement = statement;

				if (!isTestExtensions)

					lastExtensionStatement = statement;

				else

					lastTestExtensionStatement = statement;

			}

		}

		else {

			// ignore

			lastStatement = statement;

		}

	}

	private void resetInsertPoints() {

		lastStatement = null;

		lastBlockStatement = null;

		lastMakStatement = null;

		lastTestMakStatement = null;

		lastExportStatement = null;

		lastTestExportStatement = null;

		lastExtensionStatement = null;

		lastTestExtensionStatement = null;

	}

	class NewMakListConverter extends MakListConverter {

		private final boolean isTest;

		NewMakListConverter(BldInfView bldInfView, boolean isTest) {

			super(bldInfView, isTest ? BldInfView.PRJ_TESTMMPFILES_KEYWORD : BldInfView.PRJ_MMPFILES_KEYWORD);

			this.isTest = isTest;

		}

		@Override

		public Pair<IASTNode, IASTNode> getInsertAnchors() {

			IASTNode after = isTest ? lastTestMakStatement : lastMakStatement;

			return adjustForConditionalBlocks(after);

		}

		@Override

		public IASTStatement createContextStatement(IMakMakeReference model) {

			IASTNode after = isTest ? lastTestMakStatement : lastMakStatement;

			if (after != null) {

				return null;

			}

			if (isTest ? lastTestMakStatement != null : lastMakStatement != null) {

				return null;

			}

			/*

			if (lastBlockStatement instanceof IASTBldInfPrjMmpfilesBlockStatement 

					&& ((IASTBldInfPrjMmpfilesBlockStatement) lastBlockStatement).getKeywordName().equalsIgnoreCase(sectionName)) {

				return null;

			}*/

			lastBlockStatement = ASTBldInfFactory.createBldInfBlockStatement(sectionName);

			lastStatement = null;

			if (isTest) {

				lastTestMakStatement = lastBlockStatement;

			} else {

				lastMakStatement = lastBlockStatement;

			}

			return lastBlockStatement;

		}

		@Override

		public IASTBldInfMakMakeStatement toNode(IMakMakeReference mak) {

			IASTBldInfMakMakeStatement stmt = super.toNode(mak);

			if (stmt != null) {

				lastStatement = stmt;

				if (isTest) {

					lastTestMakStatement = lastStatement;

				} else {

					lastMakStatement = lastStatement;

				}

			}

			return stmt;

		}

	}

	class NewExportListConverter extends ExportListConverter {

		private final boolean isTest;

		NewExportListConverter(BldInfView bldInfView, boolean isTest) {

			super(bldInfView, isTest ? BldInfView.PRJ_TESTEXPORTS_KEYWORD : BldInfView.PRJ_EXPORTS_KEYWORD);

			this.isTest = isTest;

		}

		@Override

		public Pair<IASTNode, IASTNode> getInsertAnchors() {

			IASTNode after = isTest ? lastTestExportStatement : lastExportStatement;

			return adjustForConditionalBlocks(after);

		}

		@Override

		public IASTStatement createContextStatement(IExport model) {

			if (lastBlockStatement instanceof IASTBldInfPrjExportsBlockStatement 

					&& ((IASTBldInfPrjExportsBlockStatement) lastBlockStatement).getKeywordName().equalsIgnoreCase(sectionName)) {

				return null;

			}

			if (isTest ? lastTestExportStatement != null : lastExportStatement != null) {

				return null;

			}

			lastBlockStatement = ASTBldInfFactory.createBldInfBlockStatement(sectionName);

			lastStatement = null;

			if (isTest) {

				lastTestExportStatement = lastBlockStatement;

			} else {

				lastExportStatement = lastBlockStatement;

			}

			return lastBlockStatement;

		}

		@Override

		public IASTBldInfExportStatement toNode(IExport export) {

			IASTBldInfExportStatement stmt = super.toNode(export);

			if (stmt != null) {

				lastStatement = stmt;

				if (isTest) {

					lastTestExportStatement = lastStatement;

				} else {

					lastExportStatement = lastStatement;

				}

			}

			return stmt;

		}

	}

	class NewExtensionListConverter extends ExtensionListConverter {

		private final boolean isTest;

		NewExtensionListConverter(BldInfView bldInfView, boolean isTest) {

			super(bldInfView, isTest ? BldInfView.PRJ_TESTEXTENSIONS_KEYWORD : BldInfView.PRJ_EXTENSIONS_KEYWORD);

			this.isTest = isTest;

		}

		@Override

		public Pair<IASTNode, IASTNode> getInsertAnchors() {

			IASTNode after = isTest ? lastTestExtensionStatement : lastExtensionStatement;

			return adjustForConditionalBlocks(after);

		}

		@Override

		public IASTStatement createContextStatement(IExtension model) {

			if (lastBlockStatement instanceof IASTBldInfPrjExtensionsBlockStatement 

					&& ((IASTBldInfPrjExtensionsBlockStatement) lastBlockStatement).getKeywordName().equalsIgnoreCase(sectionName)) {

				return null;

			}

			if (isTest ? lastTestExtensionStatement != null : lastExtensionStatement != null) {

				return null;

			}

			lastBlockStatement = ASTBldInfFactory.createBldInfBlockStatement(sectionName);

			lastStatement = null;

			if (isTest) {

				lastTestExtensionStatement = lastBlockStatement;

			} else {

				lastExtensionStatement = lastBlockStatement;

			}

			return lastBlockStatement;

		}

		@Override

		public IASTBldInfExtensionBlockStatement toNode(IExtension export) {

			IASTBldInfExtensionBlockStatement stmt = super.toNode(export);

			if (stmt != null) {

				lastStatement = stmt;

				if (isTest) {

					lastTestExtensionStatement = lastStatement;

				} else {

					lastExtensionStatement = lastStatement;

				}

			}

			return stmt;

		}

	}

	private void applyNewBlockStatements() {

		if (lastBlockStatement != null && 

				view.getFilteredTranslationUnit().getMainDocument() != lastBlockStatement.getSourceRegion().getFirstDocument()) {

			resetInsertPoints();

		}

		applyNewStructuredItemStatements(bldInfView.getMakMakeReferences(),

				new NewMakListConverter(bldInfView, false),

				makToStatementMap);

		applyNewStructuredItemStatements(bldInfView.getExports(), 

				new NewExportListConverter(bldInfView, false),

				exportToStatementMap);

		applyNewStructuredItemStatements(bldInfView.getExtensions(), 

				new NewExtensionListConverter(bldInfView, false),

				extensionToStatementMap);

		applyNewStructuredItemStatements(bldInfView.getTestMakMakeReferences(), 

				new NewMakListConverter(bldInfView, true),

				testMakToStatementMap);

		applyNewStructuredItemStatements(bldInfView.getTestExports(), 

				new NewExportListConverter(bldInfView, true),

				testExportToStatementMap);

		applyNewStructuredItemStatements(bldInfView.getTestExtensions(), 

				new NewExtensionListConverter(bldInfView, true),

				testExtensionToStatementMap);

	}

	/**

	 * Find the insert anchors given this nominal 'after' anchor by using the

	 * anchor if it's not in a conditional block and inserting before the next

	 * block statement otherwise.

	 * @param after

	 * @return insert anchors

	 */

	public Pair<IASTNode, IASTNode> adjustForConditionalBlocks(IASTNode after) {

		IASTNode before = null;

		if (after != null && view.isLangNodeInConditionalBlock(after)) {

			IASTListNode list = ((IASTListNode)after.getParent());

			IASTNode node = null;

			int idx = list.indexOf(after);

			for (Iterator<IASTNode> nodeIter = list.listIterator(idx);

				nodeIter.hasNext();) {

				node = nodeIter.next();

				if (node instanceof IASTBldInfBlockStatement)

					break;

				idx++;

				node = null;

			}

			if (node != null) {

				before = node;

				after = null;

			} else {

				after = null;

			}

		}

		return new Pair(before, after);

	}

	static class PlatformStatementListConverter implements ListStatementListConverter<IASTLiteralTextNode, String> {

		public IASTListHolder<IASTLiteralTextNode> createNewListStatement() {

			return ASTBldInfFactory.createBldInfPrjPlatformsBlockStatement(new String[0]);

		}

		public boolean allowEmptyStatements() {

			return true;

		}

		public boolean canAddToStatement(String model) {

			return true;

		}

		public boolean changeRequiresNewContext(String existing,

				String newElement) {

			return false;

		}

		public IASTStatement createContextStatement(String model) {

			return null;

		}

		public String fromNode(IASTLiteralTextNode node) {

			return node.getValue();

		}