package net.sf.tomp.xtcl.filter;
   
   import net.sf.tomp.xtcl.Context;
   
   import org.apache.commons.logging.Log;
   import org.apache.commons.logging.LogFactory;
   import org.xml.sax.XMLFilter;
   
   import javax.xml.transform.Templates;
  import javax.xml.transform.TransformerConfigurationException;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.sax.SAXTransformerFactory;
  import javax.xml.transform.sax.TransformerHandler;
  import javax.xml.transform.stream.StreamSource;
  
  import java.util.HashMap;
  import java.util.Map;
  
  /***
   * DOCUMENT ME!
   * 
   * @author tomp
   */
  public class XTFilterFactoryImpl implements XTFilterFactory, TemplatesCache {
      
      private static Log log = LogFactory.getLog(XTFilterFactoryImpl.class);
  
      /*** DOCUMENT ME! */
      protected Context context;
  
      /*** DOCUMENT ME! */
      protected SAXTransformerFactory factory;
  
      /*** DOCUMENT ME! */
      protected net.sf.joost.trax.TransformerFactoryImpl jtf;
  
      /*** DOCUMENT ME! */
      protected Map cache;
  
      /***
       * Creates a new XTFilterFactoryImpl object.
       * 
       * @param factory DOCUMENT ME!
       * @param jtf DOCUMENT ME!
       */
      public XTFilterFactoryImpl(
              Context c, 
              SAXTransformerFactory factory,
              net.sf.joost.trax.TransformerFactoryImpl jtf) {
          this.context = c;
          this.factory = factory;
          this.jtf = jtf;
          cache = new HashMap();
      }
  
      /***
       * DOCUMENT ME!
       * 
       * @param className DOCUMENT ME!
       * @return DOCUMENT ME!
       * @throws ClassNotFoundException DOCUMENT ME!
       * @throws InstantiationException DOCUMENT ME!
       * @throws IllegalAccessException DOCUMENT ME!
       */
      public XMLFilter newXMLFilter(String className)
              throws ClassNotFoundException, InstantiationException,
              IllegalAccessException {
          Class filterClass = Class.forName(className);
          XMLFilter f = (XMLFilter) filterClass.newInstance();
          if(f instanceof XTFilter) {
          	((XTFilter)f).setContext(context);
          }
          return f;
      }
  
      /***
       * DOCUMENT ME!
       * 
       * @param templates DOCUMENT ME!
       * @return DOCUMENT ME!
       * @throws TransformerConfigurationException DOCUMENT ME!
       */
      public XMLFilter newTransformerFilter(Templates templates)
              throws TransformerConfigurationException {
          /*
           * if (!(templates instanceof PreparedStyleSheet)) { throw new
           * TransformerConfigurationException( "Supplied Templates object was not
           * created using Saxon"); }
           */
          TransformerHandler handler = factory.newTransformerHandler(templates);
  
          //Controller controller = (Controller)templates.newTransformer();
          return new TransformerFilterImpl(handler);
  
          //return factory.newXMLFilter(templates);
      }
  
      /***
       * DOCUMENT ME!
      * 
      * @param systemId DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public XMLFilter newTransformerFilter(String systemId)
             throws TransformerConfigurationException {
         TransformerHandler handler = factory
                 .newTransformerHandler(getTemplates(systemId));
 
         //Controller controller = (Controller)templates.newTransformer();
         return new TransformerFilterImpl(handler);
 
         //return factory.newXMLFilter(new StreamSource(systemId));
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param systemId DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public Templates newTemplates(String systemId)
             throws TransformerConfigurationException {
         //System.out.println("----- newTemplates(systemId="+systemId+")");
         return getTemplates(systemId);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param systemId DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public Templates getTemplates(String systemId)
             throws TransformerConfigurationException {
         //System.out.println("----- newTemplates(systemId="+systemId+")");
         Templates t = (Templates) cache.get(systemId);
 
         if (t == null) {
 //            t = factory.newTemplates(new StreamSource(systemId));
 //            changed by TP Sept 26 2004
             try {
             t = factory.newTemplates(factory.getURIResolver().resolve(systemId, ""));
             } catch(TransformerException te) {
                 throw new TransformerConfigurationException(te);
             }
             cache.put(systemId, t);
         }
 
         return t;
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param templates DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public XMLFilter newJoostFilter(Templates templates)
             throws TransformerConfigurationException {
         log.debug("newJoostFilter(Templates=" + templates + ")");
 
         TransformerHandler handler = jtf.newTransformerHandler(templates);
 
         return new TransformerFilterImpl(handler);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param systemId DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public Templates newJoostTemplates(String systemId)
             throws TransformerConfigurationException {
         return jtf.newTemplates(new StreamSource(systemId));
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @param systemId DOCUMENT ME!
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public XMLFilter newJoostFilter(String systemId)
             throws TransformerConfigurationException {
         log.debug("newJoostFilter(systemId=" + systemId + ")");
 
         TransformerHandler handler = jtf
                 .newTransformerHandler(new StreamSource(systemId));
 
         return new TransformerFilterImpl(handler);
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      * @throws TransformerConfigurationException DOCUMENT ME!
      */
     public TeeFilter newTeeFilter() throws TransformerConfigurationException {
         return new TeeFilterImpl();
     }
 
     /***
      * DOCUMENT ME!
      * 
      * @return DOCUMENT ME!
      */
 
     /*
      * public DerivationFilter newDerivationFilter() { return new
      * DerivationFilter(); }
      */
     /***
      * @return Returns the context.
      */
     public Context getContext() {
         return context;
     }
     /***
      * @param context The context to set.
      */
     public void setContext(Context context) {
         this.context = context;
     }
 }
 
 /*
  * 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):
  */