/*
* 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:
*
* Trace property file properties
*
*/
package com.nokia.tracebuilder.engine.propertyfile;

import java.util.HashMap;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import com.nokia.tracebuilder.engine.TraceBuilderConfiguration;
import com.nokia.tracebuilder.engine.TraceBuilderGlobals;
import com.nokia.tracebuilder.model.Trace;
import com.nokia.tracebuilder.model.TraceConstantTable;
import com.nokia.tracebuilder.model.TraceConstantTableEntry;
import com.nokia.tracebuilder.model.TraceGroup;
import com.nokia.tracebuilder.model.TraceModelListener;
import com.nokia.tracebuilder.model.TraceObject;
import com.nokia.tracebuilder.project.TraceProjectFile;

/**
 * Trace property file properties
 * 
 */
final class TracePropertyFile extends TraceProjectFile {

	/**
	 * Title shown in UI
	 */
	private static final String PROPERTY_FILE = Messages
			.getString("TracePropertyFile.Title"); //$NON-NLS-1$

	/**
	 * Property file document
	 */
	private Document document;

	/**
	 * Group properties
	 */
	private HashMap<String, TraceObjectPropertyListImpl> groupProperties;

	/**
	 * Trace properties
	 */
	private HashMap<String, TraceObjectPropertyListImpl> traceProperties;

	/**
	 * Creates a new property file
	 * 
	 * @param filePath
	 *            path to the file
	 * @param document
	 *            the document representing the property file
	 */
	TracePropertyFile(String filePath, Document document) {
		super(filePath, ""); //$NON-NLS-1$
		this.document = document;
	}

	/**
	 * Stores the group property cache. The properties are associated to groups
	 * when they are created.
	 * 
	 * @param groupProperties
	 *            properties for trace groups
	 * @param traceProperties
	 *            properties for traces
	 */
	void setProperties(
			HashMap<String, TraceObjectPropertyListImpl> groupProperties,
			HashMap<String, TraceObjectPropertyListImpl> traceProperties) {
		this.groupProperties = groupProperties;
		this.traceProperties = traceProperties;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracebuilder.project.TraceProjectFile#getFileExtension()
	 */
	@Override
	protected String getFileExtension() {
		return PropertyFileConstants.PROPERTY_FILE_NAME;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracebuilder.project.TraceProjectFile#getTitle()
	 */
	@Override
	public String getTitle() {
		return PROPERTY_FILE;
	}

	/**
	 * Gets the document
	 * 
	 * @return the document
	 */
	Document getDocument() {
		return document;
	}

	/**
	 * Adds an element to the property file document
	 * 
	 * @param object
	 *            the object to be added
	 */
	void addElement(TraceObject object) {
		if (object instanceof TraceConstantTableEntry) {
			addConstantTableEntry((TraceConstantTableEntry) object);
		} else if (object instanceof TraceConstantTable) {
			addConstantTable((TraceConstantTable) object);
		}
	}

	/**
	 * Removes an element from the property file document
	 * 
	 * @param object
	 *            the object to be added
	 */
	void removeElement(TraceObject object) {
		DocumentElementWrapper wrapper = object
				.getExtension(DocumentElementWrapper.class);
		if (wrapper != null) {
			Element e = wrapper.getElement();
			e.getParentNode().removeChild(e);
		} else {
			if (TraceBuilderConfiguration.ASSERTIONS_ENABLED) {
				TraceBuilderGlobals.getEvents().postAssertionFailed(
						"Element wrapper was missing", //$NON-NLS-1$
						null);
			}
		}
	}

	/**
	 * Updates an element from the property file document
	 * 
	 * @param object
	 *            the object to be updated
	 */
	void updateElement(TraceObject object) {
		DocumentElementWrapper wrapper = object
				.getExtension(DocumentElementWrapper.class);
		if (wrapper != null) {
			Element e = wrapper.getElement();
			if (object instanceof TraceConstantTableEntry) {
				updateConstantTableEntry(e, (TraceConstantTableEntry) object);
			} else if (object instanceof TraceConstantTable) {
				updateConstantTable(e, (TraceConstantTable) object);
			}
		} else {
			if (TraceBuilderConfiguration.ASSERTIONS_ENABLED) {
				TraceBuilderGlobals.getEvents().postAssertionFailed(
						"Element wrapper was missing", //$NON-NLS-1$
						null);
			}
		}
	}

	/**
	 * Adds a constant table to the document
	 * 
	 * @param table
	 *            the table
	 */
	void addConstantTable(TraceConstantTable table) {
		Element rootElement = getRoot();
		Element tableElement = document
				.createElement(PropertyFileConstants.ENUM_ELEMENT);
		updateConstantTable(tableElement, table);
		rootElement.appendChild(tableElement);
		// The element reference is stored into the model
		DocumentElementWrapper wrapper = new DocumentElementWrapper(
				tableElement);
		table.addExtension(wrapper);
		for (TraceConstantTableEntry entry : table) {
			addConstantTableEntry(tableElement, entry);
		}
	}

	/**
	 * Adds a constant table entry to the document
	 * 
	 * @param object
	 *            the table entry
	 */
	void addConstantTableEntry(TraceConstantTableEntry object) {
		Element tableElement = findNamedElement(object.getTable().getName(),
				PropertyFileConstants.ENUM_ELEMENT);
		if (tableElement != null) {
			addConstantTableEntry(tableElement, object);
		} else {
			TraceBuilderGlobals.getEvents().postAssertionFailed(
					"Enum element was missing from property file", //$NON-NLS-1$
					null);
		}
	}

	/**
	 * Adds a constant table entry to given element
	 * 
	 * @param tableElement
	 *            the constant table element
	 * @param entry
	 *            the constant table entry
	 */
	private void addConstantTableEntry(Element tableElement,
			TraceConstantTableEntry entry) {
		Element entryElement = document
				.createElement(PropertyFileConstants.VALUE_ELEMENT);
		updateConstantTableEntry(entryElement, entry);
		tableElement.appendChild(entryElement);
		// The element reference is stored into the model
		DocumentElementWrapper wrapper = new DocumentElementWrapper(
				entryElement);
		entry.addExtension(wrapper);
	}

	/**
	 * Updates a constant table
	 * 
	 * @param element
	 *            the element to be updated
	 * @param table
	 *            the constant table
	 */
	private void updateConstantTable(Element element, TraceConstantTable table) {
		// TODO: Table type and size are not supported
		element.setAttribute(PropertyFileConstants.NAME_ATTRIBUTE, table
				.getName());
	}

	/**
	 * Updates a constant table entry
	 * 
	 * @param element
	 *            the element to be updated
	 * @param entry
	 *            the table entry
	 */
	private void updateConstantTableEntry(Element element,
			TraceConstantTableEntry entry) {
		element.setAttribute(PropertyFileConstants.ID_ATTRIBUTE, String
				.valueOf(entry.getID()));
		element.setTextContent(entry.getName());
	}

	/**
	 * Finds a named element
	 * 
	 * @param name
	 *            the element name
	 * @param type
	 *            the element type
	 * @return the element
	 */
	private Element findNamedElement(String name, String type) {
		Element element = null;
		Element rootElement = getRoot();
		NodeList list = rootElement.getChildNodes();
		for (int i = 0; element == null && i < list.getLength(); i++) {
			Node node = list.item(i);
			if (node.getNodeType() == Node.ELEMENT_NODE) {
				if (node.getNodeName().equals(type)) {
					String nameAttr = ((Element) node)
							.getAttribute(PropertyFileConstants.NAME_ATTRIBUTE);
					if (nameAttr != null && nameAttr.equals(name)) {
						element = (Element) node;
					}
				}
			}
		}
		return element;
	}

	/**
	 * Gets the root element and creates if not found
	 * 
	 * @return the root
	 */
	private Element getRoot() {
		Element rootElement = PropertyFileUtils.findRoot(document);
		if (rootElement == null) {
			rootElement = document
					.createElement(PropertyFileConstants.ROOT_ELEMENT);
			document.appendChild(rootElement);
		}
		return rootElement;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracebuilder.project.TraceProjectFile#
	 *      objectCreationComplete(com.nokia.tracebuilder.model.TraceObject)
	 */
	@Override
	public void objectCreationComplete(TraceObject object) {
		super.objectCreationComplete(object);
		linkToProperty(object);
	}

	/**
	 * Links an object to properties
	 * 
	 * @param object
	 *            the object
	 */
	private void linkToProperty(TraceObject object) {
		// Links the cached property lists to objects
		if (object instanceof TraceGroup && groupProperties != null) {
			TraceObjectPropertyListImpl propertyList = groupProperties
					.get(object.getName());
			if (propertyList != null) {
				object.addExtension(propertyList);
			}
		} else if (object instanceof Trace && traceProperties != null) {
			TraceObjectPropertyListImpl propertyList = traceProperties
					.get(object.getName());
			if (propertyList != null) {
				object.addExtension(propertyList);
			}
		}
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracebuilder.project.TraceProjectFile#
	 *      objectRemoved(com.nokia.tracebuilder.model.TraceObject,
	 *      com.nokia.tracebuilder.model.TraceObject)
	 */
	@Override
	public void objectRemoved(TraceObject owner, TraceObject object) {
		super.objectRemoved(owner, object);
		// Removes the properties from the object
		object.removeExtensions(TraceObjectPropertyListImpl.class);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.nokia.tracebuilder.project.TraceProjectFile#
	 *      propertyUpdated(com.nokia.tracebuilder.model.TraceObject, int)
	 */
	@Override
	public void propertyUpdated(TraceObject object, int property) {
		super.propertyUpdated(object, property);
		if (property == TraceModelListener.NAME) {
			// Removes the old properties from the object and links to new ones
			object.removeExtensions(TraceObjectPropertyListImpl.class);
			linkToProperty(object);
		}
	}

}