/*

  * $Id$

  *

  * The contents of this file are subject to the Mozilla Public License 

  * Version 1.1 (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.mozilla.org/MPL/ 

  *

  * Software distributed under the License is distributed on an "AS IS" basis, 

  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 

  * for the specific language governing rights and limitations under the License.

  *

  * The Original Code is XML Hammer code. (org.xmlhammer.*)

  *

  * The Initial Developer of the Original Code is Edwin Dankert. Portions created 

  * by the Initial Developer are Copyright (C) 2005 - 2006 the Initial Developer. 

  * All Rights Reserved.

  *

  * Contributor(s): Edwin Dankert <edankert@gmail.com>

  */

 package org.xmlhammer.gui.xslt;

 import java.io.ByteArrayInputStream;

 import java.io.ByteArrayOutputStream;

 import java.io.File;

 import java.io.FileOutputStream;

 import java.io.IOException;

 import java.io.OutputStream;

 import java.io.PrintStream;

 import java.net.MalformedURLException;

 import java.net.URI;

 import java.util.ArrayList;

 import java.util.List;

 import javax.xml.parsers.DocumentBuilder;

 import javax.xml.parsers.DocumentBuilderFactory;

 import javax.xml.parsers.ParserConfigurationException;

 import javax.xml.parsers.SAXParser;

 import javax.xml.transform.Source;

 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.sax.SAXSource;

 import javax.xml.transform.stream.StreamResult;

 import javax.xml.transform.stream.StreamSource;

 import org.apache.log4j.Logger;

 import org.bounce.util.URIUtils;

 import org.xml.sax.InputSource;

 import org.xml.sax.SAXException;

 import org.xml.sax.SAXParseException;

 import org.xmlhammer.DefaultErrorHandler;

 import org.xmlhammer.Module;

 import org.xmlhammer.ResultModel;

 import org.xmlhammer.DefaultErrorHandler.Error;

 import org.xmlhammer.DefaultErrorHandler.Fatal;

 import org.xmlhammer.DefaultErrorHandler.Message;

 import org.xmlhammer.DefaultErrorHandler.Problem;

 import org.xmlhammer.DefaultErrorHandler.Warning;

 import org.xmlhammer.gui.status.StatusModel;

 import org.xmlhammer.model.preferences.Preferences;

 import org.xmlhammer.model.project.Parameter;

 import org.xmlhammer.model.project.ParameterisedSource;

 import org.xmlhammer.model.project.Project;

 import org.xmlhammer.model.tools.xslt.Associated;

 import org.xmlhammer.model.tools.xslt.OutputProperty;

 import org.xmlhammer.model.tools.xslt.XSLT.Transform;

 /**

  * Put comment...

  * 

  * @version $Revision$, $Date$

  * @author Edwin Dankert <edankert@gmail.com>

  */

 public class XSLTModule extends Module {

     private SAXParser parser = null;

     private DocumentBuilder builder = null;

     private TransformerFactory factory = null;

     private ArrayList<Transformer> transformers = null;

     private Associated associated = null;

     private Transform transform = null;

     public XSLTModule(Preferences preferences, Project project, Logger logger, boolean logSettings) throws SAXException, ParserConfigurationException, TransformerConfigurationException, TransformerException {

         super(preferences, project, logger, logSettings);

         if ("dom".equals(getProject().getParser().getType())) {

             DocumentBuilderFactory factory = getDocumentBuilderFactory();

             builder = factory.newDocumentBuilder();

         } else {

             parser = getSAXParser();

         }

         factory = getTransformerFactory();

         transform = project.getXSLT().getTransform();

         if (transform.getAssociated() != null) {

             associated = transform.getAssociated();

             return;

         } 

         if (associated == null) {

             transformers = getTransformers(logger);

         }

     }

     /**

      * Sets-up an XML Validator Module.

      * 

      * @param preferences the global preferences.

      * @param project the project specific properties;

      * @throws ParserConfigurationException 

      * @throws SAXException 

      */

         public XSLTModule(Preferences preferences, Project project, Logger logger) throws SAXException, ParserConfigurationException, TransformerConfigurationException, TransformerException {

         this(preferences, project, logger, true);

         }

     private void setOutputProperties(Transformer transformer) {

         if (transformer != null) {

             List<OutputProperty> properties = getProject().getXSLT().getOutputProperties().getOutputProperty();

             for (OutputProperty property : properties) {

                 if (property.isActive()) {

                     transformer.setOutputProperty(property.getName(), property.getValue());

                 }

             }

         }

     }

     public boolean isResultEnabled() {

         return true;

     }

     /**

      * Execute the XPath expressio.

      * @throws MalformedURLException 

      * @throws ParserConfigurationException 

      */

     @Override

     public void execute(StatusModel status, ResultModel result, URI sourceURI, URI resultURI) {

         PrintStream err = System.err;

         PrintStream out = System.out;

         DefaultErrorHandler errorHandler = new DefaultErrorHandler(null);

         if (sourceURI != null && resultURI != null) {

             // Tell that we're loading classes and parsing, so the time it

                         // takes to do this doesn't get confused with the time to do

                         // the actual query and serialization.

             InputSource in = new InputSource(sourceURI.toString());

             System.setErr(new PrintStream(new LogOutputStream("err", errorHandler), true));

             System.setOut(new PrintStream(new LogOutputStream("out", errorHandler), true));

             try {

                 FileOutputStream resultOuputStream = new FileOutputStream(new File(resultURI));

                 // TODO handle SAXTransformerFactory stuff ...

                 if ( "dom".equals(getProject().getParser().getType())) {

                     builder.setErrorHandler(errorHandler);

                     builder.setEntityResolver(getCatalogResolver());

                     DOMSource source = new DOMSource(builder.parse( in), in.getSystemId());

                     if (associated != null) {

                         transformers = new ArrayList<Transformer>();

                         Source style = factory.getAssociatedStylesheet(source, associated.getMedia(), associated.getTitle(), associated.getCharset());

                         Transformer transformer = null;

                         try {

                             transformer = getTransformer(result, sourceURI, style, associated.getParameter());

                         } catch (TransformerException e) {

                             return;

                         }

                         setOutputProperties(transformer);

                         transformers.add(transformer);

                     }

                     getLogger().info( "transform: "+URIUtils.toString(sourceURI));

                     for (Transformer transformer : transformers) {

                         transformer.setErrorListener(errorHandler);

                         StreamResult stream = null;

                         if (transformer == transformers.get(transformers.size()-1)) {

                             stream = new StreamResult(resultOuputStream);

                         } else {

                             stream = new StreamResult(new ByteArrayOutputStream());

                         }

                         transformer.transform(source, stream);

                         if (stream.getOutputStream() instanceof ByteArrayOutputStream) {

                             in.setByteStream(new ByteArrayInputStream(((ByteArrayOutputStream)stream.getOutputStream()).toByteArray()));

                             source = new DOMSource(builder.parse( in), in.getSystemId());

                         }

                     }

                 } else { // sax is the only other one.

                     parser.getXMLReader().setErrorHandler(errorHandler);

                     parser.getXMLReader().setEntityResolver(getCatalogResolver());

                     SAXSource source = new SAXSource(parser.getXMLReader(), in);

                     if (associated != null) {

                         transformers = new ArrayList<Transformer>();

                         Source style = factory.getAssociatedStylesheet(source, associated.getMedia(), associated.getTitle(), associated.getCharset());

                         Transformer transformer = null;

                         try {

                             transformer = getTransformer(result, sourceURI, style, associated.getParameter());

                         } catch (TransformerException e) {

                             return;

                         }

                         setOutputProperties(transformer);

                         transformers.add(transformer);

                     }

                     getLogger().info( "transform: "+URIUtils.toString(sourceURI));

                     for (Transformer transformer : transformers) {

                         transformer.setErrorListener(errorHandler);

                         StreamResult stream = null;

                         if (transformer == transformers.get(transformers.size()-1)) {

                             stream = new StreamResult(resultOuputStream);

                         } else {

                             stream = new StreamResult(new ByteArrayOutputStream());

                         }

                         transformer.transform(source, stream);

                         if (stream.getOutputStream() instanceof ByteArrayOutputStream) {

                             in.setByteStream(new ByteArrayInputStream(((ByteArrayOutputStream)stream.getOutputStream()).toByteArray()));

                         }

                     }

                 }

                 resultOuputStream.flush();

                 resultOuputStream.close();

             } catch ( SAXException e) {

                 if ( e instanceof SAXParseException) {

                     try {

                         errorHandler.fatalError( (SAXParseException)e);

                     } catch ( Exception x) {}

                 }

             } catch (IOException e) {

                 errorHandler.fatalError(e);

             } catch (TransformerException e) {

                 errorHandler.fatalError(e);

             } finally {

                 System.setErr(err);

                 System.setOut(out);

             }

             ArrayList<Problem> list = errorHandler.getProblems();

             if ( list.size() > 0) {

                             for (Problem problem : list) {

                     if (problem instanceof Warning) {

                         if (problem.getException() instanceof SAXParseException) {

                             logWarning(sourceURI, (SAXParseException)problem.getException());

                             if (result != null) {

                                 result.addWarning(sourceURI, (SAXParseException)problem.getException());

                             }

                         } else {

                             logWarning(sourceURI, (TransformerException)problem.getException());

                             if (result != null) {

                                 result.addWarning(sourceURI, (TransformerException)problem.getException());

                             }

                         }

                     } else if (problem instanceof Error) {

                         if (problem.getException() instanceof SAXParseException) {

                             logError(sourceURI, (SAXParseException)problem.getException());

                             if (result != null) {

                                 result.addError(sourceURI, (SAXParseException)problem.getException());

                             }

                         } else {

                             logError(sourceURI, (TransformerException)problem.getException());

                             if (result != null) {

                                 result.addError(sourceURI, (TransformerException)problem.getException());

                             }

                         }

                     } else if (problem instanceof Fatal) {

                         logFatal(sourceURI, problem.getException());

                         if (result != null) {

                             Exception exception = problem.getException();

                             if ( exception instanceof IOException) {

                                 result.addFatal(sourceURI, (IOException)problem.getException());

                             } else if ( exception instanceof SAXParseException) {

                                 result.addFatal(sourceURI, (SAXParseException)problem.getException());

                             } else {

                                 result.addFatal(sourceURI, (TransformerException)problem.getException());

                             }

                         }

                     } else if ( problem instanceof Message) {

                         getLogger().info( "\t[message] "+((Message)problem).getMessage());

                         if (result != null) {

                             result.addMessage(sourceURI, ((Message)problem).getType(), ((Message)problem).getMessage());

                         }

                     }

                             }

             } else {

                 getLogger().info( "\t[processed] Document Processed");

                 if (result != null) {

                     result.addValid(sourceURI);

                 }

             }

                 }

         }

     private ArrayList<Transformer> getTransformers(Logger logger) throws TransformerException {

         if (transformers == null) {

             transformers = new ArrayList<Transformer>();

             if (transform.getStylesheets() != null) {

                 List<ParameterisedSource> stylesheets = transform.getStylesheets().getParameterisedSource();

                 for (ParameterisedSource stylesheet: stylesheets) {

                     Transformer transformer = getTransformer(null, null, new StreamSource(stylesheet.getSrc()), stylesheet.getParameter());

                     transformers.add(transformer);

                 }

                 setOutputProperties(transformers.get(transformers.size()-1));

             } else {

                 try {

                     Transformer transformer = factory.newTransformer();

                     transformers.add(transformer);

                     setOutputProperties(transformer);

                 } catch (TransformerConfigurationException e) {

                     // this should never happen but if it does, we should just report it ...

                     e.printStackTrace();

                 }

             }

         }

         return transformers;

     }

     private Transformer getTransformer(ResultModel result, URI base, Source source, List<Parameter> parameters) throws TransformerException {

         Transformer transformer = null;

         TransformerException exception = null;

         if (source != null) {

             getLogger().info( "validate stylesheet: "+source.getSystemId());

             DefaultErrorHandler errorHandler = new DefaultErrorHandler(URIUtils.createURI(source.getSystemId()));

             try {

                 factory.setErrorListener(errorHandler);

                 transformer = factory.newTransformer(source);

                 for (Parameter parameter : parameters) {

                     if (parameter.isActive()) {

                         getLogger().info("\t[parameter] "+parameter.getName()+" = "+parameter.getValue());

                         transformer.setParameter(parameter.getName(), parameter.getValue());

                     }

                 }

             } catch (TransformerException e) {

                 errorHandler.fatalError(e);

                 exception = e;

             }

             ArrayList<Problem> list = errorHandler.getProblems();

             if ( list.size() > 0) {

                 for ( Problem problem : list) {

                     if ( problem instanceof Warning) {

                         logWarning(base, (TransformerException)problem.getException());

                         if (result != null) {

                             result.addWarning(base, (TransformerException)problem.getException());

                         }

                     } else if ( problem instanceof Error) {

                         logError(base, (TransformerException)problem.getException());

                         if (result != null) {

                             result.addError(base, (TransformerException)problem.getException());

                         }

                     } else if ( problem instanceof Fatal) {

                         logFatal(base, problem.getException());

                         if (result != null) {

                             if (problem.getException() instanceof IOException) {

                                 result.addFatal(base, (IOException)problem.getException());

                             } else {

                                 result.addFatal(base, (TransformerException)problem.getException());

                             }

                         }

                     }

                 }

             } else {

                 getLogger().info( "\t[valid] Valid Stylesheet");

             }

         }

         if (exception != null) {

             throw exception;

         }

         return transformer;

     }

     class LogOutputStream extends OutputStream {

         private StringBuffer buffer = new StringBuffer();

         private DefaultErrorHandler handler = null;

         private String type = null;

         public LogOutputStream(String type, DefaultErrorHandler handler) {

             this.handler = handler;

             this.type = type;

         }

         public void write(int b) {

             buffer.append( (char)b);

         }

         public void flush () {

             String message = buffer.toString().trim();

             if (message.length() > 0) {

                 handler.message(type, message);

             }

             buffer = new StringBuffer();

         }

     }

 }