package com.nokia.carbide.cpp.internal.api.sdk;

import java.io.File;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.eclipse.cdt.core.settings.model.ICStorageElement;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.ui.PlatformUI;

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

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

import com.nokia.carbide.cpp.internal.api.sdk.sbsv2.SBSv2ConfigQueryData;

import com.nokia.carbide.cpp.internal.api.sdk.sbsv2.SBSv2MinimumVersionException;

import com.nokia.carbide.cpp.internal.api.sdk.sbsv2.SBSv2QueryUtils;

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.cpp.sdk.core.SDKCorePlugin;

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

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

import com.nokia.cpp.internal.api.utils.ui.WorkbenchUtils;

public class BuildContextSBSv2 implements ISBSv2BuildContext {

	private String platform;

	private String target;

	private String sbsv2Alias;

	private ISymbianSDK sdk;

	private String displayString;

	private String configID;  // cconfiguration 'id' attribute from .cproject

	private boolean reportedSBSVersionError;

	// Raptor config query data

	private ISBSv2ConfigQueryData configQueryData;

	// cconfiguration data store

	private SBSv2BuilderInfo sbsv2BuildInfo;

	private IPath cachedVariantHRHFile = null;

	public BuildContextSBSv2(ISymbianSDK sdk, String platform, String target, String alias, String displayString, String configID) {

		this.sdk = sdk;

		if (platform == null){

			this.platform = "unknown_platform";

		} else {

			this.platform = platform.toUpperCase();

		}

		if (target == null){

			this.target = "unknown_target";

		} else {

			this.target = target.toUpperCase();

		}

		this.sbsv2Alias = alias;

		this.displayString = displayString;

		this.configID = configID;

		this.configQueryData = setConfigQueryData(sdk, alias);

	}

	public BuildContextSBSv2(ISymbianSDK sdk, String alias, ISBSv2ConfigQueryData configData) {

		this.sdk = sdk;

		this.sbsv2Alias = alias;

		this.configQueryData = configData;

		setPlatformAndTargetFromOutputPath();

		this.configID = ISBSv2BuildContext.BUILDER_ID + "." + sbsv2Alias + "." + sdk.getUniqueId();

		this.displayString = sbsv2Alias + " [" + sdk.getUniqueId() + "]"; 

	}

	public ISymbianSDK getSDK() {

		return sdk;

	}

	public String getPlatformString() {

		if (platform == null){

			return configQueryData.getConfigurationErrorMessage();

		}

		if (platform.contains(".")){

			String[] tok = platform.split(".");

			if (tok.length > 0) return tok[0];

		}

		return platform;

	}

	public String getPlatformReleaseDirName() {

		return platform;

	}

	public String getTargetString() {

		if (target == null){

			return configQueryData.getConfigurationErrorMessage();

		}

		return target;

	}

	public String getConfigID(){

		return configID;

	}

	public String getDisplayString() {

		Check.checkState(displayString != null);

		return displayString;

	}

	@Override

	public String toString() {

		return getConfigID();

	}

	public String getDefaultDefFileDirectoryName() {

		String dirName = getDefFileDirectoryNameForPlatform(platform);

		if (dirName == null) {

			// fallback for unknown cases

			dirName = platform;

		}

		return dirName;

	}

	private String getDefFileDirectoryNameForPlatform(String platform) {

		if (sbsv2Alias.toUpperCase().contains("WINSCW")) {

			return "BWINS"; //$NON-NLS-1$

		} else if (sbsv2Alias.toUpperCase().contains("ARM")) {

			return "EABI"; //$NON-NLS-1$

		}

		return null;

	}

	public IPath getCompilerPrefixFile() {

		if (sbsv2Alias.toUpperCase().contains(TOOLCHAIN_GCCE) ||

			sbsv2Alias.toUpperCase().contains(TOOLCHAIN_ARM)) {

			if (configQueryData != null) {

				return new Path(configQueryData.getBuildPrefix());

			}

		} 

		// fallback for WINSCW, MSVC, etc.

		return null;

	}

	public List<IDefine> getVariantHRHDefines() {

		return getCachedData().getVariantHRHDefines();

	}

	public List<File> getVariantHRHIncludes() {

		return getCachedData().getPrefixFileIncludes();

	}

	public List<IDefine> getCompilerPreincludeDefines() {

		IPath prefixFile = getCompilerPrefixFile();

		if (prefixFile == null || !prefixFile.toFile().exists()) {

			return getCachedData().getCompilerMacros(null);

		}

		return getCachedData().getCompilerMacros(prefixFile);

	}

	public String getBuildVariationName() {

		// Not needed for Raptor

		return "";

	}

	public String getSBSv2Alias() {

		return sbsv2Alias;

	}

	/**

	 * Get the cache holding the data that applies to this build context globally.

	 * A build context is subclassed by CarbideBuildConfiguration, which has multiple

	 * instances at runtime, thus, a SymbianBuildContext instance should not hold a cache itself.

	 * @return cache, never <code>null</code>

	 */

	private SymbianBuildContextDataCache getCachedData() {

		return SymbianBuildContextDataCache.getCache(this);

	}

	/**

	 * Get the list of #include paths detected for this context.

	 * @return List or <code>null</code>

	 */

	public List<File> getCachedSystemIncludePaths() {

		return getCachedData().getSystemIncludePaths();

	}

	public static String getPlatformFromV1ConfigName(String displayString) {

		String[] tokens = displayString.split(" ");

		String sdkIdToken = tokens[2];

		if (sdkIdToken.contains("_")){

			sdkIdToken = sdkIdToken.substring(1, sdkIdToken.length()-1);

			String[] aliasTokens = sdkIdToken.split("_");

			return aliasTokens[0];

		} else {

			return sdkIdToken.substring(1, sdkIdToken.length()-1);

		}

	}

	@Override

	public int hashCode() {

		final int prime = 31;

		int result = 1;

		result = prime * result

				+ ((configID == null) ? 0 : configID.hashCode());

		return result;

	}

	@Override

	public boolean equals(Object obj) {

		if (this == obj)

			return true;

		if (obj == null)

			return false;

		if (getClass() != obj.getClass())

			return false;

		BuildContextSBSv2 other = (BuildContextSBSv2) obj;

		if (configID == null) {

			if (other.configID != null)

				return false;

		} else if (!configID.equals(other.configID))

			return false;

		return true;

	}

	public static String getTargetFromV1ConfigName(String displayString) {

		String[] tokens = displayString.split(" ");

		if (tokens[1].compareTo("Debug") == 0) {

			return ISymbianBuildContext.DEBUG_TARGET;

		} else {

			return ISymbianBuildContext.RELEASE_TARGET;

		}

	}

	public static String getBuildAliasFromV1ConfigName(String displayString) {

		String target = getTargetFromV1ConfigName(displayString);

		String platform = getPlatformFromV1ConfigName(displayString);

		return platform.toLowerCase() + "_" + target.toLowerCase();

	}

	// Fall-back to get SDK id from old config name

	public static String getSDKIDFromV1ConfigName(String configName) {

		int indexBegin = configName.indexOf("[");  //$NON-NLS-1$

		int indexEnd = configName.indexOf("]");  //$NON-NLS-1$

		if (indexBegin > 0 && indexEnd > 0){

			return configName.substring(indexBegin+1, indexEnd);

		} else {

			return ""; //$NON-NLS-1$

		}

	}

	private void setPlatformAndTargetFromOutputPath() {

		String pathString = configQueryData.getOutputPathString();

		if (pathString == null || pathString.length() == 0) {

			platform = "";

			target = "";

			return;

		}

		IPath releasePath = new Path(configQueryData.getOutputPathString());

		int epoc32SegmentIndex = 0;

		for (String segment : releasePath.segments()){

			if (segment.toLowerCase().equals("epoc32"))

				break;

			epoc32SegmentIndex++;

		}

		// assuming /epoc32/<release>/<target>/

		platform = releasePath.segment(epoc32SegmentIndex+2).toUpperCase();

		target = releasePath.segment(epoc32SegmentIndex+3).toUpperCase();

	}

	private ISBSv2ConfigQueryData setConfigQueryData(ISymbianSDK sdk, String alias) {

		SBSv2ConfigQueryData configQueryData = null;

		try {

			configQueryData = SBSv2QueryUtils.getConfigQueryDataForSDK(sdk, alias);

			if (configQueryData == null) {

				Map<String, String> aliasToMeaningMap = SBSv2QueryUtils.getAliasesForSDK(sdk);

				List<String> aliasList = new ArrayList<String>();

				aliasList.add(alias);

				String configQueryXML = SBSv2QueryUtils.getConfigQueryXMLforSDK(sdk, aliasList);

				if (aliasToMeaningMap.get(alias) != null){

					configQueryData = new SBSv2ConfigQueryData(alias, aliasToMeaningMap.get(alias), configQueryXML);

				}

			}

		} catch (final SBSv2MinimumVersionException e) {

			reportedSBSVersionError = true; // only report once per IDE session.

			PlatformUI.getWorkbench().getDisplay().asyncExec(new Runnable() {

				public void run() {

					if (!reportedSBSVersionError){

						MessageDialog.openError(WorkbenchUtils.getSafeShell(), "Minimum sbs version not met.", e.getMessage());

					}

				}

			});	

			Logging.log(SDKCorePlugin.getDefault(), Logging.newSimpleStatus(0, IStatus.ERROR,

						MessageFormat.format(e.getMessage(), ""), e));

		}

		return configQueryData;

	}

	public ISBSv2ConfigQueryData getConfigQueryData() {

		return configQueryData;

	}

	public String getToolChain() {

		if (configQueryData != null) {

			Map<String, String> buildMacros = configQueryData.getBuildMacros();

			// try to figure out the tool chain using macros from Raptor config query

			if (buildMacros.containsKey(MACRO_ARM)) {

				return TOOLCHAIN_ARM;

			} else if (buildMacros.containsKey(MACRO_GCCE)) {

				return TOOLCHAIN_GCCE;

			} else if (buildMacros.containsKey(MACRO_WINSCW)) {

				return TOOLCHAIN_WINSCW;

			}

		} else {

			// if no macros available, use alias name instead

			if (sbsv2Alias.toUpperCase().contains(TOOLCHAIN_ARM)) {

				return TOOLCHAIN_ARM;

			} else if (sbsv2Alias.toUpperCase().contains(TOOLCHAIN_GCCE)) {

				return TOOLCHAIN_GCCE;

			} else if (sbsv2Alias.toUpperCase().contains(TOOLCHAIN_WINSCW)) {

				return TOOLCHAIN_WINSCW;

			}

		}

		return TOOLCHAIN_UNKNOWN;

	}

	public List<IPath> getSystemIncludes() {

		if (configQueryData != null) {

			List<String> includes = configQueryData.getMetaDataIncludes();

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

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

				for (Iterator<String> itr = includes.iterator(); itr.hasNext();) {

					String include = itr.next();

					if (include.length() == 0 || include.equals(".")) {

						continue;

					}

					Path includePath = new Path(include);

					if (!includePaths.contains(includePath)) {

						includePaths.add(includePath);

					}

				}

				return includePaths;

			}

		}

		return null;

	}

	public List<String> getSupportedTargettypes() {

		return configQueryData.getTargettypes();

	}

	public void loadConfigurationSettings(ICStorageElement se) {

		if (sbsv2BuildInfo == null){

			sbsv2BuildInfo = new SBSv2BuilderInfo();

		}

		sbsv2BuildInfo.loadFromStorage(se);

	}

	public void saveConfigurationSettings(ICStorageElement se, ISymbianBuildContext context) {

		sbsv2BuildInfo = new SBSv2BuilderInfo((ISBSv2BuildContext)context);

		sbsv2BuildInfo.saveToStorage(se.createChild(SBSV2_DATA_ID)); 

	}

	/**

	 * Get the unique ID for this build configuration.

	 * For ABLD it is the display name, for SBSv2, it is the builder ID (cconfiguration 'id')

	 * @return

	 */

	public String getConfigurationID() {

		return getConfigID();

	}

	/**

	 * Get the full path to the prefix file defined under \epoc32\tools\variant\variant.cfg

	 * @return A path object, or null if the variant.cfg does not exist. This routine does not check to see if the returned path exists.

	 */

	public IPath getPrefixFromVariantCfg(){

		ISBSv2BuildInfo sbsv2BldInfo = ((ISBSv2BuildInfo)getSDK().getBuildInfo(ISymbianBuilderID.SBSV2_BUILDER));

		return sbsv2BldInfo.getPrefixFromVariantCfg();

	}

	public List<IDefine> getBuildMacros() {

		ISBSv2BuildInfo sbsv2BldInfo = ((ISBSv2BuildInfo)getSDK().getBuildInfo(ISymbianBuilderID.SBSV2_BUILDER));

		Map<String, String> buildMacroMap = sbsv2BldInfo.getBuildMacros(getSBSv2Alias());

		List<IDefine> defines = new ArrayList<IDefine>();

		for (String macroName : buildMacroMap.keySet()){

			defines.add(DefineFactory.createDefine(macroName, buildMacroMap.get(macroName)));

		}

		return defines;

	}

	public List<IDefine> getMetadataMacros() {

		ISBSv2BuildInfo sbsv2BldInfo = ((ISBSv2BuildInfo)getSDK().getBuildInfo(ISymbianBuilderID.SBSV2_BUILDER));

		Map<String, String> platMacroMap = sbsv2BldInfo.getMetadataMacros(getSBSv2Alias());

		List<IDefine> defines = new ArrayList<IDefine>();

		for (String macroName : platMacroMap.keySet()){

			defines.add(DefineFactory.createDefine(macroName, platMacroMap.get(macroName)));

		}

		return defines;

	}

	public IDefine getTargetTypeMacro(String targettype) {

		ISBSv2BuildInfo sbsv2BuildInfo = (ISBSv2BuildInfo)sdk.getBuildInfo(ISymbianBuilderID.SBSV2_BUILDER);

		return DefineFactory.createDefine(sbsv2BuildInfo.getTargetTypeMacro(targettype));

	}

}