package org.apache.torque.task;
   
   import java.io.File;
   import java.io.FileWriter;
   import java.io.IOException;
   import java.io.StringWriter;
   
   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.Transformer;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.xpath.XPath;
  import javax.xml.xpath.XPathConstants;
  import javax.xml.xpath.XPathFactory;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.Task;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  import org.w3c.dom.NodeList;
  import org.xml.sax.SAXException;
  
  /**
   * This ant task will merge the schema-desc.xml with schema.xml, if
   * schema-description.xml exists
   * 
   * @author Kuali Rice Team (kuali-rice@googlegroups.com)
   * 
   */
  public class TorqueMergeXMLDoc extends Task {
  	
  	private static final String DESCRIPTION_ATTR = "description";
  	private static final String JAVA_NAME_ATTR = "javaName";
  	private static final String NAME_ATTR = "name";
  	private static final String COLUMN_ELEMENT = "column";
  	
  	private File schemaWithDesc;
  	private File dbSchema;
  	private String schemaWithDescString;
  	private String dbSchemaString;
  	private Document schemaWithDescDoc;
  	private Document dbSchemaDoc;
  	
  
  	public void setDbSchemaString(String dbSchemaString) {		
  		this.dbSchemaString = dbSchemaString;
  		dbSchema = new File(dbSchemaString);
  
  	}
  
  	public void setSchemaWithDescString(String schemaWithDescString) {		
  		this.schemaWithDescString = schemaWithDescString;
  		schemaWithDesc = new File(schemaWithDescString);
  
  	}
  
  	public File getDbSchema() {
  		return dbSchema;
  	}
  
  	public void setSchemaWithDesc(String schemaWithDescString) {
  		this.schemaWithDesc = new File(schemaWithDescString);
  
  	}
  
  	public void setDbSchema(String dbSchemaString) {
  		this.dbSchema = new File(dbSchemaString);
  	}
  
  	/**
  	 * creates a document object from an input file
  	 * 
  	 * @param file
  	 * @return Document object
  	 * @throws ParserConfigurationException
  	 * @throws SAXException
  	 * @throws IOException
  	 */
  	public static Document setDocument(File file)
  			throws ParserConfigurationException, SAXException, IOException {
  		DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory
  				.newInstance();
  		DocumentBuilder documentBuilder;
  		documentBuilder = documentBuilderFactory.newDocumentBuilder();
  		Document XMLdocument = documentBuilder.parse(file);
  		XMLdocument.getDocumentElement().normalize();
  		return XMLdocument;
  	}
  
  	/**
  	 * performs the merge operation by taking two input files as input and then
  	 * merges the file with description into the existing schema.xml file
  	 * 
  	 * @param schemaWithDesc
 	 * @param dbSchema
 	 */
 	public void mergeSchemas(File schemaWithDesc, File dbSchema) throws Exception {
 
 		schemaWithDescDoc = setDocument(schemaWithDesc);
 		dbSchemaDoc = setDocument(dbSchema);
 		dbSchemaDoc = createNewXML(dbSchemaDoc, schemaWithDescDoc);
 
 	}
 
 	/**
 	 * merges the two xml document. The resulting document will be same as
 	 * schema.xml except it will have a description attribute for all its tables
 	 * and columns.
 	 */
 	public Document createNewXML(Document dbSchemaDoc,
 			Document schemaWithDescDoc) throws Exception {
 
 		XPath xpath = XPathFactory.newInstance().newXPath();
 		
 		NodeList listOfTablesInSchema = (NodeList)xpath.evaluate("/database/table", dbSchemaDoc, XPathConstants.NODESET);
 
 		for (int tableIndex = 0; tableIndex < listOfTablesInSchema.getLength(); tableIndex++) {
 			Element tableElementInSchema = (Element)listOfTablesInSchema.item(tableIndex);
 			String tableName = tableElementInSchema.getAttribute(NAME_ATTR);
 			// search the schema-description.xml file for a corresponding entry that contains the description
 			Element tableDescElem = (Element)xpath.evaluate("/database/table[@" + NAME_ATTR + "='" + tableName + "']", schemaWithDescDoc, XPathConstants.NODE);
 			if (tableDescElem != null) {
 				String tableDescription = tableDescElem.getAttribute(DESCRIPTION_ATTR);
 				String tableJavaName = tableDescElem.getAttribute(JAVA_NAME_ATTR);
 				tableElementInSchema.setAttribute(DESCRIPTION_ATTR, tableDescription);
 				tableElementInSchema.setAttribute(JAVA_NAME_ATTR, tableJavaName);
 				NodeList columnElements = tableElementInSchema.getElementsByTagName(COLUMN_ELEMENT);
 				for (int columnIndex = 0; columnIndex < columnElements.getLength(); columnIndex++) {
 					// look for the column in the schema description file
 					Element columnElementInSchema = (Element)columnElements.item(columnIndex);
 					String columnName = columnElementInSchema.getAttribute(NAME_ATTR);
 					Element columnDescElement = null;
 					NodeList columnDescElements = tableDescElem.getElementsByTagName(COLUMN_ELEMENT);
 					for (int columnDescIndex = 0; columnDescIndex < columnDescElements.getLength(); columnDescIndex++) {
 						Element element = (Element)columnDescElements.item(columnDescIndex);
 						if (columnName.equals(element.getAttribute(NAME_ATTR))) {
 							columnDescElement = element;
 							break;
 						}
 					}
 					if (columnDescElement != null) {
 						String columnDescription = columnDescElement.getAttribute(DESCRIPTION_ATTR);
 						String columnJavaName = columnDescElement.getAttribute(JAVA_NAME_ATTR);
 						columnElementInSchema.setAttribute(DESCRIPTION_ATTR, columnDescription);
 						columnElementInSchema.setAttribute(JAVA_NAME_ATTR, columnJavaName);
 					}
 				}
 			}
 		}
 		return dbSchemaDoc;
 	}
 
 	/**
 	 * writes the document object to an output file
 	 * 
 	 * @param newXMLDocument
 	 *            output xml document
 	 */
 	public void writeXMLToFile(Document newXMLDocument) throws Exception {
 		File dbSchema = this.getDbSchema();
 		TransformerFactory tFactory = TransformerFactory.newInstance();
 
 		Transformer transformer = tFactory.newTransformer();
 		transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM,
 			"database.dtd");
 		DOMSource domSource = new DOMSource(newXMLDocument);
 		StringWriter writer = new StringWriter();
 		Result result = new StreamResult(writer);
 		transformer.transform(domSource, result);
 		FileWriter fileWriter = new FileWriter(dbSchema);
 
 		if (dbSchema.exists()) {
 			StringBuffer bufferedWriter = new StringBuffer(writer
 					.toString());
 			fileWriter.write(bufferedWriter.toString());
 			fileWriter.close();
 			System.out.println("The data has been written");
 		} else {
 			System.out.println("This file is not exist");
 		}
 	}
 
 	@Override
 	public void execute() throws BuildException {
 		setDbSchema(dbSchemaString);
 		setSchemaWithDesc(schemaWithDescString);
 		if (!schemaWithDesc.exists()) {
 			System.out.println("no schema file with description can be located");
 			return;
 		}
 		try {
 			mergeSchemas(schemaWithDesc, dbSchema);
 			writeXMLToFile(dbSchemaDoc);
 		} catch (Exception e) {
 			throw new BuildException(e);
 		}
 	}
 	
 	
 
 }