/**
 *  '$RCSfile$'
 *    Purpose: A Class that validates XML documents
 *             This class is designed to be 'parser independent
 *             i.e. it uses only org.xml.sax classes
 *             It is tied to SAX 2.0 methods
 *  Copyright: 2000 Regents of the University of California and the
 *             National Center for Ecological Analysis and Synthesis
 *    Authors: Dan Higgins, Matt Jones
 * 
 *   '$Author: daigle $'
 *     '$Date: 2009-08-24 21:34:17 +0000 (Mon, 24 Aug 2009) $'
 * '$Revision: 5030 $'
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package edu.ucsb.nceas.metacat;


import java.net.URL;
import java.net.MalformedURLException;
import java.util.*;
import java.io.*;
import java.lang.reflect.*;
import java.sql.*;

import org.w3c.dom.*;
import org.xml.sax.*;
import org.xml.sax.helpers.XMLReaderFactory;

import com.arbortext.catalog.*;

import edu.ucsb.nceas.metacat.database.DBConnection;
import edu.ucsb.nceas.metacat.database.DBConnectionPool;
import edu.ucsb.nceas.metacat.properties.PropertyService;

/**
 * Name: DBValidate.java
 *       Purpose: A Class that validates XML documents
 * 			   This class is designed to be parser independent
 *    			   i.e. it uses only org.xml.sax classes
 * 			   It is tied to SAX 2.0 methods
 *     Copyright: 2000 Regents of the University of California and the
 *                National Center for Ecological Analysis and Synthesis
 *                April 28, 2000
 *    Authors: Dan Higgins, Matt Jones
 */
public class DBValidate {
    
  static int WARNING = 0;
  static int ERROR=1;
  static int FATAL_ERROR=2;

  XMLReader parser;
  ErrorStorer ef;
  String xml_doc; // document to be parsed
  public boolean alreadyHandle = false;
    
  /** Construct a new validation object */
  public DBValidate() {
    alreadyHandle = false;
    try {
      // Get an instance of the parser
      String parserName = PropertyService.getProperty("xml.saxparser");
      parser = XMLReaderFactory.createXMLReader(parserName);
      parser.setFeature("http://xml.org/sax/features/validation",true);
      //parser.setValidationMode(true);     // Oracle
    } catch (Exception e) {
      System.err.println("Could not create parser in DBValidate.DBValidate");
    }
  }
    
  /** Construct a new validation object using an OASIS catalog file */
  public DBValidate(String xmlcatalogfile)  {
    this();

    CatalogEntityResolver cer = new CatalogEntityResolver();
    try {
      Catalog myCatalog = new Catalog();
      myCatalog.loadSystemCatalogs();
      myCatalog.parseCatalog(xmlcatalogfile);
      cer.setCatalog(myCatalog);
    } catch (Exception e) {
      System.out.println("Problem creating Catalog in DBValidate.DBValidate");
    }

    parser.setEntityResolver(cer);
  }

  /** Construct a new validation object using a database entity resolver */
  public DBValidate(DBConnection conn) {
    this();

    DBEntityResolver dbresolver = new DBEntityResolver(conn);
    parser.setEntityResolver(dbresolver);
  }

  /** 
   * validate an xml document against its DTD
   *
   * @param doc the filename of the document to validate
   */
  public boolean validate(String doc) {
    xml_doc = doc;    
    ef = new ErrorStorer();
    ef.resetErrors();
    parser.setErrorHandler(ef);
    try {
      parser.parse((createURL(xml_doc)).toString());
    } catch (IOException e) {
      System.out.println("IOException:Could not parse :" + xml_doc +
                         " from DBValidate.validate");
      ParseError eip = null;
      eip = new ParseError("",0,0,
                "IOException:Could not parse :"+xml_doc);
      if (ef.errorNodes == null)  ef.errorNodes = new Vector();
      ef.errorNodes.addElement(eip);
        
    } catch (Exception e) {} 

    
    
    if (ef != null && ef.getErrorNodes()!=null && 
      ef.getErrorNodes().size() > 0 ) {
      return false; 
    } else {
      return true;
    }
  }
    
  /** 
   * validate an xml document against its DTD
   *
   * @param xmldoc the String containing the xml document to validate
   */
  public boolean validateString(String xmldoc) {
    // string is actual XML here, NOT URL or file name    
    ef = new ErrorStorer();
    ef.resetErrors();
    parser.setErrorHandler(ef);
      
    InputSource is = new InputSource(new StringReader(xmldoc));
    try 
    {
      
      parser.parse(is);
     
    }
    catch (SAXParseException e) 
    {
      System.out.println("SAXParseException Error in DBValidate.validateString"
                         +e.getMessage());
      ef.error(e);
    }
    catch (SAXException saxe)
    {
      System.out.println("SAXException error in validateString: "
                          +saxe.getMessage());
      ef.otherError(saxe, null);
      
    }
    catch (IOException ioe)
    {
      System.out.println("IOExcption error in validateString "
                          +ioe.getMessage());
      ef.otherError(ioe, null);
    }

    if (ef != null && ef.getErrorNodes()!=null && 
      ef.getErrorNodes().size() > 0 ) {
      return false; 
    } else {
      return true;
    }
  }
    
  /** provide a list of errors from the validation process */
  public String returnErrors() {
    StringBuffer errorstring = new StringBuffer();
    errorstring.append("<?xml version=\"1.0\" ?>\n");
    if (ef != null && ef.getErrorNodes()!=null && 
        ef.getErrorNodes().size() > 0 ) {
      Vector errors = ef.getErrorNodes();
      errorstring.append("<validationerrors>\n");
      for (Enumeration e = errors.elements() ; e.hasMoreElements() ;) {
        errorstring.append(
                      ((ParseError)(e.nextElement())).toXML());
      }
      errorstring.append("</validationerrors>\n");
    } else {
      errorstring.append("<valid />\n");
    }
    return errorstring.toString();
  }
              
  /** Create a URL object from either a URL string or a plain file name. */
  private URL createURL(String name) throws Exception {
    try {
      URL u = new URL(name);
      return u;
    } catch (MalformedURLException ex) {
    }
    URL u = new URL("file:" + new File(name).getAbsolutePath());
    return u;
  }    

  /** 
   * main method for testing 
   * <p>
   * Usage: java DBValidate <xmlfile or URL>
   */
  public static void main(String[] args) {

    if (args.length != 1) {
      System.out.println("Usage: java DBValidate <xmlfile or URL>");
      System.exit(0);
    }

    String doc = args[0];

    DBConnection conn = null;
    int serailNumber = -1;
    try {
      conn = DBConnectionPool.getDBConnection("DBValidate.main");
      serailNumber = conn.getCheckOutSerialNumber();
  
      DBValidate gxv = new DBValidate(conn);
      if (gxv.validate(doc)) {
        System.out.print(gxv.returnErrors());
      } else {
        System.out.print(gxv.returnErrors());
      }
    } catch (SQLException e) {
      System.out.println("<error>Couldn't open database connection.</error>");
    } 
    finally
    {
      DBConnectionPool.returnDBConnection(conn, serailNumber);
    }//finally
  }

    
  /**
   * ErrorStorer has been revised here to simply create a Vector of 
   * ParseError objects
   *
   */
  class ErrorStorer implements ErrorHandler {

    //
    // Data
    //
    Vector errorNodes = null;
        
    /**
     * Constructor
     */
    public ErrorStorer() {
    }

    /**
     * The client is is allowed to get a reference to the Hashtable,
     * and so could corrupt it, or add to it...
     */
    public Vector getErrorNodes() {
        return errorNodes;
    }

    /**
     * The ParseError object for the node key is returned.
     * If the node doesn't have errors, null is returned.
     */
    public Object getError() {
        if (errorNodes == null)
            return null;
        return errorNodes;
    }
        
    /**
     * Reset the error storage.
     */
    public void resetErrors() {
        if (errorNodes != null)
        errorNodes.removeAllElements();
    }
    
    /***/
    public void warning(SAXParseException ex) {
        
        handleError(ex, WARNING);
        
    }

    public void error(SAXParseException ex) {
      
        handleError(ex, ERROR);
       
    }

    public void fatalError(SAXParseException ex){
      
        handleError(ex, FATAL_ERROR);
        
    }
    
    public void otherError(Exception ex, String fileName)
    {
      if (!alreadyHandle)
      {
        if (errorNodes == null) 
        {
          errorNodes = new Vector();
        }
      
        ParseError error = new ParseError(fileName, ex.getMessage());
        errorNodes.addElement(error);
       
      }
    }
        
    private void handleError(SAXParseException ex, int type) {
     
      if (errorNodes == null) {
        errorNodes = new Vector();
      }
      
      ParseError eip = null;
      
      eip = new ParseError(ex.getSystemId(), ex.getLineNumber(),
                           ex.getColumnNumber(), ex.getMessage());
      
      // put it in the Hashtable.
      errorNodes.addElement(eip);
      alreadyHandle = true;
      
    }
        
  }
    
  /**
   * The ParseError class wraps up all the error info from
   * the ErrorStorer's error method.
   *
   * @see ErrorStorer
   */
  class ParseError extends Object {

    //
    // Data
    //

    String fileName;
    int lineNo;
    int charOffset;
    String msg;

    /**
     * Constructor
     */
    public ParseError(String fileName, int lineNo, int charOffset, String msg) {
      this.fileName=fileName;
      this.lineNo=lineNo;
      this.charOffset=charOffset;
      this.msg=msg;
    }
    public ParseError(String fileName, String msg) {
      this.fileName=fileName;
      this.msg=msg;
    }
    //
    // Getters...
    //
    public String getFileName() { return fileName; }
    public int getLineNo() { return lineNo; }
    public int getCharOffset() { return charOffset;}
    public String getMsg() { return msg; }
    public void setMsg(String s) { msg = s; }

    /** Return the error message as an xml fragment */
    public String toXML() {
      StringBuffer err = new StringBuffer();
      err.append("<error>\n");
      err.append("<filename>").append(getFileName()).append("</filename>\n");
      err.append("<line>").append(getLineNo()).append("</line>\n");
      err.append("<offset>").append(getCharOffset()).append("</offset>\n");
      err.append("<message>").append(getMsg()).append("</message>\n");
      err.append("</error>\n");
      return err.toString();
    }
  }
}
