/*
 *  MicroEmulator
 *  Copyright (C) 2002 Bartek Teodorczyk <barteo@barteo.net>
 *
 *  It is licensed under the following two licenses as alternatives:
 *    1. GNU Lesser General Public License (the "LGPL") version 2.1 or any newer version
 *    2. Apache License (the "AL") Version 2.0
 *
 *  You may not use this file except in compliance with at least one of
 *  the above two licenses.
 *
 *  You may obtain a copy of the LGPL at
 *      http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt
 *
 *  You may obtain a copy of the AL at
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the LGPL or the AL for the specific language governing permissions and
 *  limitations.
 */

package org.microemu.app;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;
import java.util.Vector;

import nanoxml.XMLElement;
import nanoxml.XMLParseException;

import org.microemu.EmulatorContext;
import org.microemu.app.util.DeviceEntry;
import org.microemu.app.util.IOUtils;
import org.microemu.app.util.MIDletSystemProperties;
import org.microemu.app.util.MRUList;
import org.microemu.app.util.MidletURLReference;
import org.microemu.device.impl.DeviceImpl;
import org.microemu.device.impl.Rectangle;
import org.microemu.log.Logger;
import org.microemu.microedition.ImplementationInitialization;

public class Config {

	private static File meHome;

	/**
	 * emulatorID used for multiple instance of MicroEmulator, now redefine home
	 */
	private static String emulatorID;

	private static XMLElement configXml;

	private static DeviceEntry defaultDevice;

	private static EmulatorContext emulatorContext;

	private static MRUList urlsMRU = new MRUList(MidletURLReference.class, "midlet");

	private static File initMEHomePath() {
		try {
			File meHome = new File(System.getProperty("user.home") + "/.microemulator/");
			if (emulatorID != null) {
				return new File(meHome, emulatorID);
			} else {
				return meHome;
			}
		} catch (SecurityException e) {
			Logger.error("Cannot access user.home", e);
			return null;
		}
	}

	public static void loadConfig(DeviceEntry defaultDevice, EmulatorContext emulatorContext) {
		Config.defaultDevice = defaultDevice;
		Config.emulatorContext = emulatorContext;

		File configFile = new File(getConfigPath(), "config2.xml");
		try {
			if (configFile.exists()) {
				loadConfigFile("config2.xml");
			} else {
				configFile = new File(getConfigPath(), "config.xml");
				if (configFile.exists()) {
					// migrate from config.xml
					loadConfigFile("config.xml");

					for (Enumeration e = getDeviceEntries().elements(); e.hasMoreElements();) {
						DeviceEntry entry = (DeviceEntry) e.nextElement();
						if (!entry.canRemove()) {
							continue;
						}

						removeDeviceEntry(entry);
						File src = new File(getConfigPath(), entry.getFileName());
						File dst = File.createTempFile("dev", ".jar", getConfigPath());
						IOUtils.copyFile(src, dst);
						entry.setFileName(dst.getName());
						addDeviceEntry(entry);
					}
				} else {
					createDefaultConfigXml();
				}
				saveConfig();
			}
		} catch (IOException ex) {
			Logger.error(ex);
			createDefaultConfigXml();
		} finally {
			// Happens in webstart untrusted environment
			if (configXml == null) {
				createDefaultConfigXml();
			}
		}
		urlsMRU.read(configXml.getChildOrNew("files").getChildOrNew("recent"));
		initSystemProperties();
	}

	private static void loadConfigFile(String configFileName) throws IOException {
		File configFile = new File(getConfigPath(), configFileName);
		InputStream is = null;
		String xml = "";
		try {
			InputStream dis = new BufferedInputStream(is = new FileInputStream(configFile));
			while (dis.available() > 0) {
				byte[] b = new byte[dis.available()];
				dis.read(b);
				xml += new String(b);
			}
			configXml = new XMLElement();
			configXml.parseString(xml);
		} catch (XMLParseException e) {
			Logger.error(e);
			createDefaultConfigXml();
		} finally {
			IOUtils.closeQuietly(is);
		}
	}

	private static void createDefaultConfigXml() {
		configXml = new XMLElement();
		configXml.setName("config");
	}

	public static void saveConfig() {

		urlsMRU.save(configXml.getChildOrNew("files").getChildOrNew("recent"));

		File configFile = new File(getConfigPath(), "config2.xml");

		getConfigPath().mkdirs();
		FileWriter fw = null;
		try {
			fw = new FileWriter(configFile);
			configXml.write(fw);
			fw.close();
		} catch (IOException ex) {
			Logger.error(ex);
		} finally {
			IOUtils.closeQuietly(fw);
		}
	}

	static Map getExtensions() {
		Map extensions = new HashMap();
		XMLElement extensionsXml = configXml.getChild("extensions");
		if (extensionsXml == null) {
			return extensions;
		}
		for (Enumeration en = extensionsXml.enumerateChildren(); en.hasMoreElements();) {
			XMLElement extension = (XMLElement) en.nextElement();
			if (!extension.getName().equals("extension")) {
				continue;
			}
			String className = (String) extension.getChildString("className", null);
			if (className == null) {
				continue;
			}

			Map parameters = new HashMap();
			parameters.put(ImplementationInitialization.PARAM_EMULATOR_ID, Config.getEmulatorID());

			for (Enumeration een = extension.enumerateChildren(); een.hasMoreElements();) {
				XMLElement propXml = (XMLElement) een.nextElement();
				if (propXml.getName().equals("properties")) {
					for (Enumeration e_prop = propXml.enumerateChildren(); e_prop.hasMoreElements();) {
						XMLElement tmp_prop = (XMLElement) e_prop.nextElement();
						if (tmp_prop.getName().equals("property")) {
							parameters.put(tmp_prop.getStringAttribute("name"), tmp_prop.getStringAttribute("value"));
						}
					}
				}
			}

			extensions.put(className, parameters);
		}
		return extensions;
	}

	private static void initSystemProperties() {
		Map systemProperties = null;

		for (Enumeration e = configXml.enumerateChildren(); e.hasMoreElements();) {
			XMLElement tmp = (XMLElement) e.nextElement();
			if (tmp.getName().equals("system-properties")) {
				// Permits null values.
				systemProperties = new HashMap();
				for (Enumeration e_prop = tmp.enumerateChildren(); e_prop.hasMoreElements();) {
					XMLElement tmp_prop = (XMLElement) e_prop.nextElement();
					if (tmp_prop.getName().equals("system-property")) {
						systemProperties.put(tmp_prop.getStringAttribute("name"), tmp_prop.getStringAttribute("value"));
					}
				}
			}
		}

		// No <system-properties> in config2.xml
		if (systemProperties == null) {
			systemProperties = new Properties();
			systemProperties.put("microedition.configuration", "CLDC-1.0");
			systemProperties.put("microedition.profiles", "MIDP-2.0");
			// Ask avetana to ignore MIDP profiles and load JSR-82
			// implementation dll or so
			systemProperties.put("avetana.forceNativeLibrary", Boolean.TRUE.toString());

			XMLElement propertiesXml = configXml.getChildOrNew("system-properties");

			for (Iterator i = systemProperties.entrySet().iterator(); i.hasNext();) {
				Map.Entry e = (Map.Entry) i.next();
				XMLElement xmlProperty = propertiesXml.addChild("system-property");
				xmlProperty.setAttribute("value", (String) e.getValue());
				xmlProperty.setAttribute("name", (String) e.getKey());
			}

			saveConfig();
		}

		MIDletSystemProperties.setProperties(systemProperties);
	}

	public static File getConfigPath() {
		if (meHome == null) {
			meHome = initMEHomePath();
		}
		return meHome;
	}

	public static Vector getDeviceEntries() {
		Vector result = new Vector();

		if (defaultDevice == null) {
			defaultDevice = new DeviceEntry("Default device", null, DeviceImpl.DEFAULT_LOCATION, true, false);
		}
		defaultDevice.setDefaultDevice(true);
		result.add(defaultDevice);

		XMLElement devicesXml = configXml.getChild("devices");
		if (devicesXml == null) {
			return result;
		}

		for (Enumeration e_device = devicesXml.enumerateChildren(); e_device.hasMoreElements();) {
			XMLElement tmp_device = (XMLElement) e_device.nextElement();
			if (tmp_device.getName().equals("device")) {
				boolean devDefault = false;
				if (tmp_device.getStringAttribute("default") != null
						&& tmp_device.getStringAttribute("default").equals("true")) {
					devDefault = true;
					defaultDevice.setDefaultDevice(false);
				}
				String devName = tmp_device.getChildString("name", null);
				String devFile = tmp_device.getChildString("filename", null);
				String devClass = tmp_device.getChildString("class", null);
				String devDescriptor = tmp_device.getChildString("descriptor", null);
				;
				if (devDescriptor == null) {
					result.add(new DeviceEntry(devName, devFile, devDefault, devClass, emulatorContext));
				} else {
					result.add(new DeviceEntry(devName, devFile, devDescriptor, devDefault));
				}
			}
		}

		return result;
	}

	public static void addDeviceEntry(DeviceEntry entry) {
		for (Enumeration en = getDeviceEntries().elements(); en.hasMoreElements();) {
			DeviceEntry test = (DeviceEntry) en.nextElement();
			if (test.getDescriptorLocation().equals(entry.getDescriptorLocation())) {
				return;
			}
		}

		XMLElement devicesXml = configXml.getChildOrNew("devices");

		XMLElement deviceXml = devicesXml.addChild("device");
		if (entry.isDefaultDevice()) {
			deviceXml.setAttribute("default", "true");
		}
		deviceXml.addChild("name", entry.getName());
		deviceXml.addChild("filename", entry.getFileName());
		deviceXml.addChild("descriptor", entry.getDescriptorLocation());

		saveConfig();
	}

	public static void removeDeviceEntry(DeviceEntry entry) {
		XMLElement devicesXml = configXml.getChild("devices");
		if (devicesXml == null) {
			return;
		}

		for (Enumeration e_device = devicesXml.enumerateChildren(); e_device.hasMoreElements();) {
			XMLElement tmp_device = (XMLElement) e_device.nextElement();
			if (tmp_device.getName().equals("device")) {
				String testDescriptor = tmp_device.getChildString("descriptor", null);
				// this is needed by migration config.xml -> config2.xml
				if (testDescriptor == null) {
					devicesXml.removeChild(tmp_device);

					saveConfig();
					continue;
				}
				if (testDescriptor.equals(entry.getDescriptorLocation())) {
					devicesXml.removeChild(tmp_device);

					saveConfig();
					break;
				}
			}
		}
	}

	public static void changeDeviceEntry(DeviceEntry entry) {
		XMLElement devicesXml = configXml.getChild("devices");
		if (devicesXml == null) {
			return;
		}

		for (Enumeration e_device = devicesXml.enumerateChildren(); e_device.hasMoreElements();) {
			XMLElement tmp_device = (XMLElement) e_device.nextElement();
			if (tmp_device.getName().equals("device")) {
				String testDescriptor = tmp_device.getChildString("descriptor", null);
				if (testDescriptor.equals(entry.getDescriptorLocation())) {
					if (entry.isDefaultDevice()) {
						tmp_device.setAttribute("default", "true");
					} else {
						tmp_device.removeAttribute("default");
					}

					saveConfig();
					break;
				}
			}
		}
	}

	public static Rectangle getDeviceEntryDisplaySize(DeviceEntry entry) {
		XMLElement devicesXml = configXml.getChild("devices");

		if (devicesXml != null) {
			for (Enumeration e_device = devicesXml.enumerateChildren(); e_device.hasMoreElements();) {
				XMLElement tmp_device = (XMLElement) e_device.nextElement();
				if (tmp_device.getName().equals("device")) {
					String testDescriptor = tmp_device.getChildString("descriptor", null);
					if (testDescriptor.equals(entry.getDescriptorLocation())) {
						XMLElement rectangleXml = tmp_device.getChild("rectangle");
						if (rectangleXml != null) {
							Rectangle result = new Rectangle();
							result.x = rectangleXml.getChildInteger("x", -1);
							result.y = rectangleXml.getChildInteger("y", -1);
							result.width = rectangleXml.getChildInteger("width", -1);
							result.height = rectangleXml.getChildInteger("height", -1);
	
							return result;
						}
					}
				}
			}
		}

		return null;
	}

	public static void setDeviceEntryDisplaySize(DeviceEntry entry, Rectangle rect) {
		if (entry == null) {
			return;
		}
		XMLElement devicesXml = configXml.getChild("devices");
		if (devicesXml == null) {
			return;
		}

		for (Enumeration e_device = devicesXml.enumerateChildren(); e_device.hasMoreElements();) {
			XMLElement tmp_device = (XMLElement) e_device.nextElement();
			if (tmp_device.getName().equals("device")) {
				String testDescriptor = tmp_device.getChildString("descriptor", null);
				if (testDescriptor.equals(entry.getDescriptorLocation())) {
					XMLElement mainXml = tmp_device.getChildOrNew("rectangle");
					XMLElement xml = mainXml.getChildOrNew("x");
					xml.setContent(String.valueOf(rect.x));
					xml = mainXml.getChildOrNew("y");
					xml.setContent(String.valueOf(rect.y));
					xml = mainXml.getChildOrNew("width");
					xml.setContent(String.valueOf(rect.width));
					xml = mainXml.getChildOrNew("height");
					xml.setContent(String.valueOf(rect.height));

					saveConfig();
					break;
				}
			}
		}
	}

	public static String getRecordStoreManagerClassName() {
		XMLElement recordStoreManagerXml = configXml.getChild("recordStoreManager");
		if (recordStoreManagerXml == null) {
			return null;
		}

		return recordStoreManagerXml.getStringAttribute("class");
	}

	public static void setRecordStoreManagerClassName(String className) {
		XMLElement recordStoreManagerXml = configXml.getChildOrNew("recordStoreManager");
		recordStoreManagerXml.setAttribute("class", className);

		saveConfig();
	}

	public static boolean isLogConsoleLocationEnabled() {
		XMLElement logConsoleXml = configXml.getChild("logConsole");
		if (logConsoleXml == null) {
			return true;
		}

		return logConsoleXml.getBooleanAttribute("locationEnabled", true);
	}

	public static void setLogConsoleLocationEnabled(boolean state) {
		XMLElement logConsoleXml = configXml.getChildOrNew("logConsole");
		if (state) {
			logConsoleXml.setAttribute("locationEnabled", "true");
		} else {
			logConsoleXml.setAttribute("locationEnabled", "false");
		}

		saveConfig();
	}

	public static boolean isWindowOnStart(String name) {
		XMLElement windowsXml = configXml.getChild("windows");
		if (windowsXml == null) {
			return false;
		}

		XMLElement mainXml = windowsXml.getChild(name);
		if (mainXml == null) {
			return false;
		}

		String attr = mainXml.getStringAttribute("onstart", "false");
		if (attr.trim().toLowerCase().equals("true")) {
			return true;
		} else {
			return false;
		}
	}

	public static Rectangle getWindow(String name, Rectangle defaultWindow) {
		XMLElement windowsXml = configXml.getChild("windows");
		if (windowsXml == null) {
			return defaultWindow;
		}

		XMLElement mainXml = windowsXml.getChild(name);
		if (mainXml == null) {
			return defaultWindow;
		}

		Rectangle window = new Rectangle();
		window.x = mainXml.getChildInteger("x", defaultWindow.x);
		window.y = mainXml.getChildInteger("y", defaultWindow.y);
		window.width = mainXml.getChildInteger("width", defaultWindow.width);
		window.height = mainXml.getChildInteger("height", defaultWindow.height);

		return window;
	}

	public static void setWindow(String name, Rectangle window, boolean onStart) {
		XMLElement windowsXml = configXml.getChildOrNew("windows");
		XMLElement mainXml = windowsXml.getChildOrNew(name);
		if (onStart) {
			mainXml.setAttribute("onstart", "true");
		} else {
			mainXml.removeAttribute("onstart");
		}
		XMLElement xml = mainXml.getChildOrNew("x");
		xml.setContent(String.valueOf(window.x));
		xml = mainXml.getChildOrNew("y");
		xml.setContent(String.valueOf(window.y));
		xml = mainXml.getChildOrNew("width");
		xml.setContent(String.valueOf(window.width));
		xml = mainXml.getChildOrNew("height");
		xml.setContent(String.valueOf(window.height));

		saveConfig();
	}

	public static String getRecentDirectory(String key) {
		String defaultResult = ".";

		XMLElement filesXml = configXml.getChild("files");
		if (filesXml == null) {
			return defaultResult;
		}

		return filesXml.getChildString(key, defaultResult);
	}

	public static void setRecentDirectory(String key, String recentJadDirectory) {
		XMLElement filesXml = configXml.getChildOrNew("files");
		XMLElement recentJadDirectoryXml = filesXml.getChildOrNew(key);
		recentJadDirectoryXml.setContent(recentJadDirectory);

		saveConfig();
	}

	public static MRUList getUrlsMRU() {
		return urlsMRU;
	}

	public static String getEmulatorID() {
		return emulatorID;
	}

	public static void setEmulatorID(String emulatorID) {
		Config.emulatorID = emulatorID;
	}

}