/*
    Copyright (C) 2007 Grid Systems, S.A.
   
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
   
    This library 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
   Lesser General Public License for more details.
  
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  */
  package com.gridsystems.nextgrid.api.pom.ref;
  
  import java.io.IOException;
  import java.io.StringReader;
  import java.io.StringWriter;
  
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerException;
  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.Node;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  
  /**
   * A DomReference instance wraps an XML DOM document.
   * <p>
   * There are mainly two use cases where a DomReference makes sense:
   *
   * <ul>
   *   <li><b>Local Inputs</b>:
   *     XML supports parameters of arbitrary complexity, from simple scalar
   *     values, to large complex documents.
   *   </li>
   *   <li><b>Local Service Outputs</b>:
   *     Custom local services (those that execute in the same process than the
   *     workflow enactor) may use DomReferences to publish their outputs.
   *   </li>
   * </ul>
   *
   * @author Rodrigo Ruiz
   */
  public class DomReference extends ReferenceSupport<Document> {
  
    /**
     * <code>serialVersionUID</code> attribute.
     */
    private static final long serialVersionUID = 1208741903142535808L;
  
    /**
     * Wrapped XML document.
     */
    private Document doc;
  
    /**
     * Creates a new empty instance.
     */
    public DomReference() {
    }
  
    /**
     * Creates a new instance.
     *
     * @param doc XML document to wrap
     */
    public DomReference(Document doc) {
      this.doc = doc;
    }
  
    /**
     * Creates a new instance.
     *
     * @param xml A string containing an XML document
     * @throws SAXException Parse error
     * @throws ParserConfigurationException Factory configuration error
     */
    public DomReference(String xml)
      throws SAXException, ParserConfigurationException {
      this(parseDoc(xml));
    }
  
    /**
     * {@inheritDoc}
     */
    public final Document getValue() {
     return this.doc;
   }
 
   /**
    * {@inheritDoc}
    */
   public final void setValue(Object value) {
     if (value == null) {
       this.doc = null;
     } else if (value instanceof Document) {
       this.doc = (Document)value;
     } else if (value instanceof CharSequence) {
       try {
         this.doc = parseDoc(value.toString());
       } catch (Exception e) {
         throw new ClassCastException("Invalid XML value");
       }
     } else {
       throw new ClassCastException("Cannot cast " + value.getClass() + " to XML");
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public Class<Document> getValueType() {
     return Document.class;
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean canCastTo(Class<?> type) {
     if (type == null) {
       return false;
     } else {
       return type.isAssignableFrom(Document.class)
           || type.isAssignableFrom(String.class)
           || type.isAssignableFrom(Node.class);
     }
   }
 
   /**
    * {@inheritDoc}
    */
   public boolean canCastFrom(Class<?> type) {
     return type.isAssignableFrom(CharSequence.class)
         || type.isAssignableFrom(Document.class);
   }
 
   /**
    * {@inheritDoc}
    */
   public Object castTo(Class<?> type) {
     if (type.isAssignableFrom(String.class)) {
       return xmlToString(this.doc);
     } else if (type.isAssignableFrom(Element.class)) {
       return this.doc.getDocumentElement();
     } else if (type.isAssignableFrom(Node.class)) {
       return this.doc;
     } else {
       throw new ClassCastException("Cannot cast XML to " + type);
     }
   }
   /**
    * Parses a string into a DOM document.
    *
    * @param xml The string containing the XML document to parse
    * @return The obtained document
    * @throws ParserConfigurationException Factory configuration error
    * @throws SAXException                 Parse error
    */
   protected static Document parseDoc(String xml)
     throws SAXException, ParserConfigurationException {
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     //factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
     factory.setNamespaceAware(true);
 
     InputSource is = new InputSource(new StringReader(xml));
     try {
       return factory.newDocumentBuilder().parse(is);
     } catch (IOException e) {
       // I/O exceptions should never happen while reading a string
       throw new Error(e);
     }
   }
 
   /**
    * Creates a new XML document instance.
    *
    * @return An XML document instance
    * @throws ParserConfigurationException Factory configuration error
    */
   protected static Document newDocument() throws ParserConfigurationException {
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
     return factory.newDocumentBuilder().newDocument();
   }
 
   /**
    * Gets a string representation of the given XML node.
    *
    * @param node A node
    * @return A String
    */
   protected static String xmlToString(Node node) {
     try {
       TransformerFactory factory = TransformerFactory.newInstance();
       Transformer transformer = factory.newTransformer();
 
       StringWriter writer = new StringWriter();
 
       transformer.transform(new DOMSource(node), new StreamResult(writer));
       return writer.getBuffer().toString();
     } catch (TransformerConfigurationException e) {
       e.printStackTrace();
     } catch (TransformerException e) {
       e.printStackTrace();
     }
     return null;
   }
 }