package net.sf.tomp.xtcl.command;
   
   import net.sf.tomp.general.Parametrized;
   import net.sf.tomp.xtcl.Context;
   import net.sf.tomp.xtcl.filter.TeeFilter;
   import net.sf.tomp.xtcl.filter.XTFilterFactory;
   
   import org.xml.sax.ContentHandler;
   import org.xml.sax.XMLFilter;
  import org.xml.sax.XMLReader;
  
  import javax.xml.transform.Result;
  import javax.xml.transform.Templates;
  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 java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  /***
   * Creates a tee filter.
   * 
   * @author tomp
   */
  public class TeeFilterCommand extends Chain implements Parametrized {
  	
      /*** DOCUMENT ME! */
      protected Map params = new HashMap();
  
      /***
       * sets a parameter
       * 
       * @param k param name
       * @param v param value
       */
      public void setParameter(String k, Object v) {
          params.put(k, v);
  
          //System.out.println("Setting param "+k+"="+v);
      }
  
      /***
       * DOCUMENT ME!
       * 
       * @param s DOCUMENT ME!
       * @throws UnsupportedOperationException DOCUMENT ME!
       */
      public void setSourceRef(String s) {
          throw new UnsupportedOperationException("setSourceRef() on " + this);
      }
  
      /***
       * Creates a tee filter.
       * 
       */
      public int execute(Context context) throws Exception {
  
          XTFilterFactory xff = context.getXTFilterFactory();
  
          try {
              TeeFilter filter = xff.newTeeFilter();
  
              context.put(var, filter);
  
              TransformerFactory tf = context.getTransformerFactory();
  
              if (!tf.getFeature(SAXSource.FEATURE)) {
                  throw new TransformerException("Not a SAXTransformerFactory");
              }
  
              SAXTransformerFactory stf = (SAXTransformerFactory) tf;
  
              Result result = resultRef.startsWith("$") ? context
                      .refToResult(resultRef) : new StreamResult(context
                      .getFile(resultRef));
  
              XMLReader f = filter;
              XMLReader prev = filter;
  
              boolean first = true;
  
              Iterator i = filterStyleRefs.iterator();
  
              if (i.hasNext()) {
                  while (i.hasNext()) {
                      String ref = (String) i.next();
                      Object value = context.get(ref);
                      Templates t = null;
                      TransformerHandler th = null;
  
                      //System.out.println("\nREF "+ref+"=>"+context.get(ref));
                      if (!(value instanceof XMLFilter)) {
                          t = context.refToStyle(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 (first) {
                             //System.out.println("first, hasNext():
                             // setContentHandler2="+f);
                             filter.setContentHandler2((ContentHandler) f);
                         } else {
                             prev.setContentHandler((ContentHandler) f);
                         }
                     } else {
                         if (value instanceof XMLFilter) {
                             f = context.refToXMLFilter(ref);
                             ((XMLFilter) f).setParent(prev);
 
                             if (first) {
                                 filter.setContentHandler2((ContentHandler) f);
                             } else {
                                 prev.setContentHandler((ContentHandler) f);
                             }
 
                             th = stf.newTransformerHandler();
                             f.setContentHandler(th);
                         } else {
                             //System.out.println("XMLFilter="+f);
                             th = stf.newTransformerHandler(t);
 
                             if (first) {
                                 filter.setContentHandler2(th);
                             } else {
                                 prev.setContentHandler(th);
                             }
                         }
 
                         //System.out.println("NOW PARSING");
                         th.setResult(result);
 
                         //f.setContentHandler(th);
                         //f.parse(SAXSource.sourceToInputSource(source));
                         //System.out.println("END OF PARSING");
                     }
 
                     prev = f;
                     first = false;
                 }
             } else {
                 //System.out.println("in TEECHAIN: empty transformation");
                 TransformerHandler th = stf.newTransformerHandler();
 
                 th.setResult(result);
                 filter.setContentHandler2(th);
             }
 
             return done(context, 0);
         } catch (TransformerException te) {
             return done(context, 1);
         }
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
     public String toString() {
         return "TEE FILTER CHAIN " + var + " -> " + resultRef + " STYLES ("
                 + listList(filterStyleRefs) + ")";
     }
 }
 
 /*
  * 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):
  */