package net.sf.tomp.xtcl.command;
   
   import java.io.PrintStream;
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   
   import javax.xml.parsers.SAXParserFactory;
   import javax.xml.transform.Result;
  import javax.xml.transform.Source;
  import javax.xml.transform.Templates;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.sax.SAXSource;
  import javax.xml.transform.sax.SAXTransformerFactory;
  import javax.xml.transform.sax.TransformerHandler;
  import javax.xml.transform.stream.StreamResult;
  import javax.xml.transform.stream.StreamSource;
  
  import net.sf.tomp.xtcl.Context;
  import net.sf.tomp.xtcl.filter.HasOutputProperties;
  import net.sf.tomp.xtcl.filter.HasOutputPropertiesWrapper;
  
  import org.xml.sax.XMLFilter;
  import org.xml.sax.XMLReader;
  import org.xml.sax.helpers.LocatorImpl;
  
  /***
   * Command to assemble and store a transformation chain
   * 
   * @author tomp
   */
  public class Chain extends VarCommand {
  	
      /*** reference to the source */
      protected String sourceRef;
  
      /*** reference to the filters or styles in the chain */
      protected List filterStyleRefs = new ArrayList();
  
      /*** reference to the result of the chain */
      protected String resultRef;
  
      /***
       * sets source ref name
       * 
       * @param s source ref name
       */
      public void setSourceRef(String s) {
          sourceRef = s;
      }
  
      /***
       * adds filter or style reference
       * 
       * @param s filter or style reference
       */
      public void addFilterStyleRef(String s) {
          filterStyleRefs.add(s); 
      }
  
      /***
       * DOCUMENT ME!
       * 
       * @param s DOCUMENT ME!
       */
      public void setResultRef(String s) {
          resultRef = s;
      }
  
      /***
       * Creates and executes a chain transformation by
       * chaining SAX filters and XSLT-based SAX filters. 
       * 
       * @param context
       * @return 
       * @throws Exception 
       */
      public int execute(Context context) throws Exception {
          try {
              TransformerFactory tf = context.getTransformerFactory();
  
              if (!tf.getFeature(SAXSource.FEATURE)) {
                  throw new TransformerException("Not a SAXTransformerFactory");
              }
  
              SAXTransformerFactory stf = (SAXTransformerFactory) tf;
  
              SAXParserFactory spf = context.getSAXParserFactory();
  
              spf.setNamespaceAware(true);
  
              XMLReader xr = spf.newSAXParser().getXMLReader();
  
              Source source = sourceRef.startsWith("$") ? context
                      .refToSource(sourceRef) : new StreamSource(context
                      .getFile(sourceRef));
  
             Result result = resultRef.startsWith("$") ? context
                     .refToResult(resultRef) : new StreamResult(context
                     .getFile(resultRef));
 
             // if source is SAXSource, use its XMLReader as the first reader 'xr'
             if (source instanceof SAXSource) {
                 xr = ((SAXSource) source).getXMLReader();
             }
             XMLReader f = xr;
             XMLReader prev = xr;
 
             Iterator i = filterStyleRefs.iterator();
 
             if (i.hasNext()) {
                 // nonempty chain, at least one style/filter
                 while (i.hasNext()) {
                     Templates t = null;
                     TransformerHandler th = null;
 
                     String ref = (String) i.next();
                     Object value = null;
 
                     if (ref.startsWith("$")) {
                         value = context.get(ref);
 
                         //System.out.println("\nREF
                         // "+ref+"=>"+context.get(ref));
                         if (!(value instanceof XMLFilter)) {
                             t = context.refToStyle(ref);
                         }
                     } else {
                         // style filename
                         t = stf.newTemplates(new StreamSource(context
                                 .getFile(ref)));
                     }
 
                     // FIXME: what if XMLFilter is the last
                     if (i.hasNext()) {
                         f = (t == null) ? context.refToXMLFilter(ref) : stf
                                 .newXMLFilter(t);
 
                         //System.out.println("XMLFilter="+f);
                         ((XMLFilter) f).setParent(prev);
 
                         /*
                          * if(f instanceof ContentHandler) { Locator loc = new
                          * SimpleLocator(source.getSystemId());
                          * System.out.println(f+".setDocumentLocator="+loc);
                          * ((ContentHandler)f).setDocumentLocator(loc); }
                          */
                     } else {
                         // last style/filter
                         if (value instanceof XMLFilter) {
                             f = context.refToXMLFilter(ref);
 
                             //System.out.println(">>> SET PARENT TO "+f+"
                             // "+prev);
                             ((XMLFilter) f).setParent(prev);
 
                             // FIXME changed 4/2/04
                             /*
                              * if(f instanceof ContentHandler) { Locator loc =
                              * new SimpleLocator(source.getSystemId());
                              * System.out.println(f+".setDocumentLocator="+loc);
                              * //((ContentHandler)f).setDocumentLocator(loc); }
                              */
                             th = stf.newTransformerHandler();
 
                             //System.out.println("newTransformerHandler="+th);
                             if (f instanceof HasOutputProperties) {
                                 ((HasOutputProperties) f)
                                         .setOutputPropertiesListener(new HasOutputPropertiesWrapper(
                                                 th));
                             }
                         } else {
                             //System.out.println("XMLFilter="+f);
                             th = stf.newTransformerHandler(t);
 
                             /*
                              * Locator loc = new
                              * SimpleLocator(source.getSystemId());
                              * System.out.println(th+".setDocumentLocator="+loc);
                              * th.setDocumentLocator(loc);
                              */
                         }
 
                         f.setContentHandler(th);
                         f
                                 .setProperty(
                                         "http://xml.org/sax/properties/lexical-handler",
                                         th);
                         th.setResult(result);
 
                         /*                        System.out.println("NOW f=" + f + " is PARSING source="
                          + source);
                          System.out.println("NOW f.getParent()="
                          + ((XMLFilter) f).getParent());
                          */f.parse(SAXSource.sourceToInputSource(source));
 
                         //System.out.println("NOW PARSING to result="+result);
                         //System.out.println("END OF PARSING");
                     }
 
                     prev = f;
                 }
             } else {
                 //System.out.println("in CHAIN: empty transformation");
                 Transformer transf = tf.newTransformer();
 
                 transf.transform(source, result);
             }
 
             return done(context, 0);
         } catch (TransformerException te) {
             PrintStream out = context.getOut();
 
             te.printStackTrace(out);
 
             return done(context, 1);
         }
     }
 
     /***
      * @return "CHAIN " + sourceRef + " -> " + resultRef + " STYLES/FILTERS ("
                 + listList(filterStyleRefs) + ")";
      */
     public String toString() {
         return "CHAIN " + sourceRef + " -> " + resultRef + " STYLES/FILTERS ("
                 + listList(filterStyleRefs) + ")";
     }
 
     static class SimpleLocator extends LocatorImpl {
         public SimpleLocator(String systemId) {
             setSystemId(systemId);
             setPublicId(systemId);
             setColumnNumber(-1);
             setLineNumber(-1);
         }
 
         public String toString() {
             return "SimpleLocator.systemId=" + getSystemId();
         }
     }
 }
 
 /*
  * 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: all this file. The Initial Developer of the Original Code
  * is: Tomas Pitner, Masaryk University in Brno, Czech Republic. Contributor(s):
  */