/*

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

*

*/

package com.nokia.carbide.cpp.internal.sdk.core.model;

import java.text.MessageFormat;

import javax.xml.transform.dom.DOMSource;

import javax.xml.transform.stream.StreamResult;

import org.eclipse.cdt.utils.WindowsRegistry;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.emf.common.util.EList;

import org.eclipse.jface.dialogs.MessageDialog;

import org.eclipse.osgi.service.datalocation.Location;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.PlatformUI;

import org.osgi.framework.Version;

import org.w3c.dom.traversal.NodeIterator;

import org.xml.sax.SAXException;

import com.nokia.carbide.cpp.internal.sdk.core.gen.Devices.DeviceType;

import com.nokia.carbide.cpp.internal.sdk.core.gen.Devices.DevicesType;

import com.nokia.carbide.cpp.internal.sdk.core.xml.DevicesLoader;

import com.nokia.carbide.cpp.sdk.core.ICarbideInstalledSDKChangeListener.SDKChangeEventType;

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

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

import com.sun.org.apache.xpath.internal.XPathAPI;

public class SDKManager implements ISDKManager, ISDKManagerInternal {

	private static List<ISymbianSDK> sdkList = new ArrayList<ISymbianSDK>();

	private HashMap<String,ISymbianSDK> missingSdkMap = new HashMap<String,ISymbianSDK>();

	private static final String SYMBIAN_COMMON_REG_PATH = "SOFTWARE\\Symbian\\EPOC SDKs\\";

	private static final String SYMBIAN_COMMON_PATH = "CommonPath";

	private static final String WINDOWS_SYSTEM_ROOT_REG = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\";

	private static final String WINDOWS_SYSTEM_ROOT_KEY = "SystemRoot";

	private static final String EMPTY_DEVICES_XML_CONTENT = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><devices version=\"1.0\"></devices>";

	private static final String CARBIDE_SDK_CACHE_FILE_NAME = "carbideSDKCache.xml";

	private static final String SDK_CACHE_ID_ATTRIB = "id";

	private static final String SDK_CACHE_ENABLED_ATTRIB = "isEnabled";

	private static final String SDK_CACHE_OS_VERSION_ATTRIB = "osVersion";

	private static final String SDK_CACHE_OS_BRANCH_ATTRIB = "osBranch";

	private static final String SDK_CACHE_SDK_VERSION_ATTRIB = "sdkVersion";

	private static final String SDK_SCANNED_FOR_PLUGINS = "sdkScanned";

	private static final String EMPTY_STRING = "";

	private static boolean enableBSFScanner;

	private static List<BuildPlat> platList = new ArrayList<BuildPlat>();

	private static SymbianMacroStore macroStore;

	private static final String[] knownRVCTVersions = {"3.1", "3.0", "2.2", "2.1"};

	static boolean hasPromptedForDevicesXML = false; // make sure we only ask once at startup if devices.xml does not exist

	static boolean hasScannedSDKs = false; // make sure we only scan SDKs when needed

	long devicesXLMLastModified;

	private static List<IRVCTToolChainInfo> rvctInfoList = null;

	/**

	 * Registry key location for checking CSL (GCCE) Arm Toolchain installation directory. 

	 */

	private static final String CSL_ARM_TOOLCHAIN_REG_PATH="SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\CSL Arm Toolchain (arm-symbianelf)_is1";

	/**

	 * Registry key for checking CSL (GCCE) Arm Toolchain installation directory. 

	 */

	private static final String CSL_ARM_TOOLCHAIN_REG_KEY="InstallLocation";

	/**

	 * Implement listener so other class that use this can listen to SDK 

	 * change event (e.g. validate project config description)

	 */

	private static ListenerList<ICarbideInstalledSDKChangeListener> listeners = new ListenerList<ICarbideInstalledSDKChangeListener>();

	/*

	 * Implement listener so other class that use this can listen for when a change to the devices.xml

	 * has been modified outside of Carbide

	 */

	private static ListenerList<ICarbideDevicesXMLChangeListener> devicesXMLListeners = new ListenerList<ICarbideDevicesXMLChangeListener>();

	public SDKManager() {

		macroStore = SymbianMacroStore.getInstance();

		checkPerlInstallation();

	}

	public SymbianMacroStore getSymbianMacroStore(){

		return macroStore;

	}

	public void scanSDKs() {

		synchronized (sdkList)

		{

			ArrayList<ISymbianSDK> oldSDkList = new ArrayList<ISymbianSDK>(sdkList);

			if (sdkList != null){

				sdkList.clear();

			}

			DevicesType devicesType;

			try {

				File devicesFile = getDevicesXMLFile();

				if (devicesFile == null || !devicesFile.exists()) {

					// There is no devices.xml. Ask the user if he/she wants to

					// add it

					if (hasPromptedForDevicesXML == false) {

						hasPromptedForDevicesXML = true;

						doAsynchPromptCreateDevicesXML();

					}

					return; // no devices.xml file..

				}

				devicesXLMLastModified = devicesFile.lastModified();

				devicesType = DevicesLoader.loadDevices(devicesFile.toURL());

				EList devices = devicesType.getDevice();

				for (Iterator iter = devices.iterator(); iter.hasNext();) {

					SymbianSDK sdk = new SymbianSDK((DeviceType) iter.next());

					sdkList.add(sdk);

				}

				// now these SDK's are newly added, remove from internal list

				for (ISymbianSDK sdk : sdkList) {

					if (SDKManagerInternalAPI.getMissingSdk(sdk.getUniqueId()) != null) {

						SDKManagerInternalAPI.removeMissingSdk(sdk

								.getUniqueId());

					}

				}

				// now these SDK's are removed from the old list, add to

				// internal list

				for (ISymbianSDK oldSdk : oldSDkList) {

					boolean found = false;

					for (ISymbianSDK sdk : sdkList) {

						if (sdk.getUniqueId().equals(oldSdk.getUniqueId())) {

							found = true;

							break;

						}

					}

					if (found == false) {

						SDKManagerInternalAPI.addMissingSdk(oldSdk

								.getUniqueId());

					}

				}

			} catch (MalformedURLException e) {

				e.printStackTrace();

			} catch (URISyntaxException e) {

				e.printStackTrace();

			} catch (IOException e) {

				e.printStackTrace();

			}

		}

		// make sure we don't rescan over and over again

		hasScannedSDKs = true;

		// tell others about it

		fireInstalledSdkChanged(SDKChangeEventType.eSDKScanned);

		scanCarbideSDKCache();

	}

	private void ensureScannedSDKs() {

		if (!hasScannedSDKs) {

			scanSDKs();

		}

	}

	public List<ISymbianSDK> getSDKList() {

		synchronized(sdkList)

		{

			if (sdkList.size() < 1) {

				ensureScannedSDKs();

			}

			List<ISymbianSDK> listCopy = new ArrayList<ISymbianSDK>(sdkList);

			return listCopy;			

		}

	}

	public ISymbianSDK getSDK(String sdkId, boolean scanIfNecessary) {

		if (scanIfNecessary) {

			getSDKList();

		}

		synchronized(sdkList)

		{

			for (Iterator iter = sdkList.iterator(); iter.hasNext();) {

				ISymbianSDK sdk = (ISymbianSDK)iter.next();

				if (sdk.getUniqueId().compareTo(sdkId) == 0) {

					return sdk;

				}

			}

		}

		return null;

	}

	public void updateSDK(ISymbianSDK sdk) {

		try {

			File devicesFile = getDevicesXMLFile();

			// If file does not exist exception will catch it

			DevicesLoader.updateDevice(sdk, devicesFile.toURL());

			updateCarbideSDKCache();

		} catch (Exception e) { 

			// must catch and rethrow as unchecked exception this 

			// because no throws clause in API method

			throw new RuntimeException(e);

		}

	}

	public void addSDK(ISymbianSDK sdk) {

		synchronized(sdkList)

		{

			try {

				updateSDK(sdk);

				sdkList.add(sdk);

				SDKManagerInternalAPI.removeMissingSdk(sdk.getUniqueId());

				// tell others about it

				fireInstalledSdkChanged(SDKChangeEventType.eSDKAdded);

			}

			catch (Exception e) {

				logError("Could not add SDK", e);

				String message = "Could not add this SDK. Your devices.xml file may be corrupt. If you remove the file from its current location and then rescan SDKs, Carbide will offer to create a new one.";

				Logging.showErrorDialog(WorkbenchUtils.getSafeShell(), null, message, Logging.newSimpleStatus(1, e));

			}

		}

	}

	public void setDefaultSDK(ISymbianSDK sdk){

		try {

			File devicesFile = getDevicesXMLFile();

			synchronized(sdkList)

			{

				for (ISymbianSDK currSDK : sdkList){

					if (!currSDK.getUniqueId().equals(sdk.getUniqueId())){

						currSDK.setIsDefaultSDK(false);  // set all to false, except the input one

					}

				}

			}

			DevicesLoader.setDefaultDevice(sdk, devicesFile.toURL());

			updateCarbideSDKCache();

		} catch (MalformedURLException e) {

			e.printStackTrace();

		} catch (URISyntaxException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public boolean removeSDK(String sdkId) {

		synchronized (sdkList)

		{

			if (sdkList != null){

				for (ISymbianSDK currSDK : sdkList){

					if (currSDK.getUniqueId().equals(sdkId)){

						sdkList.remove(currSDK);

						SDKManagerInternalAPI.addMissingSdk(currSDK.getUniqueId());

						// tell others about it

						fireInstalledSdkChanged(SDKChangeEventType.eSDKRemoved);

						// Now actually remove it from the file...

						DevicesType devicesType;

						try {

							File devicesFile = getDevicesXMLFile();

							// if file does not exist, let exception cath it...

							devicesType = DevicesLoader.loadDevices(devicesFile.toURL());

							EList devices = devicesType.getDevice();

							for (Iterator iter = devices.iterator(); iter.hasNext();) {

								DeviceType device = (DeviceType)iter.next();

								if (device.getId().equals(sdkId)){

									if (!DevicesLoader.deleteDeviceEntry(device, devicesFile.toURL())){

										return false; // write failed

									}

									break;

								}

							}

						} catch (MalformedURLException e) {

							e.printStackTrace();

						} catch (URISyntaxException e) {

							e.printStackTrace();

						} catch (IOException e) {

							e.printStackTrace();

						}

						break;

					}

				}

				updateCarbideSDKCache();

			} else {

				return false;

			}			

		}

		return true;

	}

	// Read the devices.xml locaiton from the local machine registry.

	// return IPath with absolute path to file if it exists or null if file does not exist or registry entry not found.

	private IPath getDevicesXMLFromRegistry(){

		String regValue = WindowsRegistry.getRegistry().getLocalMachineValue(SYMBIAN_COMMON_REG_PATH, SYMBIAN_COMMON_PATH);

		IPath regPath = regValue != null ? new Path(regValue) : null;

		if (regPath == null){

			// No registry entry found...

			String errMsg = MessageFormat.format(

							"Could not read registry for local machine key: {0} Cannot get devices.xml for installed SDKs.",

							SYMBIAN_COMMON_REG_PATH);

			logError(errMsg, null);

			return null;

		}

		// registry entry exists, check existence of file

		regPath = regPath.append(DEVICES_FILE_NAME);

		if (!regPath.toFile().exists()){

			String errMsg = MessageFormat.format("Devices.xml does not exist at: {0}", regPath);

			logError(errMsg, null);

			return null;

		}

		return regPath;

	}

	private void scanCarbideSDKCache(){

		DocumentBuilder docBuilder = null;

		try {

			docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();

		} catch (ParserConfigurationException e) {

			ResourcesPlugin.getPlugin().getLog().log(new Status(IStatus.ERROR, SDKCorePlugin.PLUGIN_ID, IStatus.ERROR, e.getMessage(), e));

			throw new RuntimeException(e);

		}

		// NOTE: If debugging runtime workbench and you clear your configuraiton at each launch

		// the data in the configuration location will be lost

		Location configurationLocation = Platform.getConfigurationLocation();

		try {

			URL url = new URL(configurationLocation.getURL(), SDKCorePlugin.PLUGIN_ID);

			File configFolder = new File(url.getFile());

			if (!configFolder.exists()) {

				configFolder.mkdirs();

			}

		    File carbideSDKCacheFile = new File(configFolder, CARBIDE_SDK_CACHE_FILE_NAME);

		    if (!carbideSDKCacheFile.exists()){

		    	try {

		    	FileUtils.writeFileContents(carbideSDKCacheFile, EMPTY_STRING.toCharArray(), null);

		    	} catch (CoreException e){

		    		e.printStackTrace();

		    	}

		    }else if (carbideSDKCacheFile.length() > 0) {

			Document lastKnownDoc = docBuilder.parse(carbideSDKCacheFile);

			NodeIterator ni = XPathAPI.selectNodeIterator(lastKnownDoc, "/sdks/sdk");

			for (Node n = ni.nextNode(); n != null; n = ni.nextNode()) {

				// get the unique ID

				NamedNodeMap attribs = n.getAttributes();

				String id = attribs.getNamedItem(SDK_CACHE_ID_ATTRIB).getNodeValue();

				// get whether or not the SDK is enabled

				String sdkEnabled = "true";

				Node sdkEnabledItem = attribs.getNamedItem(SDK_CACHE_ENABLED_ATTRIB);

				if (sdkEnabledItem != null)

					sdkEnabled = sdkEnabledItem.getNodeValue();

				// get the os version

				String osVersion = "";

				Node osVersionItem = attribs.getNamedItem(SDK_CACHE_OS_VERSION_ATTRIB);

				if (osVersionItem != null)

					osVersion = osVersionItem.getNodeValue();

				// get the os branch

				String osBranch = "";

				Node osBranchItem = attribs.getNamedItem(SDK_CACHE_OS_BRANCH_ATTRIB);

				if (osBranchItem != null)

					osBranch = osBranchItem.getNodeValue();

				// get the sdk version

				String sdkVersion = "";

				Node sdkVersionItem = attribs.getNamedItem(SDK_CACHE_SDK_VERSION_ATTRIB);

				if (sdkVersionItem != null)

					sdkVersion = sdkVersionItem.getNodeValue();

				// get whether or not this SDK has been scanned

				String wasScanned = "false";

				Node sdkScannedItem = attribs.getNamedItem(SDK_SCANNED_FOR_PLUGINS);

				if (sdkScannedItem != null)

					wasScanned = sdkScannedItem.getNodeValue();

				ISymbianSDK sdk = getSDK(id, false);

				if (sdk != null){

					if (wasScanned.equalsIgnoreCase("true")){

						sdk.setPreviouslyScanned(true);

					} else {

						sdk.setPreviouslyScanned(false);

					}

					if (sdkEnabled.equalsIgnoreCase("true")){

						sdk.setEnabled(true);

					} else {

						sdk.setEnabled(false);

					}

					if (!osVersion.equals("")){

						if (Version.parseVersion(osVersion).getMajor() != 0){

							sdk.setOSVersion(Version.parseVersion(osVersion));

						}

					}

					if (!osBranch.equals("")){

						sdk.setOSSDKBranch(osBranch);

					}

					if (!sdkVersion.equals("")){

						if (Version.parseVersion(sdkVersion).getMajor() != 0){

							sdk.setSDKVersion(Version.parseVersion(sdkVersion));

						}

					}

				}

			} // for

		} 

	} catch (TransformerException e) {

	} catch (SAXException e) {

	} catch (IOException e) {

	}

	}

	public void updateCarbideSDKCache() {

		if (!Platform.isRunning())

			return;

		DocumentBuilder docBuilder = null;

		try {

			docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();