/*
 * Copyright (c) 2003-2010 The Regents of the University of California.
 * All rights reserved.
 *
 * '$Author: crawl $'
 * '$Date: 2018-05-25 18:38:49 +0000 (Fri, 25 May 2018) $' 
 * '$Revision: 34695 $'
 * 
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the above
 * copyright notice and the following two paragraphs appear in all copies
 * of this software.
 *
 * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 * FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 * THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 * PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 * CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 * ENHANCEMENTS, OR MODIFICATIONS.
 *
 */

package org.kepler.reporting.rio.fop;

import java.awt.Component;
import java.awt.Dimension;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.spi.IIORegistry;
import javax.swing.JFrame;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.fop.apps.FOPException;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopFactory;
import org.apache.fop.apps.MimeConstants;
import org.apache.fop.render.awt.AWTRenderer;
import org.apache.fop.render.awt.viewer.PreviewPanel;
import org.kepler.reporting.rio.ReportInstance;
import org.kepler.reporting.rio.test.ReportTest;
import org.kepler.reporting.roml.ReportLayout;

/**
 * This class converts a report object to XML, PDF, and AWT using JAXP (XSLT)
 * and FOP (XSL:FO).
 */
public class ReportRenderer {

        private static final String DEFAULT_XSLT = "/xslt/rio2fo.xsl";

        public static Log log = LogFactory.getLog(ReportRenderer.class);

        // configure fopFactory as desired
        private static FopFactory fopFactory = FopFactory.newInstance();

        static {
                reorderPNGReaders();
        }
        
        public static void reorderPNGReaders() {
                Iterator<ImageReader> imageIter = ImageIO.getImageReadersByMIMEType("image/png");
        
                log.debug("--------- IMAGE READERS BEFORE ----------");
        while (imageIter.hasNext()) {
                ImageReader imageReader = imageIter.next();
                log.debug(imageReader);
        }
        
        /* com.sun.imageio.plugins.png.PNGImageReaderSpi.class no longer accessible in Java 9.


        Class category = javax.imageio.spi.ImageReaderSpi.class;

        Class firstProviderClass = com.sun.imageio.plugins.png.PNGImageReaderSpi.class;
                Object firstProvider = IIORegistry.getDefaultInstance().getServiceProviderByClass(firstProviderClass);
                
                Class secondProviderClass = com.sun.media.imageioimpl.plugins.png.CLibPNGImageReaderSpi.class;
                Object secondProvider = IIORegistry.getDefaultInstance().getServiceProviderByClass(secondProviderClass);
                
                if (firstProvider !=null && secondProvider != null) {
                        IIORegistry.getDefaultInstance().setOrdering(category, firstProvider, secondProvider);
                }
        */
                
                //AFTER
                imageIter = ImageIO.getImageReadersByMIMEType("image/png");
        log.debug("--------- IMAGE READERS AFTER ----------");
        while (imageIter.hasNext()) {
                ImageReader imageReader = imageIter.next();
                log.debug(imageReader);
        }
                
        }
        
        /**
         * Converts a Report object to a PDF file.
         * 
         * @param report
         *            the Report object
         * @param pdf
         *            the target PDF file
         * @param xsltStream
         *            the stylesheet input stream
         * @throws IOException
         *             In case of an I/O problem
         * @throws FOPException
         *             In case of a FOP problem
         * @throws TransformerException
         *             In case of a XSL transformation problem
         */
        public static void convertReport2PDF(ReportInstance report, File pdf, InputStream xsltStream)
                        throws IOException, FOPException, TransformerException {
                
                if (xsltStream == null) {
                        // look up the stylesheet for generating the PDF
                        xsltStream =  report.getClass().getResourceAsStream(DEFAULT_XSLT);
                }
                
                FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
                // configure foUserAgent as desired

                // Setup output
                OutputStream out = new java.io.FileOutputStream(pdf);
                out = new java.io.BufferedOutputStream(out);
                try {
                        // Construct fop with desired output format
                        Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent,
                                        out);

                        // Setup XSLT
                        TransformerFactory factory = TransformerFactory.newInstance();
                        Transformer transformer = factory.newTransformer(new StreamSource(
                                        xsltStream));

                        // Set the value of a <param> in the stylesheet
                        //TODO: this will be very useful, remember it!
            //transformer.setParameter("myParamName", "myValue");
            
                        // Setup input for XSLT transformation
                        Source src = ReportInputSource.getSourceForReport(report);

                        // 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);
                        
                } finally {
                        out.close();
                }
        }

        
        public static ReportLayout convertXML2Report(File xml) throws IOException,
                TransformerException {
                // Setup input
                Source src = new StreamSource(xml);
                return convertXML2Report(src);
        }
        
        public static ReportLayout convertXML2Report(InputStream xml) throws IOException,
                TransformerException {
                // Setup input
                Source src = new StreamSource(xml);
                return convertXML2Report(src);
        }
        
        /**
         * Converts a Report object to XML.
         * 
         * @param report
         *            the Report object
         * @param xml
         *            the target XML file
         * @throws IOException
         *             In case of an I/O problem
         * @throws TransformerException
         *             In case of a XSL transformation problem
         * @throws ClassNotFoundException 
         * @throws IllegalAccessException 
         * @throws InstantiationException 
         */
        private static ReportLayout convertXML2Report(Source src) throws IOException,
                        TransformerException {
                        
                // Setup XSLT
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer();
                /*
                 * Note: We use the identity transformer, no XSL transformation is done.
                 * The transformer is basically just used to deserialize the XML to objects
                 */
        
                // Setup output
                DOMResult res = new DOMResult();
        
                // Start XSLT transformation
                transformer.transform(src, res);
                
                ReportLayout report = null;
                try {
                        report = ReportParser.parse(res.getNode());
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } 
                
                return report;
        }
        
        public static void convertReport2XML(ReportLayout report, File xml) throws IOException,
                        TransformerException {
                convertReport2XML(report, new FileOutputStream(xml));
        }
        
        /**
         * Converts a Report object to XML.
         * 
         * @param report
         *            the Report object
         * @param xml
         *            the target XML file
         * @throws IOException
         *             In case of an I/O problem
         * @throws TransformerException
         *             In case of a XSL transformation problem
         */
        public static void convertReport2XML(ReportLayout report, OutputStream xml) throws IOException,
                        TransformerException {

                // Setup XSLT
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer();
                /*
                 * Note: We use the identity transformer, no XSL transformation is done.
                 * The transformer is basically just used to serialize the generated
                 * document to XML.
                 */

                // Setup input
                Source src = ReportInputSource.getSourceForReport(report);

                // Setup output
                // Result res = new StreamResult(xml);
                Result res = new StreamResult(new BufferedOutputStream(xml));

                // Start XSLT transformation
                transformer.transform(src, res);
        }

        /**
         * Converts an XML file to an XSL-FO file using JAXP (XSLT).
         * 
         * @param xml
         *            the XML file
         * @param xslt
         *            the stylesheet file
         * @param fo
         *            the target XSL-FO file
         * @throws IOException
         *             In case of an I/O problem
         * @throws TransformerException
         *             In case of a XSL transformation problem
         */
        public static void convertXML2FO(File xml, File xslt, File fo) throws IOException,
                        TransformerException {

                // Setup output
                OutputStream out = new java.io.FileOutputStream(fo);
                try {
                        // Setup XSLT
                        TransformerFactory factory = TransformerFactory.newInstance();
                        Transformer transformer = factory.newTransformer(new StreamSource(
                                        xslt));

                        // Setup input for XSLT transformation
                        Source src = new StreamSource(xml);

                        // Resulting SAX events to XML
                        Result res = new StreamResult(out);

                        // Start XSLT transformation and FOP processing
                        transformer.transform(src, res);
                } finally {
                        out.close();
                }
        }

        public static void convertReport2FO(ReportInstance report, File xslt, File fo) throws IOException, TransformerException {
                
                // Setup output
                OutputStream out = new java.io.FileOutputStream(fo);
                try {
                        // Setup XSLT
                        TransformerFactory factory = TransformerFactory.newInstance();
                        Transformer transformer = factory.newTransformer(new StreamSource(xslt));
                
                        // Setup input for XSLT transformation
                        Source src = ReportInputSource.getSourceForReport(report);
                
                        // Resulting SAX events to FO
                        Result res = new StreamResult(out);
                
                        // Start XSLT transformation and FOP processing
                        transformer.transform(src, res);
                } finally {
                        out.close();
                }
        }
        
        /**
         * Renders the Report object in the default FOP viewer. Not intended to be embedded.
         * @deprecated
         * @see convertReport2AWT() for an embedded soltion.
         * 
         * @param report Report to render
         * @param xslt the transform to use for rendering the Report
         * @throws IOException
         * @throws FOPException
         * @throws TransformerException
         */
        public void renderReportAsAWT(ReportInstance report, File xslt)
                        throws IOException, FOPException, TransformerException {

                FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
                // configure foUserAgent as desired

                // Construct fop with desired output format
                Fop fop = fopFactory.newFop(MimeConstants.MIME_FOP_AWT_PREVIEW, foUserAgent);

                // Setup XSLT
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer(new StreamSource(xslt));

                // Setup input for XSLT transformation
                Source src = ReportInputSource.getSourceForReport(report);

                // 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);

        }

        /**
         * Used for embedding a viewer pane in swing applications
         * @param report Report to render
         * @param xslt transform to use for rendering Report
         * @return PreviewPane component that can be added to any GUI
         * @throws IOException
         * @throws FOPException
         * @throws TransformerException
         */
        public static Component convertReport2AWT(ReportInstance report, InputStream xslt)
                throws IOException, FOPException, TransformerException {
                                
                FOUserAgent foUserAgent = fopFactory.newFOUserAgent();
                // configure foUserAgent as desired
        
                AWTRenderer renderer = new AWTRenderer();
                foUserAgent.setRendererOverride(renderer);
                renderer.setPreviewDialogDisplayed(false);
                renderer.setUserAgent(foUserAgent);
                renderer.clearViewportList();
                 
                // Construct fop with no output format since we supply the renderer
                Fop fop = fopFactory.newFop(foUserAgent);
                
                // Setup XSLT
                TransformerFactory factory = TransformerFactory.newInstance();
                Transformer transformer = factory.newTransformer(new StreamSource(xslt));
        
                // Setup input for XSLT transformation
                Source src = ReportInputSource.getSourceForReport(report);
        
                // 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);
                
                // construct the panel to render the processed FO
                PreviewPanel previewPanel = new PreviewPanel(foUserAgent, null, renderer);
                //double scale = previewPanel.getScaleToFitWindow();
                //previewPanel.setScaleFactor(scale);
                previewPanel.setDisplayMode(PreviewPanel.CONTINUOUS);

                return previewPanel;
        }
        
        /**
         * Converts a Report object to a PDF file.
         * 
         * @param report
         *            the Report object
         * @param xslt
         *            the stylesheet file
         * @param html
         *            the target HTML file
         * @throws IOException
         *             In case of an I/O problem
         * @throws FOPException
         *             In case of a FOP problem
         * @throws TransformerException
         *             In case of a XSL transformation problem
         */
        public static void convertReport2HTML(ReportInstance report, File xslt, File html)
                        throws IOException, TransformerException {
        
                // Setup output
                OutputStream out = new java.io.FileOutputStream(html);
                out = new java.io.BufferedOutputStream(out);
                try {
                
                        // Setup XSLT
                        TransformerFactory factory = TransformerFactory.newInstance();
                        Transformer transformer = factory.newTransformer(new StreamSource(xslt));
        
                        // Setup input for XSLT transformation
                        Source src = ReportInputSource.getSourceForReport(report);
        
                        // Resulting SAX events sent to HTML
                        Result res = new StreamResult(out);
        
                        // Start XSLT transformation
                        transformer.transform(src, res);
                        
                } finally {
                        out.close();
                }
        }

        private static void showPreviewPanel(Component previewPanel) {
                
                //show the preview panel
                JFrame frame = new JFrame("my frame");
                
                Dimension dim = new Dimension(612, 792);
                frame.setPreferredSize(dim);
                frame.setMaximumSize(dim);
                frame.setMinimumSize(dim);
                frame.setSize(dim);
                
                frame.add(previewPanel);
                
                frame.validate();
                frame.setVisible(true);
        }

        /**
         * Main method.
         * 
         * @param args
         *            command-line arguments
         */
        public static void main(String[] args) {
                try {
                        log.debug("FOP Conversion");
                        log.debug("Preparing...");

                        // Setup directories
                        File baseDir = new File(".");
                        File outDir = new File(baseDir, "out");
                        outDir.mkdirs();

                        // Setup input and output
                        File xsltfile = new File(baseDir, "lib/xslt/rio2fo.xsl");
                        ///File xsltHTMLfile = new File(baseDir, "lib/xslt/rio2html.xsl");
                        ///File xmlfile = new File(outDir, "Report2XML.xml");
                        ///File htmlfile = new File(outDir, "Report2HTML.html");
                        ///File fofile = new File(outDir, "Report2FO.fo");
                        File pdffile = new File(outDir, "Report2PDF.pdf");

                        log.debug("Input: a Report object");
                        log.debug("Stylesheet: " + xsltfile);
                        log.debug("Output: PDF (" + pdffile + ")");
                        log.debug("Transforming...");

                        //ReportInstance report = ReportTest.makeReport();
                        ReportLayout reportLayout = ReportTest.makeReportLayout();
                        ReportInstance report = new ReportInstance(reportLayout);
                        // test that the copy constructor actually works
                        reportLayout.setTitle("BLAH!");
                        reportLayout.getSections().clear();
//                      ReportRenderer.convertReport2XML(report, xmlfile);
//                      ReportRenderer.convertReport2FO(report, xsltfile, fofile);
//                      ReportConverter.convertXML2FO(xmlfile, xsltfile, fofile);
//                      ReportRenderer.convertReport2PDF(report, pdffile, xsltfile);
//                      ReportRenderer.convertReport2HTML(report, xsltHTMLfile, htmlfile);
//                      ReportRenderer.convertXML2Report(xmlfile);
                        showPreviewPanel(ReportRenderer.convertReport2AWT(report, new FileInputStream(xsltfile)));
                        
                        log.debug("Success!");
                } catch (Exception e) {
                        e.printStackTrace(System.err);
                        System.exit(-1);
                }
        }
}