/*

  * Copyright 2005-2007 The Kuali Foundation

  *

  *

  * Licensed under the Educational Community License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  * http://www.opensource.org/licenses/ecl2.php

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.kuali.rice.kew.util;

 import java.io.BufferedReader;

 import java.io.IOException;

 import java.io.InputStream;

 import java.io.Reader;

 import java.io.StringReader;

 import java.io.StringWriter;

 import java.lang.reflect.Method;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Vector;

 import javax.xml.XMLConstants;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.OutputKeys;

 import javax.xml.transform.Result;

 import javax.xml.transform.Source;

 import javax.xml.transform.Transformer;

 import javax.xml.transform.TransformerException;

 import javax.xml.transform.TransformerFactory;

 import javax.xml.transform.dom.DOMResult;

 import javax.xml.transform.dom.DOMSource;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import javax.xml.xpath.XPath;

 import javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpressionException;

 import org.apache.commons.lang.StringUtils;

 import org.jdom.Attribute;

 import org.jdom.Document;

 import org.jdom.Element;

 import org.jdom.JDOMException;

 import org.jdom.Namespace;

 import org.jdom.input.DOMBuilder;

 import org.jdom.input.SAXBuilder;

 import org.jdom.output.Format;

 import org.jdom.output.XMLOutputter;

 import org.kuali.rice.kew.exception.InvalidXmlException;

 import org.kuali.rice.kew.exception.WorkflowRuntimeException;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.kew.xml.ClassLoaderEntityResolver;

 import org.kuali.rice.kew.xml.XmlConstants;

 import org.w3c.dom.NamedNodeMap;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.xml.sax.EntityResolver;

 import org.xml.sax.ErrorHandler;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 /**

  * Provides a set of utilities for XML-related operations.

  *

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class XmlHelper {

         protected static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(XmlHelper.class);

     private static final EntityResolver ENTITY_RESOLVER = new ClassLoaderEntityResolver();

         public XmlHelper() {

         }

         public static org.jdom.Document buildJDocument(StringReader xmlStream) throws InvalidXmlException {

                 // use SAX Builder

                 // don't verify for speed reasons

                 SAXBuilder builder = new SAXBuilder(false);

                 org.jdom.Document doc = null;

                 try {

                         doc = builder.build(xmlStream);

                 } /*

                          * catch (IOException e) { LOG.error("error building jdom

                          * document"); throw new InvalidXmlException("Invalid xml string. " +

                          * e.getMessage()); }

                          */catch (Exception e) {

                         LOG.error("error building jdom document");

                         throw new InvalidXmlException("Invalid xml string. " + e.getMessage());

                 }

                 return doc;

         }

         public static Element getAttributeRootElement(Document document) throws InvalidXmlException {

                 return findElement(document.getRootElement(), KEWConstants.ATTRIBUTE_CONTENT_ELEMENT);

         }

         public static Element getAttributeElement(Document document, String elementName) throws InvalidXmlException {

                 return findElement(getAttributeRootElement(document), elementName);

         }

         public static org.jdom.Document buildJDocument(org.w3c.dom.Document document) {

                 return new DOMBuilder().build(document);

         }

         /**

          * Same as above but can specify whether validation is to be performed or

          * not. Would have liked to have added a property that these methods could

          * have used but would force instantiate on an otherwise static class

          *

          * @param xmlSream

          * @param validateXML

          * @return JDOM Document

          * @throws InvalidXMLException

          */

         public static org.jdom.Document buildJDocument(StringReader xmlStream, boolean validateXML) throws InvalidXmlException {

                 SAXBuilder builder = new SAXBuilder(false);

                 org.jdom.Document doc = null;

                 try {

                         doc = builder.build(xmlStream);

                 } /*

                          * catch (IOException e) { LOG.error("error building jdom

                          * document"); throw new InvalidXmlException("Invalid xml string. " +

                          * e.getMessage()); }

                          */catch (Exception e) {

                         LOG.error("error building jdom document");

                         throw new InvalidXmlException("Invalid xml string. " + e.getMessage());

                 }

                 return doc;

         }

         public static org.w3c.dom.Document buildDocument(String xml) throws IOException, SAXException, ParserConfigurationException {

             DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

             dbf.setCoalescing(true);

             DocumentBuilder documentBuilder = dbf.newDocumentBuilder();

             return documentBuilder.parse(new InputSource(new BufferedReader(new StringReader(xml))));

         }

         /**

          * readerToString: read entire content of a Reader into a String

          *

          * @param is

          * @return String

          * @throws IOException

          */

         public static String readerToString(Reader is) throws IOException {

                 // local variables

                 StringBuffer sb = new StringBuffer();

                 char[] b = new char[2000];

                 int n;

                 // Read a block. If it gets any chars, append them.

                 while ((n = is.read(b)) > 0) {

                         sb.append(b, 0, n);

                 }

                 // Only construct the String object once, here.

                 return sb.toString();

         }

         // end ==> readerToString()

         /**

          * Find all Elements in document of a particular name

          *

          * @param root -

          *            the starting Element to scan

          * @param elementName -

          *            name of the Element to scan for

          * @return Vector - a list of the Elements found - return null if none found

          */

         public static Vector findElements(Element root, String elementName) {

                 Vector elementList = new Vector();

                 if (root == null) {

                         return elementList;

                 }

                 XmlHelper.findElements(root, elementName, elementList);

                 return elementList;

         }

         // end ==> findElements()

         /**

          * returns the one element in root according to elementName. If more than

          * one or none of element exists InvalidXmlException is thrown. This method

          * is based on the assumption you have validated your xml and know the

          * element is there. It provides a way to make code independent of the xml

          * structure i.e. it digs for the element.

          *

          * @param root

          * @param elementName

          * @return Element

          * @throws InvalidXmlException

          */

         public static Element findElement(Element root, String elementName) throws InvalidXmlException {

                 Vector elementList = XmlHelper.findElements(root, elementName);

                 if (elementList.size() < 1) {

                         return null;

                 }

                 if (elementList.size() > 1) {

                         throw new InvalidXmlException("More than one element in root");

                 }

                 return (Element) elementList.get(0);

         }

         /**

          * makes a properly formed element in the manner of <elementName value=""/>

          * if value is null value attribute is given an empty value

          *

          * @param elementName

          * @param value

          * @return Element

          * @throws Exception

          */

         public static Element makeElement(String elementName, String value) throws Exception {

                 if ((elementName == null) || elementName.trim().equals("")) {

                         throw new Exception("Programmatic error:  Element Name passed in null or blank");

                 }

                 Element element = new Element(elementName);

                 if ((value == null) || value.trim().equals("")) {

                         element.setAttribute("value", "");

                 } else {

                         element.setAttribute("value", value);

                 }

                 return element;

         }

         /**

          * Returns the value of the given element names given attribute tag based

          * upon the root element passed in.

          *

          * @param root

          * @param elementName

          * @param attributeName

          * @return value of the Element's attribute who's name matches the passed

          *         element name and attribute matches the attribute name passes

          * @throws InvalidXmlException

          *             if element or attribute are not present

          */

         public static String getElementAttributeValue(Element root, String elementName, String attributeName) throws InvalidXmlException {

                 Element element = XmlHelper.findElement(root, elementName);

                 Attribute attribute = element.getAttribute(attributeName);

                 if (attribute == null) {

                         throw new InvalidXmlException("The Attribute name given is not present in the element " + element.getName());

                 }

                 return attribute.getValue();

         }

         /**

          * This function is tail-recursive and just adds the root to the list if it

          * matches and checks the children.

          *

          * @param root

          * @param elementName

          * @param list

          */

         private static void findElements(Element root, String elementName, List list) {

                 if (root != null) {

                         if (root.getName().equals(elementName)) {

                                 list.add(root);

                         }

                         Iterator iter = root.getChildren().iterator();

                         while (iter.hasNext()) {

                                 Element item = (Element) iter.next();

                                 if (item != null) {

                                         XmlHelper.findElements(item, elementName, list);

                                 }

                         }

                 }

         }

         public static String getTextContent(org.w3c.dom.Element element) {

                 NodeList children = element.getChildNodes();

                 Node node = children.item(0);

                 return node.getNodeValue();

         }

         public static String jotDocument(org.jdom.Document document) {

                 XMLOutputter outputer = new XMLOutputter(Format.getPrettyFormat());

                 StringWriter writer = new StringWriter();

                 try {

                         outputer.output(document, writer);

                 } catch (IOException e) {

                         throw new WorkflowRuntimeException("Could not write XML data export.", e);

                 }

                 return writer.toString();

         }

         public static String jotNode(org.jdom.Element element) {

                 XMLOutputter outputer = new XMLOutputter(Format.getPrettyFormat());

                 StringWriter writer = new StringWriter();

                 try {

                         outputer.output(element, writer);

                 } catch (IOException e) {

                         throw new WorkflowRuntimeException("Could not write XML data export.", e);

                 }

                 return writer.toString();

         }

         public static String jotNode(org.w3c.dom.Node node) {

                 // default to true since this is used mostly for debugging

                 return jotNode(node, true);

         }

         public static String jotNode(org.w3c.dom.Node node, boolean indent) {

                 try {

                         return writeNode(node, indent);

                 } catch (TransformerException te) {

                         return Utilities.collectStackTrace(te);

                 }

         }

         public static String writeNode(org.w3c.dom.Node node) throws TransformerException {

                 return writeNode(node, false);

         }

         public static String writeNode(org.w3c.dom.Node node, boolean indent) throws TransformerException {

                 Source source = new DOMSource(node);

                 StringWriter writer = new StringWriter();

                 Result result = new StreamResult(writer);

                 Transformer transformer = TransformerFactory.newInstance().newTransformer();

                 transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");

                 if (indent) {

                         transformer.setOutputProperty(OutputKeys.INDENT, "yes");

                 }

                 transformer.transform(source, result);

                 return writer.toString();

         }

         public static void appendXml(Node parentNode, String xml) throws SAXException, IOException, ParserConfigurationException {

                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

                 factory.setValidating(false);

                 org.w3c.dom.Document xmlDocument = factory.newDocumentBuilder().parse(new InputSource(new StringReader(xml)));

                 org.w3c.dom.Element xmlDocumentElement = xmlDocument.getDocumentElement();

                 Node importedNode = parentNode.getOwnerDocument().importNode(xmlDocumentElement, true);

                 parentNode.appendChild(importedNode);

         }

         public static org.w3c.dom.Document readXml(String xml) throws TransformerException {

                 Source source = new StreamSource(new BufferedReader(new StringReader(xml)));

                 DOMResult result = new DOMResult();

                 Transformer transformer = TransformerFactory.newInstance().newTransformer();

                 transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");

                 transformer.transform(source, result);

                 return (org.w3c.dom.Document) result.getNode();

         }

         public static void propogateNamespace(Element element, Namespace namespace) {

                 element.setNamespace(namespace);

                 for (Iterator iterator = element.getChildren().iterator(); iterator.hasNext();) {

                         Element childElement = (Element) iterator.next();

                         propogateNamespace(childElement, namespace);

                 }

         }

         public static org.w3c.dom.Document trimXml(InputStream input) throws SAXException, IOException, ParserConfigurationException {

                 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

                 factory.setIgnoringElementContentWhitespace(true);

                 DocumentBuilder builder = factory.newDocumentBuilder();

                 org.w3c.dom.Document oldDocument = builder.parse(input);

                 org.w3c.dom.Element naviElement = oldDocument.getDocumentElement();

                 trimElement(naviElement);

                 return oldDocument;

         }

         public static void trimElement(Node node) throws SAXException, IOException, ParserConfigurationException {

                 if (node.hasChildNodes()) {

                         // System.out.println(node.getNodeType()+"; "+node.getNodeName()+";

                         // "+node.getNodeValue());

                         NodeList children = node.getChildNodes();

                         for (int i = 0; i < children.getLength(); i++) {

                                 Node child = children.item(i);

                                 if (child != null) {

                                         // System.out.println(child.getNodeType()+";

                                         // "+child.getNodeName()+"; "+child.getNodeValue());

                                         trimElement(child);

                                 }

                         }

                 } else {

                         // System.out.println(node.getNodeType()+"; "+node.getNodeName()+";

                         // "+node.getNodeValue());

                         if (node.getNodeType() == Node.TEXT_NODE) {

                                 String text = node.getNodeValue();

                                 if (Utilities.isEmpty(text)) {

                                         text = "";

                                 } else {

                                         text = text.trim();

                                 }

                                 node.setNodeValue(text);

                         }

                 }

         }

         public static void printDocumentStructure(org.w3c.dom.Document doc) {

                 org.w3c.dom.Element naviElement = doc.getDocumentElement();

                 printNode(naviElement, 0);

         }

         public static void printNode(Node node, int level) {

                 if (node.getNodeType() == Node.TEXT_NODE) {

                         if (LOG.isInfoEnabled()) {

                                 LOG.info(node.getNodeValue());

                         }

                         return;

                 } else {

                         final StringBuilder log = new StringBuilder();

                         /*

                          * System.out.println("\n"); for(int i=0;i<level;i++){

                          * System.out.print(" "); }

                          */

                         log.append("<" + node.getNodeName());

                         if (node.hasAttributes()) {

                                 NamedNodeMap attrMap = node.getAttributes();

                                 for (int i = 0; i < attrMap.getLength(); i++) {

                                         org.w3c.dom.Attr attribute = (org.w3c.dom.Attr) attrMap.item(i);

                                         log.append(" " + attribute.getName().trim() + "=\"" + attribute.getValue() + "\"");

                                 }

                         }

                         log.append(">");

                         if (node.hasChildNodes()) {

                                 NodeList children = node.getChildNodes();

                                 for (int i = 0; i < children.getLength(); i++) {

                                         Node child = children.item(i);

                                         if (child != null) {

                                                 // System.out.println(child.getNodeType()+";

                                                 // "+child.getNodeName()+"; "+child.getNodeValue());

                                                 printNode(child, level + 1);

                                         }

                                 }

                         }

                         log.append("</" + node.getNodeName() + ">");

                         if (LOG.isInfoEnabled()) {

                                 LOG.info(log);

                         }

                 }

         }

         public static Document trimSAXXml(InputStream input) throws JDOMException, SAXException, IOException, ParserConfigurationException {

                 SAXBuilder builder = new SAXBuilder(false);

                 Document oldDocument = builder.build(input);

                 Element naviElement = oldDocument.getRootElement();

                 trimSAXElement(naviElement);

                 return oldDocument;

         }

         public static void trimSAXElement(Element element) throws SAXException, IOException, ParserConfigurationException {

                 if (! element.getChildren().isEmpty()) {

                         java.util.List children = element.getChildren();

                         for (int i = 0; i < children.size(); i++) {

                                 Element child = (Element) children.get(i);

                                 if (child != null) {

                                         // System.out.println(child.getNodeType()+";

                                         // "+child.getNodeName()+"; "+child.getNodeValue());

                                         trimSAXElement(child);

                                 }

                         }

                 } else {

                         // System.out.println(node.getNodeType()+"; "+node.getNodeName()+";

                         // "+node.getNodeValue());

                         // System.out.println(element.getName());

                         String text = element.getTextTrim();

                         if (Utilities.isEmpty(text)) {

                                 text = "";

                         }

                         element.setText(text);

                 }

         }

         public static void printSAXDocumentStructure(Document doc) {

                 Element naviElement = doc.getRootElement();

                 printSAXNode(naviElement, 0);

         }

         public static void printSAXNode(Element element, int level) {

                 if (element.getChildren().isEmpty()) {

                         if (LOG.isInfoEnabled()) {

                                 LOG.info("<" + element.getName().trim() + ">" + element.getText() + "</" + element.getName().trim() + ">");

                         }

                         return;

                 } else {

                         final StringBuilder log = new StringBuilder();

                         /*

                          * System.out.println("\n"); for(int i=0;i<level;i++){

                          * System.out.print(" "); }

                          */

                         log.append("<" + element.getName());

                         org.jdom.Namespace ns = element.getNamespace();

                         if (ns != null) {

                                 log.append(" xmlns=\"" + ns.getURI() + "\"");

                         }

                         ns = element.getNamespace("xsi");

                         if (ns != null) {

                                 log.append(" xmlns:" + ns.getPrefix() + "=\"" + ns.getURI() + "\"");

                         }

                         if (element.getAttributes() != null && element.getAttributes().size() > 0) {

                                 List attrMap = element.getAttributes();

                                 for (int i = 0; i < attrMap.size(); i++) {

                                         Attribute attribute = (Attribute) attrMap.get(i);

                                         ns = attribute.getNamespace();

                                         log.append(" ");

                                         if (ns != null) {

                                                 log.append(ns.getPrefix() + ":");

                                         }

                                         log.append(attribute.getName().trim() + "=\"" + attribute.getValue() + "\"");

                                 }

                         }

                         log.append(">");

                         List children = element.getChildren();

                         for (int i = 0; i < children.size(); i++) {

                                 Element child = (Element) children.get(i);

                                 if (child != null) {

                                         // System.out.println(child.getNodeType()+";

                                         // "+child.getNodeName()+"; "+child.getNodeValue());

                                         printSAXNode(child, level + 1);

                                 }

                         }

                         log.append("</" + element.getName() + ">");

                         if (LOG.isInfoEnabled()) {

                                 LOG.info(log);

                         }

                 }

         }

     /**

      * Convenience method that performs an xpath evaluation to determine whether the expression

      * evaluates to true (a node exists).

      * This is method exists only to disambiguate the cases of determining the *presence* of a node

      * and determining the *boolean value of the node as converted from a string*, as the syntaxes

      * are very similar and could be misleading.

      * @param xpath the XPath object

      * @param expression the XPath expression

      * @param object the object on which to evaluate the expression as required by the XPath API, typically a Node

      * @return whether the result of the expression evaluation, which is whether or not a node was present

      * @throws XPathExpressionException

      */

     public static boolean pathExists(XPath xpath, String expression, Object object) throws XPathExpressionException {

         return ((Boolean) xpath.evaluate(expression, object, XPathConstants.BOOLEAN)).booleanValue();

     }

     public static void validate(final InputSource source) throws ParserConfigurationException, IOException, SAXException {

         DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

         dbf.setValidating(true);

         dbf.setNamespaceAware( true );

         dbf.setAttribute("http://java.sun.com/xml/jaxp/properties/schemaLanguage", XMLConstants.W3C_XML_SCHEMA_NS_URI);

         DocumentBuilder db = dbf.newDocumentBuilder();

         db.setEntityResolver(ENTITY_RESOLVER);

         db.setErrorHandler(new ErrorHandler() {

             public void warning(SAXParseException se) {

                 LOG.warn("Warning parsing xml doc " + source, se);

             }

             public void error(SAXParseException se) throws SAXException {

                 LOG.error("Error parsing xml doc " + source, se);

                 throw se;

             }

             public void fatalError(SAXParseException se) throws SAXException {

                 LOG.error("Fatal error parsing xml doc " + source, se);

                 throw se;

             }

         });

         db.parse(source);

     }

     public static org.w3c.dom.Element propertiesToXml(org.w3c.dom.Document doc, Object o, String elementName) throws Exception {

         Class c = o.getClass();

         org.w3c.dom.Element wrapper = doc.createElement(elementName);

         Method[] methods = c.getMethods();

         for (Method method : methods) {

             String name = method.getName();

             if ("getClass".equals(name)) continue;

             if (!name.startsWith("get") ||

                     method.getParameterTypes().length > 0) continue;

             name = name.substring("get".length());

             name = StringUtils.uncapitalize(name);

             String value = null;

             try {

                 Object result = method.invoke(o, null);

                 if (result == null) {

                     LOG.debug("value of " + name + " method on object " + o.getClass() + " is null");

                     value = "";

                 } else {

                     value = result.toString();

                 }

                 org.w3c.dom.Element fieldE = doc.createElement(name);

                 fieldE.appendChild(doc.createTextNode(value));

                 wrapper.appendChild(fieldE);

             } catch (RuntimeException e) {

                 LOG.error("Error accessing method '" + method.getName() + "' of instance of " + c);

                 throw e;

             } catch (Exception e) {

                 LOG.error("Error accessing method '" + method.getName() + "' of instance of " + c);

             }

         }

         return wrapper;

     }

     public static String getChildElementText(org.w3c.dom.Element parent, String childElementName) {

         NodeList childNodes = parent.getChildNodes();

         for (int index = 0; index < childNodes.getLength(); index++) {

             org.w3c.dom.Node node = childNodes.item(index);

             if (Node.ELEMENT_NODE == node.getNodeType()) {

                 org.w3c.dom.Element element = (org.w3c.dom.Element)node;

                 if (XmlConstants.DOCUMENT_TYPE.equals(element.getNodeName())) {

                     return element.getTextContent();

                 }

             }

         }

         return null;

     }

 }