/*

 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of "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:  Uses XML parser to read the manifest and created objects that

 *                represent the manifest.

 *

 */

package com.nokia.tools.themeinstaller.installationmanager;

import java.io.File;

import java.io.IOException;

import java.util.Enumeration;

import java.util.Vector;

import org.w3c.dom.Document;

import org.w3c.dom.NamedNodeMap;

import org.w3c.dom.Node;

import org.w3c.dom.NodeList;

import com.nokia.tools.themeinstaller.localisation.DTDReader;

import com.nokia.tools.themeinstaller.localisation.Localisation;

import com.nokia.tools.themeinstaller.localisation.LocalisationStore;

import com.nokia.tools.themeinstaller.odtconverter.ConverterProperties;

import com.nokia.tools.themeinstaller.odtconverter.IParseOperationListener;

import com.nokia.tools.themeinstaller.odtconverter.MimeTypeResolver;

import com.nokia.tools.themeinstaller.odtconverter.ThemeStatusResolver;

import com.nokia.tools.themeinstaller.xmlparser.XMLParser;

/**

 * Uses XML parser to read the manifest and created objects that represent the

 * manifest.

 */

public class ManifestFactory implements IParseOperationListener {

	// CONSTANTS

	// Manifest root node names

	private static final String MULTI_THEME = "datfiles";

	// Manifest element names

	private static final String APP_UID_ELEMENT = "AppUid";

	private static final String PROVIDER_UID_ELEMENT = "Provideruid";

	private static final String THEME_UID_ELEMENT = "ThemeUid";

	private static final String THEME_STATUS_ELEMENT = "ThemeStatus";

	private static final String THEME_FULL_NAME_ELEMENT = "ThemeFullName";

	private static final String THEME_SHORT_NAME_ELEMENT = "ThemeShortName";

	private static final String THEME_VERSION_ELEMENT = "ThemeVersion";

	private static final String FILE_XML_ELEMENT = "FileXML";

	private static final String FILE_CSS_ELEMENT = "FileCSS";

	private static final String FILE_DTD_ELEMENT = "FileDTD";

	private static final String FILE_DAT_ELEMENT = "FileDAT";

	private static final String FILE_RESOURCE_ELEMENT = "FileResource";

	private static final String CACHE_VALUE_MEMORY = "CacheMemory";

	private static final String LOCKING_ELEMENT = "Locking";

	private static final String LOCKED_VALUE = "Locked";

	private static final String CACHE_TYPE_ELEMENT = "CacheType";

	private static final String CACHE_VALUE_NONE = "CacheNone";

	private static final String CACHE_VALUE_FILE = "CacheFile";

	// Language element names

	private static final String LANGUAGE_SPECIFIC_ELEMENT = "LanguageSpecific";

	private static final int LANGUAGE_INDEPENDENT = 0;

	private static final int LANG_NOT_SET = -1;

	// Integer conversion radix

	private static final int RADIX = 16;

	// Screen size

	private static final int SCREEN_SIZE_X = 0;

	private static final int SCREEN_SIZE_Y = 0;

	// Resource file cache type

	public static int CACHE_TYPE_CACHE_NONE = 0;

	public static int CACHE_TYPE_CACHE_FILE = 1;

	public static int CACHE_TYPE_CACHE_MEMORY = 2;

	// Locking policy flag-definition from native, bit-masked.

	public static final int E_XN_UNLOCKED = 0x0000; // 0b0000000000000000,

	public static final int E_XN_LOCKED = 0x0001; // 0b0000000000000001,

	public static final String CURRENT_DIR = ".";

	// Property keys

	private static final String THEME_PROVIDER_KEY = "theme_provider_name";

	private static final String NAME_SPACE_KEY = "theme_name_space";

	// Lock for monitoring parse operation completions

	private Lock iLock;

	// Mime type resolver

	private MimeTypeResolver iMimeTypeResolver;

	// Converter properties

	private ConverterProperties iProperties;

	// Localisation settings

	private File iLocSettings;

	/**

	 * Constructor.

	 * 

	 * @param aLocSettings

	 *            Localisation settings

	 * @throws IOException

	 *             if converter properties can not be read

	 */

	public ManifestFactory(File aLocSettings) throws IOException {

		iLock = new Lock();

		iMimeTypeResolver = new MimeTypeResolver();

		iProperties = ConverterProperties.getInstance();

		iLocSettings = aLocSettings;

	}

	/**

	 * Parse a manifest and create the manifest object.

	 * 

	 * @param aFile

	 *            Manifest file

	 * @return Manifest instance

	 * @throws IOException

	 *             if the manifest can not be read

	 */

	public IThemeManifest createManifest(File aFile) throws IOException {

		// Read the manifest to the DOM document

		Document document = readManifest(aFile);

		IThemeManifest manifest = new ThemeManifest();

		// Set data directory that contains the data files of the theme

		if (aFile.getParent() == null) {

			manifest.setDataDir(CURRENT_DIR + File.separatorChar);

		} else {

			manifest.setDataDir(aFile.getParent() + File.separatorChar);

		}

		// Parse manifest contents

		String rootNodeName = document.getFirstChild().getNodeName();

		if (rootNodeName == MULTI_THEME) {

			// Multi theme manifest

			parseMultiThemeManifest(document, manifest);

		} else {

			// Single theme manifest

			parseManifest(document, manifest);

			parseLanguageSpecificData(document, manifest);

			parseResources(document, manifest, LANGUAGE_INDEPENDENT);

		}

		return manifest;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @seecom.nokia.tools.themeinstaller.odtconverter.IParseOperationListener#

	 * parseOperationCompleted(int, java.lang.String)

	 */

	public void parseOperationCompleted(int aErr, String aReason) {

		iLock.unLock();

		if (aErr != 0) {

			throw new IllegalArgumentException(

					"Theme manifest parsing failed: " + aErr + ", " + aReason);

		}

	}

	/**

	 * Parse the manifest file.

	 * 

	 * @param aManifest

	 *            Manifest file

	 * @return DOM Document of the manifest

	 */

	private Document readManifest(File aManifest) {

		// Parse the manifest

		XMLParser parser = new XMLParser(aManifest.getPath());

		parser.addListener(this);

		try {

			parser.parse();

		} catch (Exception e) {

			throw new IllegalArgumentException(

					"Theme manifest parsing failed: " + e.getMessage());

		}

		// Wait for the operation completion

		iLock.lock();

		// Return the document that was formed

		return parser.getDOMDocument();

	}

	/**

	 * Parses a multi theme manifest from DOM to the manifest instance.

	 * 

	 * @param aDocument

	 *            DOM Document containing the manifest data (source)

	 * @param aManifest

	 *            Theme manifest (destination)

	 */

	private void parseMultiThemeManifest(Document aDocument,

			IThemeManifest aManifest) {

		// Add DAT file names

		NodeList nodes = aDocument.getElementsByTagName(FILE_DAT_ELEMENT);

		Node node = null;

		for (int i = 0; i < nodes.getLength(); i++) {

			node = nodes.item(i);

			aManifest.addManifestFile(aManifest.getDataDir()

					+ node.getTextContent());

		}

	}

	/**

	 * Parses a manifest from DOM to the manifest instance.

	 * 

	 * @param aDocument

	 *            DOM Document containing the manifest data (source)

	 * @param aManifest

	 *            Theme manifest (destination)

	 */

	private void parseManifest(Document aDocument, IThemeManifest aManifest) {

		// Set application uid

		NodeList nodes = aDocument.getElementsByTagName(APP_UID_ELEMENT);

		Node node = checkOneNode(nodes, APP_UID_ELEMENT);

		if (node != null)

			aManifest.setApplicationUid(Long.valueOf(node.getTextContent(),

					RADIX));

		// Set provider uid

		nodes = aDocument.getElementsByTagName(PROVIDER_UID_ELEMENT);

		node = checkOneNode(nodes, PROVIDER_UID_ELEMENT);

		if (node != null)

			aManifest

					.setProviderUid(Long.valueOf(node.getTextContent(), RADIX));

		// Set theme uid

		nodes = aDocument.getElementsByTagName(THEME_UID_ELEMENT);

		node = checkOneNode(nodes, THEME_UID_ELEMENT);

		if (node != null)

			aManifest.setThemeUid(Long.valueOf(node.getTextContent(), RADIX));

		// Set name space

		aManifest.setNameSpace(iProperties.getProperty(NAME_SPACE_KEY));

		// Set theme provider name

		aManifest.setProviderName(iProperties.getProperty(THEME_PROVIDER_KEY));

		// Set default theme full name before localization

		nodes = aDocument.getElementsByTagName(THEME_FULL_NAME_ELEMENT);

		if (nodes.getLength() > 0) {

			// Get first theme name that is found (for a default name).

			// The used name is specified in the language specific data.

			aManifest.setThemeFullName(nodes.item(0).getTextContent());

		}

		// else

		// {

		// throw new IllegalArgumentException(

		// "Syntax error in manifest file: theme full name not found" );

		// }

		// Set theme short name

		nodes = aDocument.getElementsByTagName(THEME_SHORT_NAME_ELEMENT);

		node = checkOneNode(nodes, THEME_SHORT_NAME_ELEMENT);

		if (node != null)

			aManifest.setThemeShortName(node.getTextContent());

		// Set theme version

		nodes = aDocument.getElementsByTagName(THEME_VERSION_ELEMENT);

		node = checkOneNode(nodes, THEME_VERSION_ELEMENT);

		if (node != null)

			aManifest.setThemeVersion(node.getTextContent());

		// Screen size, not used in Xuikon at the moment

		aManifest.setScreenSizeX(new Integer(SCREEN_SIZE_X));

		aManifest.setScreenSizeY(new Integer(SCREEN_SIZE_Y));

		// Resolve theme status

		nodes = aDocument.getElementsByTagName(THEME_STATUS_ELEMENT);

		int flags = ThemeStatusResolver.E_XN_THEME_STATUS_NONE;

		for (int i = 0; i < nodes.getLength(); i++) {

			node = nodes.item(i);

			flags |= ThemeStatusResolver.getValue(node.getTextContent())

					.intValue();

			if (node.getTextContent().equals(

					ThemeStatusResolver.THEME_STATUS_LICENCEE_RESTORABLE)) {

				// This theme is restored when licensee default theme is

				// restored.

				// When using this flag, the ThemeStatusLicenceeDefault-flag

				// must be activated.

				flags |= ThemeStatusResolver.E_XN_THEME_STATUS_LICENCEE_DEFAULT;

			}

		}

		aManifest.setThemeStatus(new Integer(flags));

		// Set XML file name

		NodeList files = aDocument.getElementsByTagName(FILE_XML_ELEMENT);

		node = checkOneNode(files, FILE_XML_ELEMENT);

		if (node != null)

			aManifest.setXMLFile(node.getTextContent());

		// Set CSS file name

		files = aDocument.getElementsByTagName(FILE_CSS_ELEMENT);

		node = checkMaxOneLanguageIndependentNode(files);

		if (node != null) {

			aManifest.setCSSFile(node.getTextContent());

		}

		// Set DTD file name

		files = aDocument.getElementsByTagName(FILE_DTD_ELEMENT);

		node = checkMaxOneLanguageIndependentNode(files);

		if (node != null) {

			aManifest.setDTDFile(node.getTextContent());

		}

	}

	/**

	 * Parses language specific data in the manifest.

	 * 

	 * @param aDocument

	 *            DOM Document containing the manifest data (source)

	 * @param aManifest

	 *            Theme manifest (destination)

	 * @throws IOException

	 *             if the manifest can not be parsed

	 */

	private void parseLanguageSpecificData(Document aDocument,

			IThemeManifest aManifest) throws IOException {

		// Get languages

		NodeList languages = aDocument

				.getElementsByTagName(LANGUAGE_SPECIFIC_ELEMENT);

		Node langSpecificNode = null;

		NamedNodeMap langAttr = null;

		NodeList langSpecificChildren = null;

		Node langSpecificChild = null;

		NodeList resources = aDocument

				.getElementsByTagName(FILE_RESOURCE_ELEMENT);

		Vector langResources = null;

		// Process all languages

		for (int i = 0; i < languages.getLength(); i++) {

			// Language specific data

			int langId = LANG_NOT_SET;

			String extDtd = null;

			String extCss = null;

			String themeFullName = null;

			// Take a LanguageSpecific node

			langSpecificNode = languages.item(i);

			// There should be only one language for each LanguageSpecific node

			langAttr = langSpecificNode.getAttributes();

			if (langAttr.getLength() == 1) {

				String langStr = langAttr.item(0).getNodeValue();

				langId = Integer.valueOf(langStr).intValue();

			}

			langSpecificChildren = langSpecificNode.getChildNodes();

			// Read language specific elements

			String nodeName = null;

			for (int j = 0; j < langSpecificChildren.getLength(); j++) {

				langSpecificChild = langSpecificChildren.item(j);

				nodeName = langSpecificChild.getNodeName();

				// Language specific DTD file name

				if (FILE_DTD_ELEMENT.equals(nodeName)) {

					extDtd = langSpecificChild.getTextContent();

				}

				// Language specific CSS

				else if (FILE_CSS_ELEMENT.equals(nodeName)) {

					extCss = langSpecificChild.getTextContent();

				}

				// Localized theme full name

				else if (THEME_FULL_NAME_ELEMENT.equals(nodeName)) {

					themeFullName = langSpecificChild.getTextContent();

				}

			}

			// Parse language specific resources

			langResources = parseResources(aManifest, resources, langId);

			// Verify that mandatory fields language id and DTD file were set

			if (langId == LANG_NOT_SET || extDtd == null) {

				throw new IllegalArgumentException(

						"Syntax error in language specifications of the manifest");

			}

			// Find the DTD file for reading the localised theme full name

			File dtd = null;

			if (iLocSettings != null) {

				// Use enhanced localisation: Find the DTD file

				LocalisationStore ls = LocalisationStore

						.getInstance(iLocSettings);

				Localisation l = ls.getLocalisation(aManifest

						.getApplicationUid().longValue(), aManifest

						.getProviderUid().longValue(), aManifest.getThemeUid()

						.longValue());

				dtd = l.findDTD(extDtd);

			} else {

				dtd = new File(aManifest.getDataDir() + extDtd);

			}

			// Resolve localised theme full name, if specified

			themeFullName = DTDReader.readEntity(dtd, themeFullName);

			// Create new language specific data and add it to the languages

			// list

			LanguageSpecificData language = new LanguageSpecificData(

					new Integer(langId), extDtd, extCss, themeFullName,

					langResources);

			aManifest.addLanguage(language);

		}

		// Unlocalized variant (causes the .o0000 file to be generated)

		LanguageSpecificData language = new LanguageSpecificData(new Integer(

				LANGUAGE_INDEPENDENT), null, null, null, null);

		aManifest.addLanguage(language);

	}

	/**

	 * Parses resource data in the manifest.

	 * 

	 * @param aDocument

	 *            DOM Document containing the manifest data (source)

	 * @param aManifest

	 *            Theme manifest (destination)

	 * @param aLanguageId

	 *            Id of the language of which resources will be parsed. On 0,

	 *            only language independent resources are parsed.

	 */

	private void parseResources(Document aDocument, IThemeManifest aManifest,

			int aLanguageId) {

		// Do the parsing operation

		NodeList resourceList = aDocument

				.getElementsByTagName(FILE_RESOURCE_ELEMENT);

		Vector resources = parseResources(aManifest, resourceList, aLanguageId);

		// Add resources to the manifest

		Enumeration e = resources.elements();

		while (e.hasMoreElements()) {

			aManifest.addResource((ThemeResource) e.nextElement());

		}

	}

	/**

	 * Parses resource files defined in the manifest. Resources must be parsed

	 * after the rest of the manifest is parsed. Theme status is used here for

	 * determining locking policies.

	 * 

	 * @param aManifest

	 *            Theme manifest

	 * @param aNodeList

	 *            Node list to parse

	 * @param aLanguageId

	 *            Id of the language of which resources will be parsed. On 0,

	 *            only language independent resources are parsed.

	 */

	private Vector parseResources(IThemeManifest aManifest, NodeList aNodeList,

			int aLanguageId) {

		Vector result = new Vector();

		Node node = null;

		// Browse through all resources in the list

		int count = aNodeList.getLength();

		for (int i = 0; i < count; i++) {

			node = aNodeList.item(i);

			String filename = node.getTextContent();

			NamedNodeMap attributes = node.getAttributes();

			int cacheType = CACHE_TYPE_CACHE_NONE;

			int lockingPolicy = E_XN_UNLOCKED;

			// Set cache type

			Node cacheTypeNode = attributes.getNamedItem(CACHE_TYPE_ELEMENT);

			if ((cacheTypeNode == null)

					|| cacheTypeNode.getTextContent().equals(CACHE_VALUE_NONE)) {

				cacheType = CACHE_TYPE_CACHE_NONE;

			} else if (cacheTypeNode.getTextContent().equals(CACHE_VALUE_FILE)) {

				cacheType = CACHE_TYPE_CACHE_FILE;

			} else if (cacheTypeNode.getTextContent()

					.equals(CACHE_VALUE_MEMORY)) {

				cacheType = CACHE_TYPE_CACHE_MEMORY;

			} else {

				throw new IllegalArgumentException(

						"Syntax error in the manifest, can not resolve resource cache type");

			}

			// Set locking policy

			Node locking = attributes.getNamedItem(LOCKING_ELEMENT);

			if (locking != null

					&& locking.getTextContent().equals(LOCKED_VALUE)) {

				lockingPolicy = E_XN_LOCKED;

			}

			// If EXnThemeStatusLicenceeDefault flag is set, locking policy is

			// E_XN_LOCKED

			if ((aManifest.getThemeStatus().intValue() & ThemeStatusResolver.E_XN_THEME_STATUS_LICENCEE_DEFAULT) != 0) {

				lockingPolicy = E_XN_LOCKED;

			}

			// Resolve mime type

			String mime = iMimeTypeResolver.getMimeType(filename);

			// Resolve resource type

			int resourceType = iMimeTypeResolver.getResourceType(filename);

			// Verify language id

			Node parent = node.getParentNode();

			NamedNodeMap attr = parent.getAttributes();

			// Language specific resources

			if (attr.getLength() == 1

					&& aLanguageId == Integer.valueOf(

							attr.item(0).getNodeValue()).intValue()) {

				ThemeResource resource = new ThemeResource(filename, cacheType,

						lockingPolicy, aManifest.getNameSpace(), resourceType,

						mime);

				result.add(resource);