package org.alleypress.util.xml;

import org.apache.xpath.XPathAPI;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.SAXException;

import java.io.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.TransformerException;

/**
 *   
 * XMLUtil was born from the need to print org.w3c.dom.Document objects and has
 * expanded to include automatic conversions from a java.sql.ResultSet to a 
 * Document object.  It will also parse a String and return a Document object. 
 * For bugs or additions, send me an email.at croftontom@yahoo.com
 * <br>
 * <br>
 * Typical use can be as follows:<br>
 * <br>
 * ResultSet rs=con.createStatement.executeQuery("select name,address,phone from users");<br>
 * Document d=XMLUtil.resultSetToDoc(rs);<br>
 * //show what we got<br>
 * System.out.println(XMLUtil.docToString(d));<br>
 * //do some XSL processing <br>  
 * 
 * @author Tom Crofton
 * @version 1.9
 * @email croftontom@yahoo.com
 * @created Nov 15, 2002
 * @last modified March 1,2006
 */

public class XMLUtil {

	/*
	 * defaulting to namespace aware doc builder
	 */
	protected static DocumentBuilder docBuilder=null;
	static {
		try {
			DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();
			dbf.setNamespaceAware(true);
			docBuilder = dbf.newDocumentBuilder();
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * Mostly for internal use, it returns a string of tabs used for indenting
	 * tag text.   
	 * 
	 * @param howMany	The number of tabs you want in your string
	 * @return			A string of the number of tab characters you requested
	 */
	public static String getTabString(int howMany) {
		StringBuffer sb = new StringBuffer();
		for (int i=0;i<howMany;i++) {
			sb.append("\t");
		}
		return sb.toString();
	}
	
	/**
	 * This is called recursively to indent the correct amount, add the 
	 * appropriate tag or value and call itself again until it reaches the
	 * end of the node. 
	 * 
	 * @param n	The node containing the tag or tags to be converted to string
	 * @param tabDepth how far to indent this tag set
	 * @return Correctly formatted node as a String
	 */
	public static String nodeToString(Node n,int tabDepth) {
		StringBuffer s = new StringBuffer();
		String tabs=getTabString(tabDepth);

		String tagName = n.getNodeName();
		String tagValue = n.getNodeValue();
		// textNodes and cdata require special handling
		boolean textNode = "#text".equals(tagName);
		boolean cData = "#cdata-section".equals(tagName); 
		boolean textValued = (tagValue!=null && tagValue.trim().length()>0);

		if (textNode || cData) {
			if (textValued) {
				s.append(tabs);
				if (cData) {
					s.append("<![CDATA["+tagValue.trim()+"]]>");
				} else {
					s.append(tagValue.trim());
				}
				s.append("\n");
			}
		} else {
			s.append(tabs+"<"+tagName);
			NamedNodeMap atts = n.getAttributes();
			if (atts!=null && atts.getLength()>0) {
				for (int k=0;k<atts.getLength();k++) {
					Node atr = atts.item(k);
					s.append(" "+atr.getNodeName());
					s.append("=\""+atr.getNodeValue()+"\"");
				}
			}		
			if (n.getChildNodes().getLength()<1 || 
			   (n.getChildNodes().getLength()==1 && 
			    n.getChildNodes().item(0).getNodeName().equals("#text") &&  
			    n.getChildNodes().item(0).getNodeValue()==null)) {
				//empty node, so we can jump right back
				s.append("/>\n");
				return s.toString();
			} else if (n.getChildNodes().getLength()==1 && 
			           n.getChildNodes().item(0).getNodeName().equals("#text") && 
			           n.getChildNodes().item(0).getNodeValue().trim().length()<35) {
				//has only a short text node 
				s.append(">");
				s.append(n.getChildNodes().item(0).getNodeValue().trim());
				s.append("</"+tagName+">\n");
				return s.toString();
			} else {
				s.append(">\n");
			}
		}
		//recursion
		NodeList nl=n.getChildNodes();
		int len=nl.getLength();
		for (int i=0;i<len;i++) {
			s.append(nodeToString(nl.item(i),tabDepth+1));			
		}
		// end recursion
		
		if (!textNode && !cData){
			s.append(tabs+"</"+tagName+">\n");
		}
		return s.toString();	
	}	
	
	/**
	 * This formats a Node with the first nodes being flush left
	 * 
	 * @param n the node to be formatted to a string
	 * @return Correctly formatted node as a String
	 */
	public static String nodeToString(Node n) {
		return nodeToString(n,0);
	}

	/**
	 * Returns a full format of the Document object as a string including
	 * the xml header and any DOCTYPE info that may exist 
	 * 
	 * @param doc Document object 
	 * @return Correctly formatted Document as a String
	 */
	public static String docToString(Document doc) {
		//Header
		StringBuffer result = new StringBuffer("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n");
		//DocType
		DocumentType dt = doc.getDoctype();
		if (dt!=null) {
			result.append("<!DOCTYPE ");
			result.append(dt.getName());
			
			if (dt.getPublicId()!=null) {
				result.append(" PUBLIC \"");
				result.append(dt.getPublicId()).append("\" \"").append(dt.getSystemId()).append("\"");			
			} else if (dt.getSystemId()!=null) {
				result.append(" SYSTEM \"");
				result.append(dt.getSystemId()+"\"");
			}
			result.append(">\n");
		}
		//Main xml  
		result.append(nodeToString(doc.getLastChild()));		
		
		return result.toString();
	}
	
	/**
	 * Takes a String that should be a corrrectly formed XML document and 
	 * parses it into a Document object.  I'm a little worried about thread
	 * safety here, it needs some investigation. 
	 * 
	 * @param xmlString A properly formed xml document
	 * @return  org.w3c.dom.Document object
	 * @throws IOException
	 * @throws SAXException
	 */
	public static Document stringToDoc(String xmlString) throws IOException,SAXException {
		return docBuilder.parse(new ByteArrayInputStream(xmlString.getBytes()));
	}

	/**
	 * Creates a new Document to use as a default paramerer when calling
	 * addResultSetToDoc(Document doc, ResultSet rs, String nodeName) with the given root node name and ResultSet 
	 * 
	 * @param rs The unread ResultSet to be parsed into a Document
	 * @param rootNodeName The name you want the root node of the document to have
	 * @return a Document object containing the entire contents returned by the ResultSet
	 * @throws SQLException
	 * 
	 */
	public static Document resultSetToDoc(ResultSet rs, String rootNodeName) throws SQLException {
		Document doc = docBuilder.newDocument();
		addResultSetToDoc(doc,rs,rootNodeName);
		return doc;
	}
	
	/**
	 * This calls resultSetToDoc(ResultSet rs, String rootNodeName) with a default
	 * root node name of <i>ResultSet</i>. see resultSetToDoc(ResultSet rs, String rootNodeName) 
	 * 
	 * @param rs The unread ResultSet to be parsed into a Document
	 * @return a Document object containing the entire contents returned by the ResultSet
	 * @throws SQLException
	 */
	public static Document resultSetToDoc(ResultSet rs) throws SQLException {
		return resultSetToDoc(rs,"ResultSet");
	}
	
   /**
    * Takes an unread ResultSet and appends to a Document object. The document will
	* have a root node named from the parameter rootNodeName and child nodes
	* each named <i>row</i>.  Each <i>row</i> will have one tag for each column
	* of the ResultSet named the same as the column name and containing a text
	* representation of the column value. If the root node does not exist, it will 
	* be created. If the root node does exist each <i>row</i> will be appended after 
	* the last existing <i>row</i> child.  
	* <br>
	* At a later date I may actually add an attribute called type that would be set
	* to the actual column datatype, but there hasn't been any advantage to doing 
	* so yet. 
	* 
	* @param doc The XML Document object that the to which the ResultSet will be appended 
	* @param rs The unread ResultSet to be parsed into a Document
	* @param nodeName The name you want the root node of the document to have
  	* @return a Document object containing the entire contents returned by the ResultSet
	* @throws SQLException
	*/
	public static void addResultSetToDoc(Document doc, ResultSet rs, String nodeName) throws SQLException {
		Element node=doc.createElement(nodeName);	
		if (doc.getFirstChild()==null) {
			doc.appendChild(node);
		} else {
			doc.getFirstChild().appendChild(node);
		}

		if (rs!=null) {
				int colCount = rs.getMetaData().getColumnCount();
				String[] colNames=new String[colCount];
				for (int i=0;i<colCount;i++) {
					colNames[i]=rs.getMetaData().getColumnName(i+1);
				}
				
				while (rs.next()){
					Element row = doc.createElement("row");
					for (int i=0;i<colCount;i++) {
						Element col = doc.createElement(colNames[i]);
						col.appendChild(doc.createTextNode(rs.getString(colNames[i])));
						row.appendChild(col);
					}
					node.appendChild(row);
				}	
		}					
	}
	
	
	/**
	 * Opens and parses a text file from the provided path containing valid xml 
	 * and returns a Document object
	 *   
	 * @param fileName exact location of the xml file to be parsed
	 * @return Document ojbect created from the given filename
	 * @throws IOException
	 * @throws SAXException
	 */
	public static Document fileToDoc(String fileName) throws IOException,SAXException {
		return docBuilder.parse(fileName);
	}

	/**
	 * This is only to save the hassle and overhead of setting up a new 
	 * DocumentBuilder in order to get a new blank XML Document object 
	 * 
	 * @return a new blank Document object
	 */
	public static Document newDocument() {
		return docBuilder.newDocument();
	}
	
	/**
	 * This returns a new document with an empty root node
	 * 
	 * @param rnName
	 * @return a Document with an empty root node whose name is same as the prodived string
	 */
	
	public static Document newDocument(String rnName) {
		Document d=newDocument();
		Element e=d.createElement(rnName);
		d.appendChild(e);
		return d;
	}
	

	/**
	 * Creates an XML representation of a Map object.  Each key value will become
	 * a tag name, and it's corresponding value will go inside that tag.  It uses
	 * the toString() method to get both the tag name and tag value.  All of the
	 * key/value pairs will be put undr the tag name specified by <i>nodeName</i>
	 *  
	 * @param doc The Document for which the node will be created, for some reason all nodes are relative to a document  
	 * @param map The Map that will be converted to the node 
	 * @param nodeName the name you want for the main tag that will enclose all the tags generated from the Map object
	 * @return a Node for the given document named from nodeName and containing the name/value pairs of the map as tag/values  
	 */	
	public static Node mapToNode(Document doc,Map map,String nodeName) {
		Element resultNode=doc.createElement(nodeName);
		Iterator keyIterator = map.keySet().iterator();
		while (keyIterator.hasNext()) {
			String tagName=keyIterator.next().toString();
			Element tempNode = doc.createElement(tagName);
			if (map.get(tagName)!=null){
				Text tx = doc.createTextNode(map.get(tagName).toString());
				tempNode.appendChild(tx);
			}
			resultNode.appendChild(tempNode);
		}
		return resultNode;		
	}
	
	/**
	 * Creates a Properties object from a node containing name and value pairs. Tries to auto-detect
	 * the tag names based on the structure. The given node is expected to contain one or more nodes
	 * with name and value tags. The first tag will be the name and the second will be the value.
	 * Use the following code as an example:
	 * <code>
	 *	Document d=XMLUtil.stringToDoc("&lt;props&gt;&lt;prp&gt;&lt;name&gt;name1&lt;/name&gt;&lt;value&gt;value1&lt;/value&gt;&lt;/prp&gt;&lt;prp&gt;&lt;name&gt;second&lt;/name&gt;&lt;value&gt;value2&lt;/value&gt;&lt;/prp&gt;&lt;/props&gt;");<br>
	 *  Properties p= XMLUtil.nodeToProperties( XPathAPI.eval(d,"/props").nodelist().item(0));<br>
     *  System.out.println(p);<br>
	 * </code>
	 * 
	 */
	public static Properties nodeToProperties(Node node) throws TransformerException {
		if (node==null) return null;		

		Properties props=new Properties();
		//how many props are there?
		int pCount=(int)XPathAPI.eval(node,"count(./*)").num();
		
		for (int i=0;i<pCount;i++){
			String name =XPathAPI.eval(node,"./*["+(i+1)+"]/*[1]").str();
			String value=XPathAPI.eval(node,"./*["+(i+1)+"]/*[2]").str();
			props.setProperty(name,value);
		}
		return props;
	}
	
}