package de.superx.bin;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.StringReader;
import java.io.Writer;
import java.net.URI;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Types;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.URIResolver;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.Transformer;

import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.apps.Fop;
import org.apache.fop.apps.FopConfParser;
import org.apache.fop.apps.FopFactory;
import org.apache.fop.apps.FopFactoryBuilder;
import org.apache.fop.apps.MimeConstants;
import org.jfor.jfor.converter.Converter;
import org.xml.sax.InputSource;

import de.superx.common.TransletCache;
import de.superx.util.SqlStringUtils;

// ACHTUNG - PDF ERZEUGUNG WIEDER AKTIV DQ 27.12.2005!!!

/**
 * @author Daniel Quathamer Projektgruppe SuperX SxTransformer.java @ Dieses
 *         Javaprogramm transformiert ResultSets in text, html oder xml und gibt
 *         das Ergebnis als Ausgabestrom für stdout oder eine Datei aus.
 * 
 * 
 *  
 */
public class SxTransformer {

    /**
     *  
     */
    private String head_delim1 = "";

    private String head_delim2 = "\t";

    private String header_delim1 = "";

    private String header_delim2 = "\n";

    private String fld_delim1 = "";

    private String fld_delim2 = "\t";

    private String row_delim1 = "";

    private String row_delim2 = "\n";//we only user unix newline, even under
    // DOS

    private String rs_delim1 = "";

    private String rs_delim2 = "";

    private String delim = "\t";

    private String header = "false";

    private String outHeader = "";

    private String outFooter = "";

    public String format = "txt";

    public String params = "";

    public String[] XslPipeline;

    public String stylesheet = "";

    public PrintWriter myOutwriter;

    public OutputStream myOutputStream;

    public ResultSet outrs = null;

    public ResultSetMetaData outrsmd = null;

    public String quellstring = null;

    public String outfile = "";
    private File fopxconfFile=null;
    public void setFopxconfFile(File fopxconfFile) {
		this.fopxconfFile = fopxconfFile;
	}
    public String mandantenID;
	Logger myLogger;

    String loglevel;

    //PrintStream outputstream=null;

    //TODO ggfs. auf Saxon umstellen
    //TransletUtils.initFactory("net.sf.saxon.TransformerFactoryImpl",
    //		"org.apache.xalan.xsltc.trax.TransformerFactoryImpl");
    //System.out.println("Using xsl processor: "
    //		+ TransletUtils.getUsedProcessor());
    public SxTransformer(Logger logger, PrintStream myStream) {
        super();
        myLogger = logger;
        myLogger.config("Starting the Transformer with Stdout-Output.");
        myOutwriter = new PrintWriter(myStream);
    }

    public SxTransformer(Logger logger, String myFile) {
        super();
        myLogger = logger;
        myLogger.config("Starting the Transformer with File-Output.");
        outfile = myFile;
        myLogger.setLevel(Level.SEVERE);

    }

    public SxTransformer(Logger logger, FileWriter myFilewriter) {
        super();
        myLogger = logger;
        myLogger.config("Starting the Transformer with File-Output.");
        myOutwriter = new PrintWriter(new BufferedWriter(myFilewriter));
    }

    public SxTransformer(Logger logger) {
        super();
        myLogger = logger;
        myLogger.config("Starting the Transformer without Stream");
    }

    public void printResult(String outFormat) {
        //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
        assignDelims(outFormat);
        myLogger.config("Resultset wird formatiert");
        String f_wert = "";
        //ResultSetMetaData rsmd = rs.getMetaData();

        String zs = "";
        String headZs = "";
        int cols = 0;
        Object o = null;
        String[] lbl = null;
        int[] types = new int[255];
        // de.memtext.util.MemoryUtils.printfree();
        if (outrs != null) {

            try {
                cols = outrsmd.getColumnCount();
                lbl = new String[255];
                zs = outHeader + rs_delim1;
                headZs = header_delim1;
                ;
                // Print the result column names?
                for (int i = 1; i <= cols; i++) {
                    lbl[i] = outrsmd.getColumnLabel(i);
                    types[i] = outrsmd.getColumnType(i);
                    if (outFormat.equals("xml")) {
                        fld_delim1 = "<fld name='" + lbl[i] + "'>";
                        fld_delim2 = "</fld>";
                    } else {

                        if (i < cols)
                            headZs += (head_delim1 + lbl[i] + head_delim2);
                        else {
                            headZs += (head_delim1 + lbl[i] + head_delim2);
                            headZs += (header_delim2);
                            //out.newLine();
                        }
                    }
                }
            } catch (SQLException e1) {
                myLogger.severe("Fehler beim Einlesen der Feldnamen: " + e1.toString());
                e1.printStackTrace();
            }
            if (header.equals("true")) zs += headZs;

            // try {
            myOutwriter.write(zs);
            myOutwriter.flush();
            /*
             * } catch (IOException e) { myLogger.severe("Fehler beim Ausgeben
             * der Feldnamen: " + e.toString());
             *  }
             */

            //now the results
            StringBuffer line = new StringBuffer();
            try {
                int rowCounter = 0;

                do {

                    line.setLength(0);

                    line.append(row_delim1);
                    for (int i = 1; i <= cols; i++) {
                        if (outFormat.equals("xml")) {
                            fld_delim1 = "<fld name='" + lbl[i] + "'>";
                            fld_delim2 = "</fld>";
                        }
                        if (types[i] == Types.LONGVARCHAR) {
                            //Der Informix-Treiber verlangt hier getString
                            // statt getObject!
                            o = outrs.getString(i);
                        } else {
                            o = outrs.getObject(i);
                        }
                        if (outrs.wasNull())
                            if (i < cols)
                                line.append(fld_delim1 + "" + fld_delim2);
                            else {
                                line.append(fld_delim1 + "" + fld_delim2);
                                line.append(row_delim2);
                                //out.newLine();
                            }
                        else {
                            //vergl. de.superx.common.Maske.getCSV
                            f_wert = SxDBUtils.field_value(o);
                            if (outFormat.equals("xml") && (f_wert.indexOf("&") > -1 || f_wert.indexOf("<") > -1 || f_wert.indexOf(">") > -1))
                                f_wert = "<![CDATA[" + f_wert + "]]>";
                            //wenn der Feldwert zufällig das Trennzeichen enthält, wird es mit "\" maskiert
                            if (outFormat.equals("txt")) {
                                f_wert = SxDBUtils.prepareInformixCsv(f_wert);
                                if (f_wert != null && (f_wert.indexOf(fld_delim2) > -1)) f_wert = de.memtext.util.StringUtils.replace(f_wert, fld_delim2, "\\" + fld_delim2);
                            }
                            if (i < cols)
                                line.append(fld_delim1 + f_wert + fld_delim2);
                            else {
                                line.append(fld_delim1 + f_wert + fld_delim2);
                                line.append(row_delim2);
                            }
                        }
                    }
                    myOutwriter.write(line.toString());
                    rowCounter++;
                    if (rowCounter > 10000) {
                        de.memtext.util.MemoryUtils.printfree();
                        myOutwriter.flush();

                        rowCounter = 0;
                    }
                } while (outrs.next()); //von while

                myOutwriter.write(rs_delim2 + outFooter);

                myOutwriter.flush();
                outrs.close();
                myOutwriter.close();

            } /*
               * catch (IOException e) { myLogger.severe("Fehler beim Ausgeben
               * der Feldwerte: " + e.toString()); }
               */
            catch (SQLException e) {
                myLogger.warning("SQL-Fehler beim Ausgeben der Feldwerte: " + e.toString());
                try {
                    myOutwriter.write(rs_delim2 + outFooter);
                    myOutwriter.flush();
                    myOutwriter.close();
                    outrs.close();
                }
                /*
                 * catch (IOException e1) { myLogger.severe("Fehler beim
                 * Ausgeben der Feldwerte: " + e1.toString()); }
                 */
                catch (SQLException e1) {
                    myLogger.warning("SQL-Fehler beim Ausgeben der Feldwerte: " + e1.toString());
                }
            }

        }

        else //wenn outrs=null
        {

            myOutwriter.flush();
            myOutwriter.close();

        }
        myLogger.info("resultset printed");

    }

    public void transformString(String methode) throws TransformerException {
        try {

            javax.xml.transform.TransformerFactory tFactory = javax.xml.transform.TransformerFactory.newInstance();

            javax.xml.transform.Transformer transformer = tFactory.newTransformer(new javax.xml.transform.stream.StreamSource(stylesheet));
            StringReader s1 = new StringReader(quellstring);
            transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, SqlStringUtils.getEncoding());
            transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, methode);
            transformer.setParameter("sx_client", format);
            String result = null;
            if (!params.endsWith(",")) params += ",";
            StringTokenizer st = new StringTokenizer(params, ",");
            for (; st.hasMoreTokens();) {
                String param = st.nextToken();
                if (!param.equals("")) {
                    String paramname = param.substring(0, param.indexOf("="));
                    String paramvalue = param.substring(param.indexOf("=") + 1, param.length());
                    transformer.setParameter(paramname, paramvalue);
                }
            }
            transformer.transform(new javax.xml.transform.stream.StreamSource(s1), new javax.xml.transform.stream.StreamResult(myOutwriter));
        } catch (Exception e) {
            myLogger.severe("XSL-Transformation fehlgeschlagen: " + e.toString());

        }

    }

    public void transformFile(String methode) throws TransformerException, Exception
    {
    	  
        /*javax.xml.transform.TransformerFactory tFactory = javax.xml.transform.TransformerFactory.newInstance("net.sf.saxon.TransformerFactoryImpl", null);

        javax.xml.transform.Transformer transformer = tFactory.newTransformer(new javax.xml.transform.stream.StreamSource(this.stylesheet));*/
    	Transformer transformer = TransletCache.getTransformer(this.mandantenID, this.stylesheet);
        //StringReader s1 = new StringReader(quellstring);
        transformer.setOutputProperty(javax.xml.transform.OutputKeys.ENCODING, SqlStringUtils.getEncoding());
        if (methode.equals("pdf") || methode.equals("rtf"))
            transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, "xml");
        else
            transformer.setOutputProperty(javax.xml.transform.OutputKeys.METHOD, methode);

        transformer.setParameter("sx_client", format);
        transformer.setParameter("versionParam", "2.0");

        //        String result = null;
        if (!params.endsWith(",")) params += ",";
        StringTokenizer st = new StringTokenizer(params, ",");
        for (; st.hasMoreTokens();) {
            String param = st.nextToken();
            if (!param.equals("")) {
                String paramname = param.substring(0, param.indexOf("="));
                String paramvalue = param.substring(param.indexOf("=") + 1, param.length());
                transformer.setParameter(paramname, paramvalue);
            }
        }

        if (methode.equals("pdf")) { //Sichern um zurücksetzen zu können.
            Level logLevel = myLogger.getParent().getLevel();
            myLogger.getParent().setLevel(Level.SEVERE);

            // configure fopFactory as desired
            //akt. Pfad muss WEB-INF sein oder vorher als -fopxconf Param übergeben worden sein
         
           
            FopFactory fopFactory ;  
            FOUserAgent foUserAgent;
          
            // in fop.xconf fopFactory.setSourceResolution(96); // =96dpi (dots/pixels per Inch)
            if (fopxconfFile==null)
            	fopxconfFile=new File ("conf" + File.separator + "fop.xconf");
        if (!fopxconfFile.exists()) 
        	{
        	String msg=fopxconfFile.getAbsolutePath()+" nicht gefunden";
        	System.out.println(msg);
        	throw new IllegalStateException(msg);
        	}
            	 
            	  FopConfParser parser = new FopConfParser(fopxconfFile); //parsing configuration  
            	  
      	        FopFactoryBuilder builder = parser.getFopFactoryBuilder(); //building the factory with the user options
      	      String fa=fopxconfFile.getCanonicalPath();
      	    
      	        URI uri=new File(fa).getParentFile().getParentFile().toURI();
      	   //   System.out.println(uri);
      	        builder.setBaseURI(uri);
      	        builder.setStrictFOValidation(false);
      				 fopFactory = builder.build();
      				
      				 foUserAgent = fopFactory.newFOUserAgent();
           

            try {
                myOutputStream = new java.io.FileOutputStream(outfile);
            } catch (FileNotFoundException e) {
                myLogger.severe("Ausgabedatei " + outfile + " kann nicht erzeugt werden:" + e.toString());
                System.exit(-1);
            }

            try {
                // Construct fop with desired output format
                Fop fop = fopFactory.newFop(MimeConstants.MIME_PDF, foUserAgent, myOutputStream);

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

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

                // Start XSLT transformation and FOP processing
                try {
                    transformer.transform(src, res);
                    System.out.println("Success!");
                } catch (TransformerException ex) {
                    throw new Exception(ex);
                }
            } catch (Exception e) {
                e.printStackTrace(System.err);
                myLogger.severe("FOP-Transformation Fehler: " + e.toString());
            } finally {
                myOutputStream.close();
                myLogger.getParent().setLevel(logLevel);
            }

        } else {
            if (methode.equals("rtf")) {
                String zielstring = "";
                myLogger.info("Ausgabedatei " + outfile + " vorbereiten");
                Writer myWriter = null;
                try {
                    myWriter = new BufferedWriter(new FileWriter(outfile));
                } catch (IOException e) {
                    e.printStackTrace();
                }
                try {
                    myLogger.info("Transformiere nach fo ");
                    transformer.transform(new javax.xml.transform.stream.StreamSource(quellstring), new StreamResult("tmp.fo"));

                    myLogger.info("Transformiere nach rtf ");

                    new Converter(new InputSource("tmp.fo"), myWriter, Converter.createConverterOption());
                } catch (Exception e1) {

                    e1.printStackTrace();
                }
            } else {
                if (methode.equals("xls")) {

                } else {
                    //Normal xml Transformation, not fop or rtf
                    try {

                        FileWriter myFile = new FileWriter(outfile);
                        myOutwriter = new PrintWriter(myFile);
                        transformer.transform(new javax.xml.transform.stream.StreamSource(quellstring), new javax.xml.transform.stream.StreamResult(myOutwriter));
                    } catch (IOException e) {
                        myLogger.severe("Datei " + outfile + " kann nicht erzeugt werden: " + e.toString());
                    } catch (TransformerException e) {
                        myLogger.severe("Datei " + outfile + " kann nicht transformiert werden: " + e.toString());
                    }
                    //new javax.xml.transform.stream.StreamResult( myOutwriter));
                }
            }
        }
       
    }

    public void outputString() {
        BufferedWriter out = new BufferedWriter(myOutwriter);
        try {
            out.write(quellstring);
            out.flush();
        } catch (IOException e) {
            myLogger.severe("Fehler beim Ausgeben des Ergebnisses: " + e.toString());
        }

    }

    public String getResult(String outFormat) throws SQLException {

        //loglevel=myLogger.getRootLogger().getLevel().toString().trim();
        assignDelims(outFormat);
        myLogger.config("Resultset wird formatiert");
        String f_wert = "";
        //ResultSetMetaData rsmd = rs.getMetaData();
        int cols = outrsmd.getColumnCount();
        String[] lbl = new String[255];
        String zs = rs_delim1;
        String headZs = header_delim1;
        ;
        // Print the result column names?
        for (int i = 1; i <= cols; i++) {
            lbl[i] = outrsmd.getColumnLabel(i);
            if (outFormat.equals("xml")) {
                fld_delim1 = "<fld name='" + lbl[i].toLowerCase() + "'>";
                fld_delim2 = "</fld>";
            } else {

                if (i < cols)
                    headZs += (head_delim1 + lbl[i] + head_delim2);
                else {
                    headZs += (head_delim1 + lbl[i] + head_delim2);
                    headZs += (header_delim2);
                    //out.newLine();
                }
            }
        }
        if (header.equals("true")) zs += headZs;

        //now the results
        try {
            while (outrs.next())

            {
                zs += (row_delim1);
                for (int i = 1; i <= cols; i++) {
                    Object o = outrs.getObject(i);
                    f_wert = SxDBUtils.field_value(o);
                    if (outFormat.equals("xml")) {
                        fld_delim1 = "<fld name='" + lbl[i].toLowerCase() + "'>";
                        fld_delim2 = "</fld>\n";
                    }
                    if (outrs.wasNull())
                        if (i < cols)
                            zs += (fld_delim1 + "" + fld_delim2);
                        else {
                            zs += (fld_delim1 + "" + fld_delim2);
                            zs += (row_delim2);
                            //out.newLine();
                        }
                    else if (i < cols)
                        zs += (fld_delim1 + f_wert.trim() + fld_delim2);
                    else {
                        zs += (fld_delim1 + f_wert.trim() + fld_delim2);
                        zs += (row_delim2);

                        //						out.newLine();
                    }

                    //				}
                    //				catch (IOException e)
                    //				{
                    //				myLogger.severe("Fehler beim Ausgeben der Feldwerte:
                    // "+e.toString());
                    //					
                    //				}

                }
            } //von while
            zs += (rs_delim2);

        } catch (Exception e) {
            myLogger.severe("Fehler beim Ausgeben der Feldwerte: " + e.toString());
        }
        outrs.close();

        return zs;
    }

    private void assignDelims(String outFormat) {
        if (outFormat.equals("html")) {
            outHeader = "<html><body>";
            outFooter = "</body></html>";
            rs_delim1 = "<table border='1'>\n";
            rs_delim2 = "</table>";
            head_delim1 = "<th>";
            head_delim2 = "</th>";
            header_delim1 = "<tr>";
            header_delim2 = "</tr>\n";
            row_delim1 = "<tr>";
            row_delim2 = "</tr>";
            fld_delim1 = "<td>";
            fld_delim2 = "</td>";
        }
        if (outFormat.equals("xml")) {
            outHeader = "<?xml version='1.0' encoding='" + SqlStringUtils.getEncoding() + "'?>";
            outFooter = "";
            rs_delim1 = "<rs>\n";
            rs_delim2 = "</rs>";
            head_delim1 = "";
            head_delim2 = "";
            header_delim1 = "";
            header_delim2 = "";
            row_delim1 = "<row>\n";
            row_delim2 = "</row>\n";
            fld_delim1 = "";
            fld_delim2 = "";
        }
    }

    /**
     * @return
     */
    public String getDelim() {
        return delim;
    }

    /**
     * @return
     */
    public String getFld_delim1() {
        return fld_delim1;
    }

    /**
     * @return
     */
    public String getFld_delim2() {
        return fld_delim2;
    }

    /**
     * @return
     */
    public String getFormat() {
        return format;
    }

    /**
     * @return
     */
    public String getHead_delim1() {
        return head_delim1;
    }

    /**
     * @return
     */
    public String getHead_delim2() {
        return head_delim2;
    }

    /**
     * @return
     */
    public String getHeader() {
        return header;
    }

    /**
     * @return
     */
    public String getHeader_delim1() {
        return header_delim1;
    }

    /**
     * @return
     */
    public String getHeader_delim2() {
        return header_delim2;
    }

    /**
     * @return
     */
    public ResultSet getOutrs() {
        return outrs;
    }

    /**
     * @return
     */
    public ResultSetMetaData getOutrsmd() {
        return outrsmd;
    }

    /**
     * @return
     */
    public String getRow_delim1() {
        return row_delim1;
    }

    /**
     * @return
     */
    public String getRow_delim2() {
        return row_delim2;
    }

    /**
     * @return
     */
    public String getRs_delim1() {
        return rs_delim1;
    }

    /**
     * @return
     */
    public String getRs_delim2() {
        return rs_delim2;
    }

    /**
     * @return
     */
    public String[] getXslPipeline() {
        return XslPipeline;
    }

    /**
     * @param string
     */
    public void setDelim(String string) {
        delim = string;
        fld_delim1 = "";
        fld_delim2 = string;
        head_delim2 = string;
    }

    /**
     * @param string
     */
    public void setFld_delim1(String string) {
        fld_delim1 = string;
    }

    /**
     * @param string
     */
    public void setFld_delim2(String string) {
        fld_delim2 = string;
    }

    /**
     * @param string
     */
    public void setFormat(String string) {
        format = string;
    }

    /**
     * @param string
     */
    public void setHead_delim1(String string) {
        head_delim1 = string;
    }

    /**
     * @param string
     */
    public void setHead_delim2(String string) {
        head_delim2 = string;
    }

    /**
     * @param string
     */
    public void setHeader(String string) {
        header = string;
    }

    /**
     * @param string
     */
    public void setHeader_delim1(String string) {
        header_delim1 = string;
    }

    /**
     * @param string
     */
    public void setHeader_delim2(String string) {
        header_delim2 = string;
    }

    /**
     * @param set
     */

    public void setOutrs(ResultSet set) {
        outrs = set;
    }

    /**
     * @param data
     */
    public void setOutrsmd(ResultSetMetaData data) {
        outrsmd = data;
    }

    /**
     * @param string
     */
    public void setRow_delim1(String string) {
        row_delim1 = string;
    }

    /**
     * @param string
     */
    public void setRow_delim2(String string) {
        row_delim2 = string;
    }

    /**
     * @param string
     */
    public void setRs_delim1(String string) {
        rs_delim1 = string;
    }

    /**
     * @param string
     */
    public void setRs_delim2(String string) {
        rs_delim2 = string;
    }

    /**
     * @param strings
     */
    public void setXslPipeline(String[] strings) {
        XslPipeline = strings;
    }

    /**
     * @return
     */
    public String getOutFooter() {
        return outFooter;
    }

    /**
     * @return
     */
    public String getOutHeader() {
        return outHeader;
    }

    /**
     * @param string
     */
    public void setOutFooter(String string) {
        outFooter = string;
    }

    /**
     * @param string
     */
    public void setOutHeader(String string) {
        outHeader = string;
    }

    /**
     * @return
     */
    public String getParams() {
        return params;
    }

    /**
     * @param string
     */
    public void setParams(String string) {
        params = string;
    }

    //-- nur zum Testen --//
    public static void main(String[] args) throws Exception {
        Logger log = Logger.getLogger(SxTransformer.class.getName());
        String rootDir = "/home/superx/tmp/";
        String quelle = rootDir + "Buchungsbericht_ids_Test.xml";
        String zielFile = rootDir + "testneu.pdf";
        String sxlSheet = "/home/superx/dev/edustore/webserver/tomcat/webapps/superx/xml/tabelle_fo_pdf.xsl";

        SxTransformer sxTrans = new SxTransformer(log, zielFile);

        sxTrans.quellstring = quelle;
        sxTrans.outfile = zielFile;
        sxTrans.stylesheet = sxlSheet;
        sxTrans.transformFile("pdf");


    }//Ende der Methode

    public class ClasspathUriResolver implements URIResolver {

        public Source resolve(String href, String base) throws TransformerException {
            Source source = null;
            InputStream inputStream = ClassLoader.getSystemResourceAsStream(href);
            if (inputStream != null) {
                source = new StreamSource(inputStream);
            }
            return source;
        }
    }
}//Ende der Klasse