package org.webslinger.xml;

 import java.io.ByteArrayInputStream;

 import java.io.InputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.StringWriter;

 import java.io.Writer;

 import java.util.Collection;

 import java.util.LinkedList;

 import java.util.HashMap;

 import java.util.Queue;

 import java.util.concurrent.LinkedBlockingQueue;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.transform.Result;

 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 javax.xml.xpath.XPathConstants;

 import javax.xml.xpath.XPathExpressionException;

 import javax.xml.xpath.XPathFactory;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.w3c.dom.Document;

 import org.w3c.dom.Element;

 import org.w3c.dom.Node;

 import org.w3c.dom.NodeList;

 import org.w3c.dom.Text;

 import org.webslinger.io.IOUtil;

 public class XmlUtil {

     private static final Queue<Transformer> writeTransformers;

     private static final Queue<DocumentBuilder> readBuilders;

     static {

         try {

             readBuilders = createPool(getDocumentBuilderFactory(), 20);

             writeTransformers = createPool(getTransformerFactory(), 20);

             for (Transformer transformer: writeTransformers) {

                 transformer.setOutputProperty("indent", "yes");

             }

         } catch (RuntimeException e) {

             throw e;

         } catch (Exception e) {

             throw (InternalError) new InternalError("loading queues").initCause(e);

         }

     }

     public static Queue<DocumentBuilder> createPool(DocumentBuilderFactory factory, int size) throws ParserConfigurationException {

         LinkedBlockingQueue<DocumentBuilder> queue = new LinkedBlockingQueue<DocumentBuilder>(size);

         while (size > 0) {

             queue.add(factory.newDocumentBuilder());

             size--;

         }

         return queue;

     }

     public static Queue<Transformer> createPool(TransformerFactory factory, int size) throws TransformerConfigurationException {

         LinkedBlockingQueue<Transformer> queue = new LinkedBlockingQueue<Transformer>(size);

         while (size > 0) {

             queue.add(factory.newTransformer());

             size--;

         }

         return queue;

     }

     public static TransformerFactory getTransformerFactory() {

         return TransformerFactory.newInstance();

     }

     public static Transformer newTransformer() throws TransformerConfigurationException {

         return getTransformerFactory().newTransformer();

     }

     public static DocumentBuilderFactory getDocumentBuilderFactory() {

         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();

         factory.setCoalescing(true);

         factory.setExpandEntityReferences(true);

         return factory;

     }

     public static NodeList getNodes(Node root, String xpath) throws XPathExpressionException {

         return (NodeList) XPathFactory.newInstance().newXPath().evaluate(xpath, root, XPathConstants.NODESET);

     }

     public static Node getNode(Node root, String xpath) throws XPathExpressionException {

         return (Node) XPathFactory.newInstance().newXPath().evaluate(xpath, root, XPathConstants.NODE);

     }

     public static void setNodes(Node root, String xpath, String value) throws XPathExpressionException {

         NodeList list = getNodes(root, xpath);

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

             list.item(i).setTextContent(value);

         }

     }

     public static void fixupNodes(Node root, String xpath, NodeProcessor processor) throws XPathExpressionException {

         NodeList list = getNodes(root, xpath);

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

             processor.process(list.item(i));

         }

     }

     public static void removeNodes(Node root, String xpath) throws XPathExpressionException {

         NodeList list = getNodes(root, xpath);

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

             Node child = list.item(i);

             child.getParentNode().removeChild(child);

         }

     }

     public static String getNodeValue(Node root, String xpath) throws XPathExpressionException {

         return getNodeSubText(getNode(root, xpath));

     }

     public static Document newDocument() throws ParserConfigurationException {

         DocumentBuilder builder = readBuilders.poll();

         try {

             return builder.newDocument();

         } finally {

             readBuilders.offer(builder);

         }

     }

     public static DocumentBuilder getDocumentBuilder() throws ParserConfigurationException {

         return getDocumentBuilderFactory().newDocumentBuilder();

     }

     public static Document read(String content) throws IOException, ParserConfigurationException, SAXException {

         return read(readBuilders, new ByteArrayInputStream(IOUtil.getBytes(content)));

     }

     public static Document read(Queue<DocumentBuilder> queue, String content) throws IOException, ParserConfigurationException, SAXException {

         return read(queue, new ByteArrayInputStream(IOUtil.getBytes(content)));

     }

     public static Document read(InputStream in) throws IOException, ParserConfigurationException, SAXException {

         return read(readBuilders, in);

     }

     public static Document read(Queue<DocumentBuilder> queue, InputStream in) throws IOException, ParserConfigurationException, SAXException {

         DocumentBuilder builder = queue.poll();

         try {

             return getDocumentBuilder().parse(in);

         } finally {

             queue.offer(builder);

             in.close();

         }

     }

     public static void write(Document doc, OutputStream out) throws IOException, TransformerException {

         write(writeTransformers, doc, out);

     }

     public static void write(Queue<Transformer> queue, Document doc, OutputStream out) throws IOException, TransformerException {

         try {

             write(queue, doc, new StreamResult(out));

         } finally {

             out.close();

         }

     }

     public static void write(Element element, OutputStream out) throws IOException, TransformerException {

         write(writeTransformers, element, out);

     }

     public static void write(Queue<Transformer> queue, Element element, OutputStream out) throws IOException, TransformerException {

         try {

             write(queue, element, new StreamResult(out));

         } finally {

             out.close();

         }

     }

     public static void write(Document doc, Writer writer) throws IOException, TransformerException {

         write(writeTransformers, doc, writer);

     }

     public static void write(Queue<Transformer> queue, Document doc, Writer writer) throws IOException, TransformerException {

         try {

             write(queue, doc, new StreamResult(writer));

         } finally {

             writer.close();

         }

     }

     public static void write(Element element, Writer writer) throws IOException, TransformerException {

         write(writeTransformers, element, writer);

     }

     public static void write(Queue<Transformer> queue, Element element, Writer writer) throws IOException, TransformerException {

         try {

             write(queue, element, new StreamResult(writer));

         } finally {

             writer.close();

         }

     }

     public static String write(Document doc) throws IOException, TransformerException {

         return write(writeTransformers, doc);

     }

     public static String write(Queue<Transformer> queue, Document doc) throws IOException, TransformerException {

         StringWriter writer = new StringWriter();

         write(queue, doc, writer);

         return writer.toString();

     }

     public static String write(Element element) throws IOException, TransformerException {

         return write(writeTransformers, element);

     }

     public static String write(Queue<Transformer> queue, Element element) throws IOException, TransformerException {

         StringWriter writer = new StringWriter();

         write(queue, element, writer);

         return writer.toString();

     }

     public static void write(Document doc, Result result) throws TransformerException {

         write(doc.getDocumentElement(), result);

     }

     public static void write(Queue<Transformer> queue, Document doc, Result result) throws TransformerException {

         write(queue, doc.getDocumentElement(), result);

     }

     public static void write(Element element, Result result) throws TransformerException {

         write(writeTransformers, element, result);

     }

     public static void write(Queue<Transformer> queue, Element element, Result result) throws TransformerException {

         DOMSource source = new DOMSource(element);

         Transformer transformer = queue.element();

         try {

             transformer.transform(source, result);

         } finally {

             queue.offer(transformer);

         }

     }

     public static String getAttribute(Element element, String attrName, String def) {

         String value = element != null ? element.getAttribute(attrName) : null;

         return value != null ? value : def;

     }

     public static Element getFirstElement(Node node) {

         if (node == null) return null;

         Node ptr = node.getFirstChild();

         while (ptr != null) {

             if (ptr instanceof Element) return (Element) ptr;

             ptr = ptr.getNextSibling();

         }

         return null;

     }

     public static Element getNextElement(Node node) {

         if (node == null) return null;

         Node ptr = node.getNextSibling();

         while (ptr != null) {

             if (ptr instanceof Element) return (Element) ptr;

             ptr = ptr.getNextSibling();

         }

         return null;

     }

     public static Element getFirstElementNamed(Node node, String name) {

         if (node == null) return null;

         Node ptr = node.getFirstChild();

         while (ptr != null) {

             if (!(ptr instanceof Element)) continue;

             if (node.getNodeName().equals(name)) return (Element) ptr;

             ptr = ptr.getNextSibling();

         }

         return null;

     }

     public static Collection<Element> getElementsNamed(Node node, String name) {

         LinkedList<Element> elements = new LinkedList<Element>();

         if (node == null) return elements;

         Node ptr = node.getFirstChild();

         while (ptr != null) {

             if (ptr instanceof Element && ptr.getNodeName().equals(name)) elements.add((Element) ptr);

             ptr = ptr.getNextSibling();

         }

         return elements;

     }

     public static String getNodeSubText(Node node) {

         if (node == null) return null;

         if (node instanceof Text) return node.getNodeValue();

         StringBuilder sb = new StringBuilder();

         Node ptr = node.getFirstChild();

         while (ptr != null) {

             if (ptr instanceof Text) sb.append(ptr.getNodeValue());

             ptr = ptr.getNextSibling();

         }

         return sb.toString();

     }

     public static Object parse(Element element) {

         if (element == null) return null;

         String nodeName = element.getNodeName();

         if ("true".equals(nodeName)) return Boolean.TRUE;

         if ("false".equals(nodeName)) return Boolean.FALSE;

         if ("integer".equals(nodeName)) return new Integer(element.getNodeValue());

         if ("float".equals(nodeName)) return new Float(element.getNodeValue());

         if ("long".equals(nodeName)) return new Long(element.getNodeValue());

         if ("double".equals(nodeName)) return new Double(element.getNodeValue());

         if ("string".equals(nodeName)) return getNodeSubText(element);

         if ("map".equals(nodeName)) {

             HashMap<String, Object> value = new HashMap<String, Object>();

             Node ptr = element.getFirstChild();

             while (ptr != null) {

                 ptr = ptr.getNextSibling();

                 if (!(ptr instanceof Element)) continue;

                 if (ptr.getNodeName().equals("entry")) {

                     Element subE = (Element) ptr;

                     String key = subE.getAttribute("key");

                     value.put(key, parse(getFirstElement(ptr)));

                 }

             }

             return value;

         }

         if ("list".equals(nodeName)) {

             LinkedList<Object> value = new LinkedList<Object> ();

             Node ptr = element.getFirstChild();

             while (ptr != null) {

                 ptr = ptr.getNextSibling();

                 if (!(ptr instanceof Element)) continue;

                 value.add(parse((Element) ptr));

             }

             return value;

         }

         throw new IllegalArgumentException("unknown element: " + element);

     }

     public interface NodeProcessor {

         void process(Node node);

     }

 }