/*
 * Copyright 1999-2004 The Apache Software Foundation.
 * 
 * Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/* $Id$ */
 
package org.apache.fop.apps;
import org.apache.fop.fo.ElementMapping;
import org.apache.fop.render.Renderer;

// Avalon
import org.apache.avalon.framework.logger.ConsoleLogger;
import org.apache.avalon.framework.logger.Logger;

// DOM
import org.w3c.dom.Document;

// SAX
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

// Java
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Vector;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.Result;
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.SAXResult;

/**
 * Primary class that drives overall FOP process.
 * <P><B>This class is deprecated and included only for
 * some backwards compatibility with older Fop releases.</B></P>
 * <P>
 * The simplest way to use this is to instantiate it with the
 * InputSource and OutputStream, then set the renderer desired, and
 * calling run();
 * <P>
 * Here is an example use of Driver which outputs PDF:
 *
 * <PRE>
 * Driver driver = new Driver(new InputSource (args[0]),
 * new FileOutputStream(args[1]));
 * driver.setRenderer(RENDER_PDF);
 * driver.run();
 * </PRE>
 * If neccessary, calling classes can call into the lower level
 * methods to setup and render. Methods can be called to set the
 * Renderer to use, the (possibly multiple) ElementMapping(s) to use
 * and the OutputStream to use to output the results of the rendering
 * (where applicable). In the case of the Renderer and
 * ElementMapping(s), the Driver may be supplied either with the
 * object itself, or the name of the class, in which case Driver will
 * instantiate the class itself. The advantage of the latter is it
 * enables runtime determination of Renderer and ElementMapping(s).
 * <P>
 * Once the Driver is set up, the render method is called. Depending
 * on whether DOM or SAX is being used, the invocation of the method
 * is either render(Document) or render(Parser, InputSource)
 * respectively.
 * <P>
 * A third possibility is to call getContentHandler() and firing
 * the SAX events yourself.
 * <P>
 * Here is an example use of Driver which outputs to AWT:
 *
 * <PRE>
 * Driver driver = new Driver();
 * driver.setRenderer(new org.apache.fop.render.awt.AWTRenderer(translator));
 * driver.render(parser, fileInputSource(args[0]));
 * </PRE> */
public class Driver {

    /**
     * Render to PDF. OutputStream must be set
     */
    public static final int RENDER_PDF = 1;

    /**
     * Render to a GUI window. No OutputStream neccessary
     */
    public static final int RENDER_AWT = 2;

    /**
     * Render to MIF. OutputStream must be set
     */
    public static final int RENDER_MIF = 3;

    /**
     * Render to XML. OutputStream must be set
     */
    public static final int RENDER_XML = 4;

    /**
     * Render to PRINT. No OutputStream neccessary
     */
    public static final int RENDER_PRINT = 5;

    /**
     * Render to PCL. OutputStream must be set
     */
    public static final int RENDER_PCL = 6;

    /**
     * Render to Postscript. OutputStream must be set
     */
    public static final int RENDER_PS = 7;

    /**
     * Render to Text. OutputStream must be set
     */
    public static final int RENDER_TXT = 8;

    /**
     * Render to SVG. OutputStream must be set
     */
    public static final int RENDER_SVG = 9;

    /**
     * the FOP object we are encapsulating
     */
    private Fop _fop;

    /**
     * the source of the FO file
     */
    private InputSource _source;

    /**
     * the stream to use to output the results of the renderer
     */
    private OutputStream _stream;

    /**
     * The XML parser to use when building the FO tree
     */
    private XMLReader _reader;

    /**
     * If true, full error stacks are reported
     */
    private boolean _errorDump = false;

    /**
     * the system resources that FOP will use
     */
    private Logger log;

    /**
     * @deprecated
     * @return the class name of the SAX parser
     */
    public static final String getParserClassName() {
        try {
            return javax.xml.parsers.SAXParserFactory.newInstance().newSAXParser().getXMLReader().getClass().getName();
        } catch (javax.xml.parsers.ParserConfigurationException e) {
            return null;
        } catch (org.xml.sax.SAXException e) {
            return null;
        }
    }

    /**
     * @deprecated
     * create a new Driver
     */
    public Driver() {
        _stream = null;
        setupDefaultMappings();
    }

    /**
     * @deprecated
     * create a new Driver
     * @param the input source, @see #setInputSource(InputSource)
     * @param the output stream, @see #setOutputStream(OutputStream)
     */
    public Driver(InputSource source, OutputStream stream) {
        this();
        _source = source;
        _stream = stream;
    }

    /**
     * @deprecated
     * Set the logger
     * @param the logger
     */
    public void setLogger(Logger logger) {
        log = logger;
    }

    private Logger getLogger() {
        if(log == null) {
            log = new ConsoleLogger(ConsoleLogger.LEVEL_INFO);
            log.error("Logger not set");
        }

        return log;
    }

    /**
     * @deprecated
     * Resets the Driver so it can be reused. Property and element
     * mappings are reset to defaults.
     * The output stream is cleared. The renderer is cleared.
     */
    public synchronized void reset() {
        _source = null;
        _stream = null;
        _reader = null;
    }

    /**
     * @deprecated
     * Returns the results of the last rendering process. Information includes
     * the total number of pages generated and the number of pages per
     * page-sequence.
     */
    public FormattingResults getResults() {
        try {
            return _fop.getResults();
        } catch (NullPointerException e) {
            return null;
        }
    }

    /**
     * @deprecated always returns false
     * @return always false
     */
    public boolean hasData() {
        return (false);
    }

    /**
     * @deprecated
     * Set the error dump option
     * @param dump if true, full stacks will be reported to the error log
     */
    public void setErrorDump(boolean dump) {
        _errorDump = dump;
    }

    /**
     * @deprecated
     * Set the OutputStream to use to output the result of the Renderer
     * (if applicable)
     * @param stream the stream to output the result of rendering to
     *
     */
    public void setOutputStream(OutputStream stream) {
        _stream = stream;
    }

    /**
     * @deprecated DocumentInputSource is not supported
     * Set the source for the FO document. This can be a normal SAX
     * InputSource, or an DocumentInputSource containing a DOM document.
     */
    public void setInputSource(InputSource source) {
        _source = source;
    }

    /**
     * @deprecated
     * Sets the reader used when reading in the source. If not set,
     * this defaults to a basic SAX parser.
     */
    public void setXMLReader(XMLReader reader) {
        _reader = reader;
    }

    /**
     * @deprecated not supported any more
     * Sets all the element and property list mappings to their default values.
     */
    public void setupDefaultMappings() {
    }

    /**
     * @deprecated
     * Set the rendering type to use. Must be one of
     * <ul>
     * <li>RENDER_PDF
     * <li>RENDER_AWT
     * <li>RENDER_MIF
     * <li>RENDER_XML
     * <li>RENDER_PCL
     * <li>RENDER_PS
     * <li>RENDER_TXT
     * <li>RENDER_SVG
     * </ul>
     * @param renderer the type of renderer to use
     */
    public void setRenderer(int renderer) throws IllegalArgumentException {
        switch (renderer) {
        case RENDER_PDF:
            _fop = new Fop(Fop.RENDER_PDF);
            break;
        case RENDER_AWT:
            _fop = new Fop(Fop.RENDER_AWT);
            break;
        case RENDER_PRINT:
            _fop = new Fop(Fop.RENDER_PRINT);
            break;
        case RENDER_PCL:
            _fop = new Fop(Fop.RENDER_PCL);
            break;
        case RENDER_PS:
            _fop = new Fop(Fop.RENDER_PS);
            break;
        case RENDER_TXT:
            _fop = new Fop(Fop.RENDER_TXT);
            break;
        case RENDER_MIF:
            _fop = new Fop(Fop.RENDER_MIF);
            break;
        case RENDER_XML:
            _fop = new Fop(Fop.RENDER_XML);
            break;
        case RENDER_SVG:
            _fop = new Fop(Fop.RENDER_SVG);
            break;
        default:
            throw new IllegalArgumentException("Unknown renderer type");
        }

    }

    /**
     * @deprecated not supported any more
     * Set the Renderer to use
     * @param renderer the renderer instance to use
     */
    public void setRenderer(Renderer renderer) {
    }

    /**
     * @deprecated not supported any more
     * @return the current renderer
     */
    public Renderer getRenderer() {
        return null;
    }

    /**
     * @deprecated use renderer.setProducer(version) + setRenderer(renderer) or just setRenderer(renderer_type) which will use the default producer string.
     * @see #setRenderer(int)
     * @see #setRenderer(Renderer)
     */
    public void setRenderer(String rendererClassName, String version) {
        setRenderer(rendererClassName);
    }

    /**
     * @deprecated not supported any more
     * Set the class name of the Renderer to use as well as the
     * producer string for those renderers that can make use of it.
     * @param rendererClassName classname of the renderer to use such as
     * "org.apache.fop.render.pdf.PDFRenderer"
     * @exception IllegalArgumentException if the classname was invalid.
     * @see #setRenderer(int)
     */
    public void setRenderer(String rendererClassName)
        throws IllegalArgumentException {
    }

    /**
     * @deprecated not supported any more
     * Add the given element mapping.
     * An element mapping maps element names to Java classes.
     *
     * @param mapping the element mappingto add
     */
    public void addElementMapping(ElementMapping mapping) {
    }

    /**
     * @deprecated not supported any more
     * add the element mapping with the given class name
     */
    public void addElementMapping(String mappingClassName)
        throws IllegalArgumentException {
    }

    /**
     * @deprecated
     * Returns the tree builder (a SAX ContentHandler).
     *
     * Used in situations where SAX is used but not via a FOP-invoked
     * SAX parser. A good example is an XSLT engine that fires SAX
     * events but isn't a SAX Parser itself.
     * @return the SAX content handler
     */
    public ContentHandler getContentHandler() {
        try {
            _fop.setOutputStream(_stream);
            return _fop.getDefaultHandler();
        } catch (FOPException e) {
        }
        return null;
    }

    /**
     * @deprecated
     * Build the formatting object tree using the given SAX Parser and
     * SAX InputSource
     */
    public synchronized void render(XMLReader parser, InputSource source)
        throws FOPException {
        // Setup output
        _fop.setOutputStream(_stream);

        parser.setContentHandler(_fop.getDefaultHandler());

        try {
            // Start parsing and FOP processing
            // throws SAXException, IOException
            parser.parse(source);
        } catch (SAXException e) {
            if (e.getException() instanceof FOPException) {
                throw (FOPException)e.getException();
            } else {
                throw new FOPException(e);
            }
        }
        catch (IOException e) {
            throw new FOPException(e);
        }
    }

    /**
     * @deprecated
     * Build the formatting object tree using the given DOM Document
     */
    public synchronized void render(Document document)
                throws FOPException {
        // Setup output
        _fop.setOutputStream(_stream);

        // Setup Identity Transformer
        try {
            TransformerFactory factory = TransformerFactory.newInstance();
            Transformer transformer = factory.newTransformer(); // identity transformer

            // Setup input for XSLT transformation
            Source src = new DOMSource(document);

            // Resulting SAX events (the generated FO) must be piped through to FOP
            Result res = new SAXResult(_fop.getDefaultHandler());

            // Start XSLT transformation and FOP processing
            transformer.transform(src, res);
        } catch (TransformerConfigurationException tce) {
            throw new FOPException(tce);
        } catch (TransformerException te) {
            throw new FOPException(te);
        }
    }

    /**
     * @deprecated
     * Dumps an error
     */
    public void dumpError(Exception e) {
        if (_errorDump) {
            Logger log = getLogger();
            if (e instanceof SAXException) {
                log.error("", e);
                if (((SAXException)e).getException() != null) {
                    log.error("", ((SAXException)e).getException());
                }
            } else if (e instanceof FOPException) {
                e.printStackTrace();
                if (((FOPException)e).getException() != null) {
                    log.error("", ((FOPException)e).getException());
                }
            } else {
                log.error("", e);
            }
        }
    }

    /**
     * @deprecated
     * Runs the formatting and renderering process using the previously set
     * inputsource and outputstream
     */
    public synchronized void run() 
    throws IOException, FOPException {
        if (_fop == null) {
            setRenderer(RENDER_PDF);
        }

        if (_source == null) {
            throw new FOPException("InputSource is not set.");
        }

        if (_reader == null) {
            try {
                // Setup SAX parser
                // throws FactoryConfigurationError
                SAXParserFactory factory = SAXParserFactory.newInstance();
                factory.setNamespaceAware(true);
                // throws ParserConfigurationException
                SAXParser parser = factory.newSAXParser();
                _reader = parser.getXMLReader();
            } catch (ParserConfigurationException pce) {
                throw new FOPException(pce);
            } catch (SAXException se) {
                throw new FOPException(se);
            }
        }

        render(_reader, _source);
    }

}

// code stolen from org.apache.batik.util and modified slightly
// does what sun.misc.Service probably does, but it cannot be relied on.
// hopefully will be part of standard jdk sometime.

/**
 * This class loads services present in the class path.
 */
class Service {

    static HashMap providerMap = new HashMap();

    public static synchronized Enumeration providers(Class cls) {
        ClassLoader cl = cls.getClassLoader();
        String serviceFile = "META-INF/services/" + cls.getName();

        // System.out.println("File: " + serviceFile);

        Vector v = (Vector)providerMap.get(serviceFile);
        if (v != null)
            return v.elements();

        v = new Vector();
        providerMap.put(serviceFile, v);

        Enumeration e;
        try {
            e = cl.getResources(serviceFile);
        } catch (IOException ioe) {
            return v.elements();
        }

        while (e.hasMoreElements()) {
            try {
                java.net.URL u = (java.net.URL)e.nextElement();
                // System.out.println("URL: " + u);

                InputStream is = u.openStream();
                InputStreamReader r = new InputStreamReader(is, "UTF-8");
                BufferedReader br = new BufferedReader(r);

                String line = br.readLine();
                while (line != null) {
                    try {
                        // First strip any comment...
                        int idx = line.indexOf('#');
                        if (idx != -1)
                            line = line.substring(0, idx);

                        // Trim whitespace.
                        line = line.trim();

                        // If nothing left then loop around...
                        if (line.length() == 0) {
                            line = br.readLine();
                            continue;
                        }
                        // System.out.println("Line: " + line);

                        // Try and load the class
                        // Object obj = cl.loadClass(line).newInstance();
                        // stick it into our vector...
                        v.add(line);
                    } catch (Exception ex) {
                        // Just try the next line
                    }

                    line = br.readLine();
                }
            } catch (Exception ex) {
                // Just try the next file...
            }

        }
        return v.elements();
    }

}