/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common 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.
   *
   * Java-Common 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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.application.state.impl;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NamedNodeMap;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.xml.sax.InputSource;
  
  import com.cosylab.application.state.State;
  import com.cosylab.application.state.StateFactory;
  import com.cosylab.application.state.StateStorage;
  
  
  /**
   * This class is an implementation of the <code>StateStorage</code> that uses a
   * XML file to store the array of the <code>State</code> objects.
   *
   * @author dvitas
   */
  public class OldXMLStateStorage extends DefaultStateStorage
  {
  	/**
  	 * DOCUMENT ME!
  	 *
  	 * @param outStates DOCUMENT ME!
  	 * @param os DOCUMENT ME!
  	 *
  	 * @throws IOException DOCUMENT ME!
  	 */
  	public static final void storeStates(State[] outStates, OutputStream os)
  		throws IOException
  	{
  		storeStates(Arrays.asList(outStates), os);
  	}
  
  	private static final void storeStates(List outStates, OutputStream os)
  		throws IOException
  	{
  		try {
  			// setup XML
  			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  			factory.setValidating(false);
  			factory.setNamespaceAware(false);
  
  			DocumentBuilder builder = factory.newDocumentBuilder();
  			Document doc = builder.newDocument();
  			Element mainEl = doc.createElement("states");
  			doc.appendChild(mainEl);
  
  			for (int i = 0; i < outStates.size(); i++) {
  				State s = (State)outStates.get(i);
  				Element el = doc.createElement("state");
  				mainEl.appendChild(el);
  				saveState(doc, el, s);
  			}
  
  			if (os == null) {
  				return;
  			}
  
  			// use this instead of casting because it doesn't need to be the Crimson parser
  			TransformerFactory.newInstance().newTransformer().transform(new DOMSource(
  			        doc), new StreamResult(os));
  
  			//((XmlDocument)doc).write(os);
 			// close file buffers
 			os.flush();
 			os.close();
 		} catch (Exception e) {
 			e.printStackTrace();
 
 			IOException exc = new IOException("Unable to store state! "
 				    + e.getMessage());
 			exc.initCause(e);
 			throw exc;
 		}
 	}
 
 	private static final void readStateFromNode(Node node, State state)
 	{
 		NamedNodeMap nnm = node.getAttributes();
 
 		// load attributes
 		String key;
 
 		// load attributes
 		String value;
 
 		for (int i = 0; i < nnm.getLength(); i++) {
 			key = nnm.item(i).getNodeName();
 			value = nnm.item(i).getNodeValue();
 
 			//          if(key.startsWith("ID")) {
 			//              if(!value.startsWith("null"))
 			//                  state.setID(value);
 			//          }
 			//          else
 			state.putString(key, value);
 		}
 
 		// and childs if any
 		NodeList nl = node.getChildNodes();
 
 		for (int i = 0; i < nl.getLength(); i++) {
 			Node child = nl.item(i);
 
 			if (child instanceof Element) {
 				State s = state.createState(child.getNodeName());
 				readStateFromNode(child, s);
 			}
 		}
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param is DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 *
 	 * @throws IOException DOCUMENT ME!
 	 */
 	public static final State[] loadStates(InputSource is)
 		throws IOException
 	{
 		List retList = new ArrayList();
 		loadStates(is, retList);
 
 		State[] ret = new State[retList.size()];
 		retList.toArray(ret);
 
 		return ret;
 	}
 
 	private static final void loadStates(InputSource is, List retStates)
 		throws IOException
 	{
 		try {
 			if (is == null || (is.getByteStream() == null && is.getCharacterStream()==null)) {
 				return;
 			}
 
 			// setup DOM and parse 
 			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 			factory.setValidating(false);
 			factory.setNamespaceAware(false);
 
 			DocumentBuilder builder = factory.newDocumentBuilder();
 			Document doc = builder.parse(is);
 			NodeList nl = doc.getChildNodes();
 
 			// node "states" should be the first node in the doc
 			Node statesNode = null;
 
 			for (int i = 0; i < nl.getLength(); i++) {
 				if (nl.item(i).getNodeName() == "states") {
 					statesNode = nl.item(i);
 
 					break;
 				}
 			}
 
 			if (statesNode == null) {
 				throw new IOException("Unable to find node for states in "
 				    + is.toString());
 			}
 
 			// nl is now states so get its childs
 			nl = statesNode.getChildNodes();
 
 			for (int i = 0; i < nl.getLength(); i++) {
 				State state = StateFactory.createState();
 				Node node = nl.item(i);
 
 				if (!(node instanceof Element)) {
 					continue;
 				}
 
 				readStateFromNode(node, state);
 				retStates.add(state);
 			}
 		} catch (Exception e) {
 			IOException exc = new IOException("Unable to read state from "
 				    + is.getSystemId() + ": " + e.getMessage());
 			exc.initCause(e);
 			throw exc;
 		}
 	}
 
 	/**
 			             *
 			             */
 	public OldXMLStateStorage()
 	{
 		super();
 	}
 
 	/**
 	 * Creates a new XMLStateStorage object.
 	 *
 	 * @param ss DOCUMENT ME!
 	 */
 	public OldXMLStateStorage(StateStorage ss)
 	{
 		super(ss);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param is DOCUMENT ME!
 	 *
 	 * @throws IOException DOCUMENT ME!
 	 */
 	public void load(InputStream is) throws IOException
 	{
 		load(new InputSource(is));
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param is DOCUMENT ME!
 	 *
 	 * @throws IOException DOCUMENT ME!
 	 */
 	public void load(InputSource is) throws IOException
 	{
 		loadStates(is, states);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateStorage#load(java.io.InputStream)
 	 */
 	public void load(String filePath, String applicationName)
 		throws IOException
 	{
 		if (delegate != null) {
 			delegate.load(filePath, applicationName);
 			addAll(delegate.getStates());
 
 			return;
 		}
 
 		// get the InputStream if file exists
 		InputStream is = getInputStream(filePath, applicationName + ".xml");
 
 		if (is != null) {
 			try {
 				load(is);
 			} catch (IOException e) {
 				IOException ex = new IOException("Failed to load from file '"
 					    + filePath + "/" + applicationName + ".xml'");
 				ex.initCause(e);
 				throw ex;
 			}
 		}
 	}
 
 	private static final void saveState(Document doc, Element el, State s)
 	{
 		//el.setAttribute("ID", (s.getID()==null)?"null":s.getID());
 		Iterator iter = s.keySet().iterator();
 
 		while (iter.hasNext()) {
 			String key = (String)iter.next();
 			Object value = s.getObject(key);
 
 			if (value instanceof State) {
 				Element el1 = doc.createElement(key);
 				el.appendChild(el1);
 				saveState(doc, el1, (State)value);
 
 				continue;
 			}
 
 			String aa = String.valueOf(value);
 			//System.out.println("KEY "+key+ " VALUE "+value);
 			el.setAttribute(key, aa);
 		}
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateStorage#store(java.io.OutputStream)
 	 */
 	public void store(String filePath, String applicationName)
 		throws IOException
 	{
 		OutputStream os = getOutputStream(filePath, applicationName + ".xml");
 		store(os);
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.application.state.StateStorage#store(java.io.FileInputStream, java.lang.String)
 	 */
 	public void store(OutputStream os) throws IOException
 	{
 		storeStates(states, os);
 	}
 }
 
 /* __oOo__ */