/* SAXNullTransformerFactory.java -- 
   Copyright (C) 2001 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package gnu.xml.util;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.Hashtable;
import java.util.Properties;

import gnu.xml.dom.Consumer;
import gnu.xml.dom.DomDocument;
import gnu.xml.pipeline.DomConsumer;
import gnu.xml.pipeline.EventFilter;

import javax.xml.transform.*;
import javax.xml.transform.dom.*;
import javax.xml.transform.sax.*;
import javax.xml.transform.stream.*;

import org.xml.sax.*;
import org.xml.sax.helpers.XMLReaderFactory;
import org.xml.sax.helpers.LocatorImpl;


/**
 * Implements null transforms. XSLT stylesheets are not supported.
 * This class provides a way to translate three representations of
 * XML data (SAX event stream, DOM tree, and XML text) into each other.
 * In essence it's a thinnish wrapper around basic SAX event
 * <a href="../pipeline/package-summary.html">pipeline</a> facilities, which
 * exposes only limited functionality.  The <em>javax.xml.transform</em>
 * functionality is implemented as follows: <ul>
 *
 * <li>The {@link javax.xml.transform.sax.SAXSource SAXSource} class
 * just wraps an {@link XMLReader} and {@link InputSource}, while the
 * {@link javax.xml.transform.sax.SAXResult SAXResult} class is less
 * functional than a {@link gnu.xml.pipeline.EventConsumer EventConsumer}.
 * (Notably, it drops all but one declaration from any DTD.)</li>
 *
 * <li>The {@link javax.xml.transform.dom.DOMSource DOMSource} class
 * corresponds to special SAX parsers like {@link DomParser}, and the
 * {@link javax.xml.transform.dom.DOMResult DOMResult} class corresponds
 * to a {@link gnu.xml.pipeline.DomConsumer DomConsumer}.</li>
 *
 * <li>The {@link javax.xml.transform.stream.StreamSource StreamSource}
 * class corresponds to a SAX {@link InputSource}, and the
 * {@link javax.xml.transform.stream.StreamResult StreamResult} class
 * corresponds to a {@link gnu.xml.pipeline.TextConsumer TextConsumer}.</li>
 *
 * </ul>
 *
 * <p><em>This implementation is preliminary.</em>
 *
 * @see gnu.xml.pipeline.XsltFilter
 *
 * @author David Brownell
 */
public class SAXNullTransformerFactory extends SAXTransformerFactory
{
  
  private ErrorListener	errListener;
  private URIResolver		uriResolver;
  
  /** Default constructor */
  public SAXNullTransformerFactory () { }
  
  //
  // only has stuff that makes sense with null transforms
  //
  
  /**
   * Returns true if the requested feature is supported.
   * All three kinds of input and output are accepted:
   * XML text, SAX events, and DOM nodes.
   */
  public boolean getFeature (String feature)
  {
    return SAXTransformerFactory.FEATURE.equals (feature)
      || SAXResult.FEATURE.equals (feature)
      || SAXSource.FEATURE.equals (feature)
      || DOMResult.FEATURE.equals (feature)
      || DOMSource.FEATURE.equals (feature)
      || StreamResult.FEATURE.equals (feature)
      || StreamSource.FEATURE.equals (feature)
      ;
  }

  public void setFeature(String name, boolean value)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException(name);
  }


  /** Throws an exception (no implementation attributes are supported) */
  public void setAttribute (String key, Object value)
  {
    throw new IllegalArgumentException ();
  }

  /** Throws an exception (no implementation attributes are supported) */
  public Object getAttribute (String key)
  {
    throw new IllegalArgumentException ();
  }

  /** (not yet implemented) */
  public Source getAssociatedStylesheet (Source source,
                                         String media,
                                         String title,
                                         String charset)
    throws TransformerConfigurationException
  {
    // parse, and find the appropriate xsl-stylesheet PI contents
    throw new IllegalArgumentException ();
  }

  public Transformer newTransformer ()
    throws TransformerConfigurationException
  {
    return new NullTransformer ();
  }

  /**
   * Returns a TransformerHandler that knows how to generate output
   * in all three standard formats.  Output text is generated using
   * {@link XMLWriter}, and the GNU implementation of
   * {@link DomDocument DOM} is used.
   *
   * @see SAXResult
   * @see StreamResult
   * @see DOMResult
   */
  public TransformerHandler newTransformerHandler ()
    throws TransformerConfigurationException
  {
    NullTransformer	transformer = new NullTransformer ();
    return transformer.handler;
  }

  //
  // Stuff that depends on XSLT support, which we don't provide
  //
  private static final String		noXSLT = "No XSLT support";

  /** Throws an exception (XSLT is not supported). */
  public Transformer newTransformer (Source stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public Templates newTemplates (Source stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public TemplatesHandler newTemplatesHandler ()
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public TransformerHandler newTransformerHandler (Source stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public TransformerHandler newTransformerHandler (Templates stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public XMLFilter newXMLFilter (Source stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Throws an exception (XSLT is not supported). */
  public XMLFilter newXMLFilter (Templates stylesheet)
    throws TransformerConfigurationException
  {
    throw new TransformerConfigurationException (noXSLT);
  }

  /** Returns the value assigned by {@link #setErrorListener}.  */
  public ErrorListener getErrorListener ()
  {
    return errListener;
  }

  /** Assigns a value that would be used when parsing stylesheets */
  public void setErrorListener (ErrorListener e)
  {
    errListener = e;
  }

  /** Returns the value assigned by {@link #setURIResolver}.  */
  public URIResolver getURIResolver ()
  {
    return uriResolver;
  }

  /** Assigns a value that would be used when parsing stylesheets */
  public void setURIResolver (URIResolver u)
  {
    uriResolver = u;
  }


  //
  // Helper classes.  These might in theory be subclassed
  // by an XSLT implementation, if they were exported.
  //

  static class DomTerminus
    extends DomConsumer
  {

    DomTerminus (DOMResult result)
      throws SAXException
    {
      // won't really throw SAXException
      super (DomDocument.class);
      setHandler (new DomHandler (this, result));
    }
    
  }

  static class DomHandler
    extends Consumer.Backdoor
  {
  
    private DOMResult	result;
    
    DomHandler (DomConsumer c, DOMResult r)
      throws SAXException
    {
      // won't really throw SAXException
      super (c);
      result = r;
    }

    public void endDocument ()
      throws SAXException
    {
      super.endDocument ();
      result.setNode (getDocument ());
    }
    
  }

  private static OutputStream getOutputStream (String uri)
    throws IOException
  {
    // JDK stupidity:  file "protocol does not support output" ... 
    if (uri.startsWith ("file:"))
      return new FileOutputStream (uri.substring (5));
    
    // Otherwise ...
    URL		url = new URL (uri);
    URLConnection	conn = url.openConnection ();
    
    conn.setDoOutput (true);
    return conn.getOutputStream ();
  }
  

  static class NullHandler
    extends EventFilter
    implements TransformerHandler
  {
   
    private String		systemId;
    private Transformer	transformer;
    
    NullHandler (Transformer t)
    {
      transformer = t;
    }

    public Transformer getTransformer ()
    {
      return transformer;
    }

    public String getSystemId ()
    {
      return systemId;
    }

    public void setSystemId (String id)
    {
      systemId = id;
    }

    public void setResult (Result result)
    {
      if (result.getSystemId () != null)
        systemId = result.getSystemId ();
      
      try
        {
          
          // output to partial SAX event stream?
          if (result instanceof SAXResult)
            {
              SAXResult 	r = (SAXResult) result;
              
              setContentHandler (r.getHandler ());
              setProperty (LEXICAL_HANDLER, r.getLexicalHandler ());
              // DTD info is filtered out by javax.transform
              
              // output to DOM tree?
            }
          else if (result instanceof DOMResult)
            {
              DomTerminus	out = new DomTerminus ((DOMResult) result);

              setContentHandler (out.getContentHandler ());
              setProperty (LEXICAL_HANDLER,
                           out.getProperty (LEXICAL_HANDLER));
              // save DTD-derived info, if any.
              setDTDHandler (out.getDTDHandler ());
              setProperty (DECL_HANDLER,
                           out.getProperty (DECL_HANDLER));

              // node is saved into result on endDocument()

              // output to (XML) text?
            }
          else if (result instanceof StreamResult)
            {
              StreamResult	r = (StreamResult) result;
              XMLWriter		out;

              // FIXME:  when do output properties take effect?
              // encoding, standalone decl, xml/xhtml/... ...

              // FIXME:  maybe put nsfix filter up front

              try
                {
                  if (r.getWriter () != null)
                    out = new XMLWriter (r.getWriter ());
                  else if (r.getOutputStream () != null)
                    out = new XMLWriter (r.getOutputStream ());
                  else if (r.getSystemId () != null)
                    out = new XMLWriter (
                                         getOutputStream (r.getSystemId ()));
                  else
                    throw new IllegalArgumentException (
                                                        "bad StreamResult");
                }
              catch (IOException e)
                {
                  e.printStackTrace ();
                  // on jdk 1.4, pass the root cause ...
                  throw new IllegalArgumentException (e.getMessage ());
                }

              // out.setExpandingEntities (true);
              // out.setPrettyPrinting (true);
              // out.setXhtml (true);

              setContentHandler (out);
              setProperty (LEXICAL_HANDLER, out);
              // save DTD info, if any; why not?
              setDTDHandler (out);
              setProperty (DECL_HANDLER, out);
            }
          
        }
      catch (SAXException e)
        {
          // SAXNotSupportedException or SAXNotRecognizedException:
          // "can't happen" ... but SAXException for DOM build probs
          // could happen, so ...
          // on jdk 1.4, pass the root cause ...
          throw new IllegalArgumentException (e.getMessage ());
        }
    }
  }

  // an interface that adds no value
  static class LocatorAdapter
    extends LocatorImpl
    implements SourceLocator
  {
  
    LocatorAdapter (SAXParseException e)
    {
      setSystemId (e.getSystemId ());
      setPublicId (e.getPublicId ());
      setLineNumber (e.getLineNumber ());
      setColumnNumber (e.getColumnNumber ());
    }
    
  }

  // another interface that adds no value
  static class ListenerAdapter
    implements ErrorHandler
  {
    
    NullTransformer	transformer;
    
    ListenerAdapter (NullTransformer t)
    {
      transformer = t;
    }
    
    private TransformerException map (SAXParseException e)
    {
      return new TransformerException (
                                       e.getMessage (),
                                       new LocatorAdapter (e),
                                       e);
    }

    public void error (SAXParseException e)
      throws SAXParseException
    {
      try
        {
          if (transformer.errListener != null)
            transformer.errListener.error (map (e));
        }
      catch (TransformerException ex)
        {
          transformer.ex = ex;
          throw e;
        }
    }

    public void fatalError (SAXParseException e)
      throws SAXParseException
    {
      try
        {
          if (transformer.errListener != null)
            transformer.errListener.fatalError (map (e));
          else
            throw map (e);
        } catch (TransformerException ex) {
          transformer.ex = ex;
          throw e;
        }
    }

    public void warning (SAXParseException e)
      throws SAXParseException
    {
      try
        {
          if (transformer.errListener != null)
            transformer.errListener.warning (map (e));
        }
      catch (TransformerException ex)
        {
          transformer.ex = ex;
          throw e;
        }
    }
  }

  static class NullTransformer
    extends Transformer
  {
  
    private URIResolver		uriResolver;
    private Properties		props = new Properties ();
    private Hashtable		params = new Hashtable (7);
    
    ErrorListener			errListener = null;
    TransformerException		ex = null;
    NullHandler			handler;
    
    NullTransformer ()
    {
      super ();
      handler = new NullHandler (this);
    }
    
    public ErrorListener getErrorListener ()
    {
      return errListener;
    }
    
    public void setErrorListener (ErrorListener e)
    {
      errListener = e;
    }
    
    public URIResolver getURIResolver ()
    {
      return uriResolver;
    }
    
    public void setURIResolver (URIResolver u)
    {
      uriResolver = u;
    }

    public void setOutputProperties (Properties p)
    {
      props = (Properties) p.clone ();
    }
    
    public Properties getOutputProperties ()
    {
      return (Properties) props.clone ();
    }

    public void setOutputProperty (String name, String value)
    {
      props.setProperty (name, value);
    }
    
    public String getOutputProperty (String name)
    {
      return props.getProperty (name);
    }

    public void clearParameters ()
    {
      params.clear ();
    }
    
    public void setParameter (String name, Object value)
    {
      props.put (name, value);
    }
    
    public Object getParameter (String name)
    {
      return props.get (name);
    }

    public void transform (Source in, Result out)
      throws TransformerException
    {
      try
        {
          XMLReader		producer;
          InputSource		input;
          
          // Input from DOM?
          if (in instanceof DOMSource)
            {
              DOMSource	source = (DOMSource) in;
              
              if (source.getNode () == null)
                throw new IllegalArgumentException ("no DOM node");
              producer = new DomParser (source.getNode ());
              input = null;
              
              // Input from SAX?
            }
          else if (in instanceof SAXSource)
            {
              SAXSource	source = (SAXSource) in;
              
              producer = source.getXMLReader ();
              if (producer == null)
                producer = XMLReaderFactory.createXMLReader ();
              
              input = source.getInputSource ();
              if (input == null)
                {
                  if (source.getSystemId () != null)
                    input = new InputSource (source.getSystemId ());
                  else
                    throw new IllegalArgumentException (
                                                        "missing SAX input");
                }
              
              // Input from a stream or something?
            }
          else
            {
              producer = XMLReaderFactory.createXMLReader ();
              input = SAXSource.sourceToInputSource (in);
              if (input == null)
                throw new IllegalArgumentException ("missing input");
            }
          
          // preserve original namespace prefixes
          try
            {
              producer.setFeature(EventFilter.FEATURE_URI +
                                  "namespace-prefixes",
                                  true);
            }
          catch (Exception e)
            {
              /* ignore */
              // FIXME if we couldn't, "NsFix" stage before the output ..
            }
          
          // arrange the output
          handler.setResult (out);
          EventFilter.bind (producer, handler);
          
          // then parse ... single element pipeline
          producer.parse (input);
          
        }
      catch (IOException e)
        {
          throw new TransformerException ("transform failed", e);
          
        }
      catch (SAXException e)
        {
          if (ex == null && ex.getCause () == e)
            throw ex;
          else
            throw new TransformerException ("transform failed", e);
          
        }
      finally
        {
          ex = null;
        }
    }
  }

}