/*
    * $HeadURL: $
    * $Date: $
    * $Revision: $
    * $Author: $
    * 
    * Copyright (c) 2005 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.mindtree.techworks.insight.preferences.xmlpersistence;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  
  import org.apache.xml.serialize.OutputFormat;
  import org.apache.xml.serialize.XMLSerializer;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  import org.xml.sax.SAXException;
  
  import com.mindtree.techworks.insight.preferences.PreferenceHandlerStoreException;
  import com.mindtree.techworks.insight.preferences.model.ListPreferenceAttribute;
  import com.mindtree.techworks.insight.preferences.model.Preference;
  import com.mindtree.techworks.insight.preferences.model.PreferenceAttribute;
  import com.mindtree.techworks.insight.preferences.model.PreferenceAttributeType;
  import com.mindtree.techworks.insight.preferences.util.Crypt;
  
  /**
   * This class saves the preferences into the preference file. No new top-level
   * preferences can be added, however child preferences and preference attributes
   * can be added to existing preferences. This implementation creates a DOM model
   * of the preferences, and stores the model.
   * 
   * @see com.mindtree.techworks.insight.preferences.xmlpersistence.XMLPreferenceDataHandler
   *      XMLPreferenceDataHandler
   * @author <a href="mailto:bindul_bhowmik@mintree.com">Bindul Bhowmik</a>
   * @version $Revision: 27 $ $Date: 2007-12-16 04:58:03 -0700 (Sun, 16 Dec 2007) $
   */
  public class XMLDOMPreferenceDataWriter implements PreferenceXMLNameConstants {
  
  	/**
  	 * The preference file to store.
  	 */
  	private String preferenceFile;
  
  	/**
  	 * Default Constructor which gets the list of preferences to store.
  	 * 
  	 * @param preferenceFile
  	 *            The preferenceFile to store.
  	 */
  	public XMLDOMPreferenceDataWriter (String preferenceFile) {
  
  		this.preferenceFile = preferenceFile;
  	}
  
  	/**
  	 * Writes the preferences to the store
  	 * 
  	 * @param preferences
  	 *            The list of preferences to store
  	 * @param outputFile
  	 *            The filt to which the preferences are to be stored
  	 * @throws PreferenceHandlerStoreException
  	 *             If the preference cannot be stored.
  	 */
  	public void writePreferences (List preferences, String outputFile)
  			throws PreferenceHandlerStoreException {
  
  		DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
  				.newInstance ();
  		documentBuilderFactory.setNamespaceAware (true);
  		try {
  			DocumentBuilder documentBuilder = documentBuilderFactory
  					.newDocumentBuilder ();
  			Document document = documentBuilder
 					.parse (new File (preferenceFile));
 			processPreferenceList (preferences, document);
 
 			// Write the DOM
 			OutputFormat format = new OutputFormat ();
 			format.setMethod ("xml");
 			format.setIndenting (true);
 			FileOutputStream fos = new FileOutputStream (outputFile);
 			XMLSerializer serializer = new XMLSerializer (format
 					.getEncodingInfo ().getWriter (fos), format);
 			serializer.asDOMSerializer ();
 			serializer.serialize (document);
 			try {
 				fos.close ();
 			} catch (IOException e) {
 				// Forget about it.
 			}
 			serializer = null;
 
 		} catch (ParserConfigurationException e) {
 			throw new PreferenceHandlerStoreException (
 					"Parser Configuration Exception in DocumentBuilder", e);
 		} catch (SAXException e) {
 			throw new PreferenceHandlerStoreException (
 					"SAX Exception in reading document", e);
 		} catch (IOException e) {
 			throw new PreferenceHandlerStoreException (
 					"IO Exception in reading document", e);
 		}
 
 	}
 
 	/**
 	 * Processes the list of preferences to store
 	 * 
 	 * @param preferences
 	 *            Preferences to store
 	 * @param document
 	 *            Document to which preferences are being written.
 	 */
 	private void processPreferenceList (List preferences, Document document) {
 
 		Element rootElement = document.getDocumentElement ();
 
 		NodeList nodeList = rootElement
 				.getElementsByTagNameNS (DEFAULT_NAMESPACE, XMLNAME_PREFERENCE);
 		int nodeCount = nodeList.getLength ();
 
 		Iterator preferencesIterator = preferences.iterator ();
 		while (preferencesIterator.hasNext ()) {
 			Preference preference = (Preference) preferencesIterator.next ();
 			String id = preference.getId ();
 
 			// Get the old element
 			Element oldElement = null;
 			for (int i = 0; i < nodeCount; i++ ) {
 				Element currentElement = (Element) nodeList.item (i);
 				if (id.equals (currentElement
 						.getAttribute (XMLNAME_PREFERENCE_ID))) {
 					oldElement = currentElement;
 					break;
 				}
 			}
 
 			// Replace the old element
 			if (null != oldElement) {
 				Element newElement = createPreferenceElement (preference,
 																document);
 				rootElement.replaceChild (newElement, oldElement);
 				if (preferencesIterator.hasNext ()) {
 					nodeList = rootElement
 							.getElementsByTagNameNS (DEFAULT_NAMESPACE,
 														XMLNAME_PREFERENCE);
 					nodeCount = nodeList.getLength ();
 				}
 			}
 		}
 
 	}
 
 	/**
 	 * Creates an element for a preference.
 	 * 
 	 * @param preference
 	 *            The preference for which the element is to be created.
 	 * @param document
 	 *            The document which is the parent of the element.
 	 * @return An element containing the current element
 	 */
 	private Element createPreferenceElement (Preference preference,
 			Document document) {
 
 		// Create the element
 		Element preferenceElement = document
 				.createElementNS (DEFAULT_NAMESPACE, XMLNAME_PREFERENCE);
 
 		// Populate the mandatory paramenters
 		preferenceElement.setAttribute (XMLNAME_PREFERENCE_ID, preference
 				.getId ());
 		preferenceElement.setAttribute (XMLNAME_PREFERENCE_NAME, preference
 				.getName ());
 		preferenceElement.setAttribute (XMLNAME_PREFERENCE_ISUSERMOD, String
 				.valueOf (preference.isUserModifiable ()));
 		preferenceElement.setAttribute (XMLNAME_PREFERENCE_ISAGGREGATED, String
 				.valueOf (preference.isAggregated ()));
 
 		// Populate the optional parameters
 		String displayClass = preference.getDisplayClass ();
 		if (null != displayClass && displayClass.length () > 0) {
 			preferenceElement.setAttribute (XMLNAME_PREFERENCE_DISPLAY_CLASS,
 											displayClass);
 		}
 
 		// Populate the Preference Attributes
 		Iterator preferenceAttrItr = preference.iteratePreferenceAttributes ();
 		while (preferenceAttrItr.hasNext ()) {
 			preferenceElement.appendChild (createPreferenceAttributeElement (
 								(PreferenceAttribute) preferenceAttrItr.next (),
 								document));
 		}
 
 		// Populate the child Preferences
 		Iterator childPreferenceItr = preference.iterateChildPreferences ();
 		while (null != childPreferenceItr && childPreferenceItr.hasNext ()) {
 			preferenceElement
 					.appendChild (createPreferenceElement (
 								(Preference) childPreferenceItr.next (),
 								document));
 		}
 
 		return preferenceElement;
 	}
 
 	/**
 	 * Creates a PreferenceAttribute element
 	 * 
 	 * @param attribute
 	 *            The preference attribute for which the element is required.
 	 * @param document
 	 *            The document which is the parent of the element.
 	 * @return An element for the preference attribute
 	 */
 	private Element createPreferenceAttributeElement (
 			PreferenceAttribute attribute, Document document) {
 
 		// Create the element
 		Element preferenceAttributeElement = document
 				.createElementNS (DEFAULT_NAMESPACE,
 									XMLNAME_PREFERENCE_ATTRIBUTE);
 
 		// Populate the attributes
 		preferenceAttributeElement.setAttribute (XMLNAME_PREFERENCE_ATT_ID,
 													attribute.getId ());
 		preferenceAttributeElement.setAttribute (XMLNAME_PREFERENCE_ATT_NAME,
 													attribute.getName ());
 
 		// Set the optional element
 		String defaultValue = attribute.getDefaultValue ();
 		if (null != defaultValue && defaultValue.length () > 0) {
 			int indexOfLT = defaultValue.indexOf ("<");
 			if (indexOfLT > -1 && defaultValue.indexOf (">", indexOfLT) > -1) {
 				preferenceAttributeElement.appendChild (createCDATAElement (
 										DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_DEFAULT_VALUE,
 										defaultValue,
 										document));
 			} else {
 				preferenceAttributeElement
 						.appendChild (createTextElement (
 										DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_DEFAULT_VALUE,
 										defaultValue,
 										document));
 			}
 		}
 
 		if (attribute.isPersistant ()) {
 			// This is the change for Enhancement Tracker #73 which requires
 			// data containing XML data to be stored as CDATA sections in the
 			// XML preference
 			String value = attribute.getValue ();
 			if(value == null)
 				value = "";
 			int indexOfLT = value.indexOf ("<");
 			if (indexOfLT > -1 && value.indexOf (">", indexOfLT) > -1) {
 				// Need to write this as CDATA
 				preferenceAttributeElement
 						.appendChild (createCDATAElement (
 										DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_VALUE,
 										(attribute.isEncrypted())?Crypt.encryptHexString(value):value, document));
 			} else {
 				preferenceAttributeElement
 						.appendChild (createTextElement (
 										DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_VALUE,
 										(attribute.isEncrypted())?Crypt.encryptHexString(value):value, document));
 			}
 		}
 
 		// Set the mandatory elements
 		preferenceAttributeElement
 				.appendChild (createTextElement (DEFAULT_NAMESPACE,
 									XMLNAME_PREF_ATT_TYPE,
 									attribute.getType ().getName (),
 									document));
 		if(attribute.isEncrypted()){
 			preferenceAttributeElement
 			.appendChild (createTextElement (DEFAULT_NAMESPACE,
 					XMLNAME_PREF_ATT_ENCRYPTED,
 					String.valueOf (attribute.isEncrypted ()),
 					document));
 		}
 		preferenceAttributeElement
 				.appendChild (createTextElement (DEFAULT_NAMESPACE,
 									XMLNAME_PREF_ATT_PERSISTANT,
 									String.valueOf (attribute.isPersistant ()),
 									document));
 		preferenceAttributeElement
 				.appendChild (createTextElement (DEFAULT_NAMESPACE,
 									XMLNAME_PREF_ATT_USER_MOD,
 									String.valueOf (
 									      attribute.isUserModifiable ()),
 									document));
 
 		// Check List preference Attribute
 		if (attribute.getType ().getType () == PreferenceAttributeType.LIST_TYPE
 				&& attribute instanceof ListPreferenceAttribute) {
 			preferenceAttributeElement
 					.setAttributeNS (XSI_NAMESPACE, XMLNAME_XSI_TYPE,
 										XMLNAME_LIST_PREFERENCE_ATTRIBUTE);
 			Element optionsElement = document
 					.createElementNS (DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_OPTIONS);
 
 			ListPreferenceAttribute listPreferenceAttribute = (ListPreferenceAttribute) attribute;
 			Iterator options = listPreferenceAttribute.iterateOptions ();
 			while (options.hasNext ()) {
 				String optionsValue = (String) options.next ();
 				int indexOfLT = optionsValue.indexOf ("<");
 				if (indexOfLT > -1
 						&& optionsValue.indexOf (">", indexOfLT) > -1) {
 					optionsElement
 							.appendChild (createCDATAElement (DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_OPTION_VAL,
 										optionsValue,
 										document));
 				} else {
 					optionsElement
 							.appendChild (createTextElement (DEFAULT_NAMESPACE,
 										XMLNAME_PREF_ATT_OPTION_VAL,
 										optionsValue,
 										document));
 				}
 			}
 
 			preferenceAttributeElement.appendChild (optionsElement);
 		}
 
 		return preferenceAttributeElement;
 	}
 
 	/**
 	 * Creates a text element with the name of the element and the value
 	 * supplied.
 	 * 
 	 * @param namespace
 	 *            The namespace of the element.
 	 * @param elementName
 	 *            The local name of the element.
 	 * @param value
 	 *            The value to be added to the element.
 	 * @param document
 	 *            The document which will be the parent of the element.
 	 * @return And element containing a text value
 	 */
 	private Element createTextElement (String namespace, String elementName,
 			String value, Document document) {
 
 		Element textElement = null;
 
 		if (null == namespace) {
 			textElement = document.createElement (elementName);
 		} else {
 			textElement = document.createElementNS (namespace, elementName);
 		}
 
 		textElement.appendChild (document.createTextNode (value));
 		return textElement;
 	}
 
 	/**
 	 * Creates a text element with the name of the element and the value
 	 * supplied.
 	 * 
 	 * @param namespace
 	 *            The namespace of the element.
 	 * @param elementName
 	 *            The local name of the element.
 	 * @param value
 	 *            The value to be added to the element as a CDATA section.
 	 * @param document
 	 *            The document which will be the parent of the element.
 	 * @return An element containing a CDATA section with the value provided.
 	 */
 	private Element createCDATAElement (String namespace, String elementName,
 			String value, Document document) {
 
 		Element cdataElement = null;
 
 		if (null == namespace) {
 			cdataElement = document.createElement (elementName);
 		} else {
 			cdataElement = document.createElementNS (namespace, elementName);
 		}
 
 		cdataElement.appendChild (document.createCDATASection (value));
 		return cdataElement;
 	}
 
 }