package javaxt.xml;

import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import org.w3c.dom.*;
import javax.xml.parsers.*;

//imports used to transform xml
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

//******************************************************************************
//**  DOM Utilities
//******************************************************************************
/**
 *   Provides basic utilities to simplify loading and parsing xml
 *
 ******************************************************************************/

public class DOM {

  //**************************************************************************
  //** Private Constructor
  //**************************************************************************
  /**  Defeats Instantiation */

    private DOM() {
    }


  //**************************************************************************
  //** createDocument
  //**************************************************************************
  /**  Used to create a DOM document from a URL. */

    public static Document createDocument(java.net.URL url){
        return new javaxt.http.Request(url).getResponse().getXML();
    }


  //**************************************************************************
  //** createDocument
  //**************************************************************************
  /** Used to create a DOM document from a java.io.File. Returns null if the
   *  file cannot be serialized to XML.
   */
    public static Document createDocument(java.io.File file){
        if (file.exists()==false) return null;
        try{
            return createDocument(new java.io.FileInputStream(file));
        }
        catch(Exception e){
            //e.printStackTrace();
            return null;
        }
    }


  //**************************************************************************
  //** createDocument
  //**************************************************************************
  /** Used to create a DOM document from a String. Returns null if the string
   *  is invalid.
   */
    public static Document createDocument(String xml){
        if (xml==null) return null;

        xml = xml.trim();
        String encoding = "UTF-8";

        try{
            String xmlHeader = xml.substring(xml.indexOf("<?"), xml.indexOf("?>"));
            if (xmlHeader.contains(" encoding")){
                encoding = xmlHeader.substring(xmlHeader.indexOf(" encoding")+" encoding".length());
                encoding = encoding.substring(encoding.indexOf("=")+1);
                while(encoding.substring(0, 1).equals(" ")){
                    encoding = encoding.substring(1);
                }

                String firstChar = encoding.substring(0, 1);
                if (firstChar.equals("\"") || firstChar.equals("'")){
                    encoding = encoding.substring(1);
                    encoding = encoding.substring(0, encoding.indexOf(firstChar)).trim();
                }
                else{
                    encoding = encoding.substring(0, encoding.indexOf(" ")).trim();
                }

            }
        }
        catch(Exception e){}

        return createDocument(xml, encoding);
    }



    public static Document createDocument(String xml, String charsetName){
        xml = xml.trim();
        try{
            return createDocument(new ByteArrayInputStream(xml.getBytes(charsetName)));
        }
        catch(Exception e){
            //e.printStackTrace();
            return createDocument(new ByteArrayInputStream(xml.getBytes()));
        }
    }


  //**************************************************************************
  //** createDocument
  //**************************************************************************
  /**  Used to create a DOM document from an InputStream. */

    public static Document createDocument(InputStream is){
        try{
            DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder builder = builderFactory.newDocumentBuilder();
            return builder.parse(is);
        }
        catch(Exception e){
            //e.printStackTrace();
            return null;
        }
    }



  //**************************************************************************
  //** getOuterNode
  //**************************************************************************
  /** Returns the outer node for a given xml document.
   *  @param xml A org.w3c.dom.Document
   */
    public static Node getOuterNode(Document xml){
        if (xml==null) return null;
        NodeList OuterNodes = xml.getChildNodes();
        for (int i=0; i<OuterNodes.getLength(); i++ ) {
             if (OuterNodes.item(i).getNodeType() == 1){
                 return OuterNodes.item(i);
             }
        }
        return null;
    }


  //**************************************************************************
  //** equals
  //**************************************************************************
  /** Used to compare two XML documents by performing a raw string comparison.
   */
    public static boolean equals(Document xml, Document xml2){
        if (xml==null && xml2==null) return true;
        if (xml!=null && xml2==null) return false;
        if (xml==null && xml2!=null) return false;
        return getText(xml).equals(getText(xml2));
    }


  //**************************************************************************
  //** getText
  //**************************************************************************
  /** Converts a DOM Document to a String
   *  @param xml A org.w3c.dom.Document
   */
    public static String getText(Document xml){

        try{
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer();
            DOMSource source = new DOMSource(xml);
            ByteArrayOutputStream bas = new ByteArrayOutputStream();
            StreamResult result = new StreamResult(bas);
            transformer.transform(source, result);
            String encoding = xml.getXmlEncoding();
            if (encoding!=null) return bas.toString(encoding);
            else return bas.toString();
        }
        catch (Exception e){
            //System.out.println(e.toString());
            return "";
        }
    }


  //**************************************************************************
  //** getText
  //**************************************************************************
  /** Converts a NodeList to a String */

    public static String getText(NodeList nodeList){
        StringBuffer ret = new StringBuffer();
        for (int i=0; i<nodeList.getLength(); i++ ) {
            ret.append(getText(nodeList.item(i)));
        }
        return ret.toString();
    }


  //**************************************************************************
  //** getText
  //**************************************************************************
  /** Converts a Node to a String */

    public static String getText(Node node){
         StringBuffer ret = new StringBuffer();
         if (node.getNodeType()==1){

             if (hasChildren(node)){
                 ret.append(getNodeValue(node));
             }
             else{
                 ret.append("<" + node.getNodeName() + getAttributes(node) + ">");
                 ret.append(getNodeValue(node));
                 ret.append("</" + node.getNodeName() + ">");
             }
         }
         return ret.toString();
    }


  //**************************************************************************
  //** getAttributes
  //**************************************************************************
  /** Used to retrieve all of the attributes for a given node.   */

    private static String getAttributes(Node node){
        if (node==null) return "";
        NamedNodeMap attr = node.getAttributes();
        String Attributes = "";
        if (attr!=null){
            for (int j=0; j<attr.getLength(); j++){
                 String name = attr.item(j).getNodeName();
                 String value = attr.item(j).getTextContent();
                 if (value==null) value = attr.item(j).getNodeValue();
                 if (value==null) value = "";
                 //System.out.println(name + "=" + attr.item(j).getNodeValue());
                 Attributes += " " + name + "=\"" + value + "\"";
            }
        }
        return Attributes;
    }


  //**************************************************************************
  //** hasChildren
  //**************************************************************************
  /** Used to determine whether a given node has any children. Differs from the
   *  native DOM implementation in that this function only considers child
   *  nodes that have a node type value equal to 1.
   */
    public static boolean hasChildren(Node node){

        NodeList nodeList = node.getChildNodes();
        for (int i=0; i<nodeList.getLength(); i++ ) {
            if (nodeList.item(i).getNodeType()==1){
                return true;
            }
        }
        return false;
    }


  //**************************************************************************
  //** getAttributeValue
  //**************************************************************************
  /** Used to return the value of a given node attribute. The search is case
   *  insensitive. If no match is found, returns an empty string.
   */
    public static String getAttributeValue(NamedNodeMap attrCollection, String attrName){

        if (attrCollection!=null){
            for (int i=0; i < attrCollection.getLength(); i++ ) {
                Node node = attrCollection.item(i);
                if (node.getNodeName().equalsIgnoreCase(attrName)) {
                    return node.getNodeValue();
                }
            }
        }
        return "";
    }


  //**************************************************************************
  //** getAttributeValue
  //**************************************************************************
  /** Used to return the value of a given node attribute. The search is case
   *  insensitive. If no match is found, returns an empty string.
   */
    public static String getAttributeValue(Node node, String attrName){
        return getAttributeValue(node.getAttributes(), attrName);
    }


  //**************************************************************************
  //** setAttributeValue
  //**************************************************************************
  /** Used to create or update an attribute.
   */
    public static void setAttributeValue(Node node, String attrName, String attrValue){

        if (node==null) return;

        try{
            ((Element)node).setAttribute(attrName, attrValue);
        }
        catch(Exception e){

          //Apparently some nodes can't be cast to an Element so we can try
          //to update the node's attribute collection.
            try{

                NamedNodeMap attrCollection = node.getAttributes();
                for (int i=0; i<attrCollection.getLength(); i++ ) {
                    org.w3c.dom.Node attribute = attrCollection.item(i);
                    if (attribute.getNodeName().equals(attrName)) {
                        attribute.setNodeValue(attrValue);
                        return;
                    }
                }

                //TODO: If we're still here, create new attribute
            }
            catch(Exception ex){
            }
        }
    }



  //**************************************************************************
  //** getNodeValue
  //**************************************************************************
  /** Returns the value of a given node as text. If the node has children, the
   *  method will return an xml fragment which will include the input node as
   *  the outer node. This is a legacy feature which should be deprecated over
   *  time.
   */
    public static String getNodeValue(Node node){

        String nodeValue = "";

        if (hasChildren(node)) {

            StringBuffer xmlTree = new StringBuffer();
            traverse(node, xmlTree);
            nodeValue = xmlTree.toString();

        }
        else{
            nodeValue = node.getTextContent();
        }

        if (nodeValue == null){
            return "";
        }
        else{
            return nodeValue;
        }
    }

    private static void traverse(Node tree, StringBuffer xmlTree){
        if (tree.getNodeType()==1){
            String Attributes = getAttributes(tree);
            xmlTree.append("<" + tree.getNodeName() + Attributes + ">");
            if (hasChildren(tree)) {

                NodeList xmlNodeList = tree.getChildNodes();
                for (int i=0; i<xmlNodeList.getLength(); i++){
                    traverse(xmlNodeList.item(i), xmlTree);
                }

            }
            else{

                String nodeValue = tree.getTextContent();
                if (nodeValue == null){
                    nodeValue = "";
                }

                xmlTree.append(nodeValue);
            }

            xmlTree.append("</" + tree.getNodeName() + ">");
        }
    }


  //**************************************************************************
  //** getDocumentAttributes
  //**************************************************************************
  /**
   *  @param xml A org.w3c.dom.Document
   */
    public static NamedNodeMap getDocumentAttributes(Document xml){
        NodeList Definitions = xml.getChildNodes();
        for (int i=0; i<Definitions.getLength(); i++ ) {
             if (Definitions.item(i).getNodeType() == 1){
                 return Definitions.item(i).getAttributes();
             }
        }
        return null;
    }


  //**************************************************************************
  //** getTargetNameSpace
  //**************************************************************************
  /** Returns the "targetNamespace" for a given xml document.
   *  @param xml A org.w3c.dom.Document
   */
    public static String getTargetNameSpace(Document xml){
        NamedNodeMap attr = getDocumentAttributes(xml);
        return getAttributeValue(attr,"targetNamespace");
    }


  //**************************************************************************
  //** getNameSpaces
  //**************************************************************************
  /** Returns a hashmap with all the namespaces found in a given xml document.
   *  The hashmap key is the namespace prefix and the corresponding value is
   *  the namespace url.
   *
   *  @param xml A org.w3c.dom.Document
   */
    public static java.util.HashMap<String, String> getNameSpaces(Document xml){
        java.util.HashMap<String, String> namespaces = new java.util.HashMap<String, String>();
        getNameSpaces(getOuterNode(xml), namespaces);
        return namespaces;
    }

    private static void getNameSpaces(Node node, java.util.HashMap<String, String> namespaces){
        if (node.getNodeType()==1){

            NamedNodeMap attr = node.getAttributes();
            if (attr!=null){
                for (int j=0; j<attr.getLength(); j++){
                     String name = attr.item(j).getNodeName();
                     String value = attr.item(j).getTextContent();
                     if (name.startsWith("xmlns:")){
                         name = name.substring(6);
                         namespaces.put(name, value);
                     }
                }
            }


            if (hasChildren(node)) {
                NodeList childNodes = node.getChildNodes();
                for (int i=0; i<childNodes.getLength(); i++){
                    getNameSpaces(childNodes.item(i), namespaces);
                }
            }

        }
    }



  //**************************************************************************
  //** getElementsByTagName
  //**************************************************************************
  /** Returns an array of nodes that match a given tagName (node name). The
   *  results will include all nodes that match, regardless of namespace. To
   *  narrow the results to a specific namespace, simply include the namespace
   *  prefix in the tag name (e.g. "t:Contact").
   */
    public static org.w3c.dom.Node[] getElementsByTagName(String tagName, Document xml){
        return getElementsByTagName(tagName, getOuterNode(xml));
    }

  //**************************************************************************
  //** getElementsByTagName
  //**************************************************************************
  /** Returns an array of nodes that match a given tagName (node name). The
   *  results will include all nodes that match, regardless of namespace. To
   *  narrow the results to a specific namespace, simply include the namespace
   *  prefix in the tag name (e.g. "t:Contact"). Returns an empty array if
   *  no nodes are found.
   */
    public static org.w3c.dom.Node[] getElementsByTagName(String tagName, Node node){
        java.util.ArrayList<Node> nodes = new java.util.ArrayList<Node>();
        getElementsByTagName(tagName, node, nodes);
        return nodes.toArray(new org.w3c.dom.Node[nodes.size()]);
    }

    private static void getElementsByTagName(String tagName, Node node, java.util.ArrayList<Node> nodes){
        if (node!=null && node.getNodeType()==1){

            String nodeName = node.getNodeName().trim();
            if (nodeName.contains(":") && !tagName.contains(":")){
                nodeName = nodeName.substring(nodeName.indexOf(":")+1);
            }

            if (nodeName.equalsIgnoreCase(tagName)){
                nodes.add(node);
            }

            if (hasChildren(node)) {
                NodeList childNodes = node.getChildNodes();
                for (int i=0; i<childNodes.getLength(); i++){
                    getElementsByTagName(tagName, childNodes.item(i), nodes);
                }
            }

        }
    }


  /** Converts a NodeList into an array to simplify nested loops. */
    public static Node[] getNodes(NodeList nodeList){
        java.util.ArrayList<Node> nodes = new java.util.ArrayList<Node>();
        for (int i=0; i<nodeList.getLength(); i++){
            Node node = nodeList.item(i);
            if (node.getNodeType()==1) nodes.add(node);
        }
        return nodes.toArray(new Node[nodes.size()]);
    }



    public final static String ESCAPE_CHARS = "<>&\"\'";
    public final static java.util.List<String> ESCAPE_STRINGS =
    java.util.Collections.unmodifiableList(java.util.Arrays.asList(new String[] {
      "&lt;"
    , "&gt;"
    , "&amp;"
    , "&quot;"
    , "&apos;"
    }));

    private static String UNICODE_LOW =  "" + ((char)0x20); //space
    private static String UNICODE_HIGH = "" + ((char)0x7f);


  //**************************************************************************
  //** escapeXml
  //**************************************************************************
  /** Used to encode text data for use in an XML tag or attribute.
   */
    public static String escapeXml(String content) {
        String result = content;

        if ((content != null) && (content.length() > 0)) {
          boolean modified = false;
          StringBuilder stringBuilder = new StringBuilder(content.length());
          for (int i = 0, count = content.length(); i < count; ++i) {
            String character = content.substring(i, i + 1);
            int pos = ESCAPE_CHARS.indexOf(character);
            if (pos > -1) {
              stringBuilder.append(ESCAPE_STRINGS.get(pos));
              modified = true;
            }
            else {
              if (    (character.compareTo(UNICODE_LOW) > -1)
                   && (character.compareTo(UNICODE_HIGH) < 1)
                 ) {
                stringBuilder.append(character);
              }
              else {
                stringBuilder.append("&#" + ((int)character.charAt(0)) + ";");
                modified = true;
              }
            }
          }
          if (modified) {
            result = stringBuilder.toString();
          }
        }

        return result;
    }

}