/***
    * Copyright 2003-2004 Fabrizio Giustina.
    * 
    * Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0
    * 
   * 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.apache.maven.xhtml;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileNotFoundException;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.io.UnsupportedEncodingException;
  import java.net.UnknownHostException;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.tools.ant.BuildException;
  import org.apache.tools.ant.DirectoryScanner;
  import org.apache.tools.ant.Project;
  import org.apache.tools.ant.Task;
  import org.apache.tools.ant.types.DTDLocation;
  import org.apache.tools.ant.types.FileSet;
  import org.apache.tools.ant.types.XMLCatalog;
  import org.dom4j.Element;
  import org.dom4j.io.OutputFormat;
  import org.dom4j.io.XMLWriter;
  import org.dom4j.tree.DefaultElement;
  import org.xml.sax.InputSource;
  import org.xml.sax.SAXException;
  import org.xml.sax.SAXNotRecognizedException;
  import org.xml.sax.SAXNotSupportedException;
  import org.xml.sax.XMLReader;
  import org.xml.sax.helpers.XMLReaderFactory;
  
  
  /***
   * Validator task. This task is a modified version of the standard ant validator task, specialized for checking xhtml
   * files and logging errors (without breaking the build)
   * @author fgiust
   * @version $Revision: 1.4 $ ($Author: fgiust $)
   */
  public class Validator extends Task
  {
  
      /***
       * validation feature.
       */
      private static final String VALIDATION_FEATURE = "http://xml.org/sax/features/validation";
  
      /***
       * encoding - defaults to ISO-8859-1.
       */
      private String encoding = "ISO-8859-1";
  
      /***
       * output file.
       */
      private File outputFile;
  
      /***
       * XmlWriter used to write to outputFile.
       */
      private XMLWriter out;
  
      /***
       * sets of file to be validated.
       */
      private List filesets = new ArrayList();
  
      /***
       * XMLReader used to validation process.
       */
      private XMLReader xmlReader;
  
      /***
       * Validator handler: implements both ErrorHandler and DTDHandler.
       */
      private ValidatorHandler validatorHandler = new ValidatorHandler();
  
      /***
       * XMLCatalog containing references to local dtds and entities.
       */
      private XMLCatalog xmlCatalog = new XMLCatalog();
  
      /***
       * sets the input/output files encoding.
       * @param value encoding
      */
     public void setEncoding(String value)
     {
         this.encoding = value;
     }
 
     /***
      * sets the output file.
      * @param file output file
      */
     public void setOUtput(File file)
     {
         this.outputFile = file;
     }
 
     /***
      * add an XMLCatalog as a nested element.
      * @param catalog XMLCatalog
      */
     public void addConfiguredXMLCatalog(XMLCatalog catalog)
     {
         this.xmlCatalog.addConfiguredXMLCatalog(catalog);
     }
 
     /***
      * specify a set of file to be checked.
      * @param set Fileset
      */
     public void addFileset(FileSet set)
     {
         this.filesets.add(set);
     }
 
     /***
      * initialize task.
      */
     public void init()
     {
         super.init();
         this.xmlCatalog.setProject(this.project);
     }
 
     /***
      * Create a DTD location record. This stores the location of a DTD. The DTD is identified by its public Id
      * @return DTDLocation
      */
     public DTDLocation createDTD()
     {
         DTDLocation dtdLocation = new DTDLocation();
         this.xmlCatalog.addDTD(dtdLocation);
         return dtdLocation;
     }
 
     /***
      * Init the parser. Load the parser class and enable validation
      */
     private void initValidator()
     {
 
         // turn validation on
         try
         {
             this.xmlReader = XMLReaderFactory.createXMLReader();
             this.xmlReader.setFeature(VALIDATION_FEATURE, true);
 
         }
         catch (SAXNotRecognizedException e)
         {
             throw new BuildException("Could not start validation: " + this.xmlReader + " doesn't provide validation");
         }
         catch (SAXNotSupportedException e)
         {
             throw new BuildException("Could not start validation: " + this.xmlReader + " doesn't provide validation");
         }
         catch (SAXException e)
         {
             throw new BuildException("Could not start validation: " + this.xmlReader + " not found");
         }
 
         log(this.xmlReader.getClass().getName(), Project.MSG_DEBUG);
 
         // set entity resolver
         this.validatorHandler.setChainedEntityResolver(this.xmlCatalog);
         this.xmlReader.setEntityResolver(this.validatorHandler);
 
         // set handler for validation messages
         this.xmlReader.setErrorHandler(this.validatorHandler);
 
     }
 
     /***
      * execute the task.
      * @throws BuildException if unable to build a validating SAX2 parser
      */
     public void execute() throws BuildException
     {
 
         // check output dir
         File dir = this.outputFile.getParentFile();
 
         // create output dir if missing
         if (dir != null)
         {
             dir.mkdirs();
         }
 
         // set output format
         OutputFormat format = OutputFormat.createPrettyPrint();
         format.setEncoding(this.encoding);
 
         // create the XMLWriter
         try
         {
             this.out = new XMLWriter(new FileOutputStream(this.outputFile), format);
         }
         catch (UnsupportedEncodingException e)
         {
             throw new BuildException("Unsopported encoding: [" + this.encoding + "]");
         }
         catch (FileNotFoundException e)
         {
             throw new BuildException("Unable to write to [" + this.outputFile.getAbsolutePath() + "]");
         }
 
         // init validator
         initValidator();
 
         // pass out to validator handler
         this.validatorHandler.setOut(this.out);
 
         // create the root element
         Element validation = new DefaultElement("validation");
         try
         {
             // start xml document and open the root element
             this.out.startDocument();
             this.out.writeOpen(validation);
 
             // create the root element
 
             // iterates on filesets
             Iterator fileIterator = this.filesets.iterator();
 
             while (fileIterator.hasNext())
             {
                 // next fileset
                 FileSet fs = (FileSet) fileIterator.next();
 
                 // scan for files
                 DirectoryScanner ds = fs.getDirectoryScanner(this.project);
 
                 // get all the file names
                 String[] files = ds.getIncludedFiles();
 
                 for (int j = 0; j < files.length; j++)
                 {
                     // create a new File
                     File srcFile = new File(fs.getDir(this.project), files[j]);
 
                     // new file element
                     Element xmlfile = new DefaultElement("file");
 
                     // add file name to element
                     xmlfile.addAttribute("name", files[j]);
 
                     // open file element
                     this.out.writeOpen(xmlfile);
 
                     // perform validation
                     doValidate(srcFile);
 
                     // close file element
                     this.out.writeClose(xmlfile);
                 }
             }
 
             // close the root element
             this.out.writeClose(validation);
 
             // end document
             this.out.endDocument();
         }
 
         catch (SAXException e)
         {
             log(e.getClass() + " " + e.getMessage(), Project.MSG_WARN);
             e.printStackTrace();
             throw new BuildException(e + " " + e.getMessage());
         }
         catch (Exception e)
         {
             log(e + " " + e.getClass() + " " + e.getMessage(), Project.MSG_WARN);
             e.printStackTrace();
             throw new BuildException(e + " " + e.getMessage());
         }
 
         finally
         {
             try
             {
                 // be sure out is closed
                 if (this.out != null)
                 {
                     this.out.close();
                 }
             }
             catch (IOException e)
             {
                 log("Caught IOException: " + e.getMessage(), Project.MSG_ERR);
             }
         }
     }
 
     /***
      * parses the file.
      * @param afile File to validate
      */
     private void doValidate(File afile)
     {
         log("Validating " + afile.getName() + "... ", Project.MSG_INFO);
 
         // init validation handler
         this.validatorHandler.init(afile);
 
         try
         {
 
             InputSource is = new InputSource(new FileInputStream(afile));
             String uri = "file:" + afile.getAbsolutePath().replace('//', '/');
             for (int index = uri.indexOf('#'); index != -1; index = uri.indexOf('#'))
             {
                 uri = uri.substring(0, index) + "%23" + uri.substring(index + 1);
             }
             is.setSystemId(uri);
             is.setEncoding(this.encoding);
 
             this.xmlReader.parse(is);
         }
         catch (SAXException e)
         {
             logFatalError(e.getMessage());
         }
         catch (UnknownHostException e)
         {
             logFatalError("Could not validate document "
                 + afile.getName()
                 + "; dtd missing from repository and unable to connect ("
                 + e.getMessage()
                 + ")");
         }
         catch (IOException e)
         {
             logFatalError(e.getMessage());
         }
 
         if (this.validatorHandler.getErrors() > 0)
         {
             log(afile + ", errors=" + this.validatorHandler.getErrors(), Project.MSG_INFO);
         }
 
     }
 
     /***
      * log event to output.
      * @param e SAXParseException
      * @param logLevel int
      */
     private void logFatalError(String message)
     {
         Element error = new DefaultElement("error");
         error.addAttribute("line", "" + 0);
         error.addAttribute("col", "" + 0);
         error.addAttribute("position", "0:0");
         error.addAttribute("level", "fatal");
 
         // check for invalid sequence ]]> and encode to be sure not to break the build
         int endCdata;
         while (message != null && (endCdata = message.indexOf("]]>")) > -1)
         {
             message = message.substring(0, endCdata) + "] ] >" + message.substring(endCdata + 3, message.length());
         }
 
         error.addCDATA(message);
         writeToLog(error);
     }
 
     /***
      * write an element to the xml log file.
      * @param element Element to write
      */
     private void writeToLog(Element element)
     {
         try
         {
             this.out.write(element);
         }
         catch (IOException e)
         {
             log("Caught IOException: " + e.getMessage(), Project.MSG_ERR);
         }
     }
 
 }