package de.superx.bin;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.logging.LogManager;
import java.util.logging.Logger;

import org.w3c.dom.Document;

import de.memtext.util.GetOpts;
import de.memtext.util.GetOpts.Options;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JRExporterParameter;
import net.sf.jasperreports.engine.JRParameter;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperExportManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperPrintManager;
import net.sf.jasperreports.engine.export.JRCsvExporter;
import net.sf.jasperreports.engine.export.JRRtfExporter;
import net.sf.jasperreports.engine.export.JRXlsExporter;
import net.sf.jasperreports.engine.query.JRXPathQueryExecuterFactory;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.engine.util.JRXmlUtils;

/**
 * @author Daniel Quathamer Projektgruppe SuperX
 * 
 * @
 * Dieses Javaprogramm führt JasperReports aus und gibt das Ergebnis aus.<br>
 * 
 *Aufruf: java $JAVA_OPTS -cp "$CP" de.superx.bin.SxJasper -logger:$LOGGER_PROPERTIES -db_properties:$DB_PROPERTIES -JRXML:<JRXML-Datei> -JASPER:<Jasper-Datei> -JRPRINT:<Jrprint-Datei> -XML:<Datei mit XML-Datenquelle> -IGNORE_PAGINATION:<true oder false> -OUT:<Ausgabedatei>

 Aktion: sx_jasper führt einen JasperReports-Task aus.
 Das Ergebnis wird in eine Datei <Ausgabedatei> ausgegeben
 Die Datenbankverbindung ist in $DB_PROPERTIES definiert.
 
 Achtung: Der Workflow ist wie folgt:
 Quelldatei.jrxml ist die XML-Beschreibungsdatei des Berichts
 
 Task compile: Quelldatei.jrxml -> Quelldatei.jasper
 Quelldatei.jasper ist kompilierte Beschreibungsdatei für den Bericht
 Compile wird ausgeführt, wenn nur eine jrxml-Datei und der Logger übergeben wird.
 
 Task fill/fillIgnorePagination: Quelldatei.jasper -> Quelldatei.jrprint
 Quelldatei.jrprint enthält mit Daten gefüllte Berichtsvorlage
 
 Task pdf,csv,html,xml,xmlEmbed,rtf,xls,jxl,print: Quelldatei.jrprint -> Ausgabedatei (Default: Quelldatei+Formatspezifische Endung)
 Rendering des Berichts wird ausgeführt.
 
 Sonderform run:
 Aus vorhandender .jasper-Datei wird direkt eine pdf-Datei erzeugt.
 Setzen Sie den Logging-Level in $LOGGER_PROPERTIES auf INFO, um Laufzeiten zu sehen 


 */
//Änderungen

public class SxJasper {
    private static Connection myDb;

    private static Statement st; // Our statement to run queries with

    private static DatabaseMetaData dbmd;

    // This defines the structure of the database
    private static boolean done = false; // Added by CWJ to permit \q command

    private static String taskName = "run";

    private static String jrxmlFileName = "";

    private static String jasperFileName = "";

    private static String jrprintFileName = "";

    private static String XMLfileName = "";

    private static String XSLfileName = "";

    private static String ignorePagination = "";

    private static String params = "";

    private static String logfile = "../conf/logging.properties";

    private static String dbpropfile = "../conf/db.properties";

    private static SxConnection myConnection = null;

    private static String db_driver;

    private static String outfile = "";

    private static Logger logger = (Logger) Logger.getLogger(SxJasper.class.toString());

    private static final String TASK_COMPILE = "compile";

    private static final String TASK_FILL = "fill";

    private static final String TASK_PRINT = "print";

    private static final String TASK_PDF = "pdf";

    private static final String TASK_RTF = "rtf";

    private static final String TASK_XML = "xml";

    private static final String TASK_XML_EMBED = "xmlEmbed";

    private static final String TASK_HTML = "html";

    private static final String TASK_XLS = "xls";

    private static final String TASK_JXL = "jxl";

    private static final String TASK_CSV = "csv";

    private static final String TASK_RUN = "run";

    private static final String TASK_FILL_IGNORE_PAGINATION = "fillIgnorePagination";

    private static String usage = "-------------------------------------\nGebrauch: java de.superx.bin.SxJasper -logger=<<Pfad zu logging.properties>> -JRXML=<<jrxml-Datei>> -OUT=<<Ausgabedatei>>(optional) \n---------------------------------------------------";

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws FileNotFoundException
     * @throws IOException
     * @throws SQLException
     */
    public static void go(String args[]) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException {
        if (args.length == 0) {
            throw new IllegalArgumentException("Mindestens drei Parameter (Pfad zu den logger.properties, Pfad zu den db.properties, outfile) erfoderlich");

        }
        GetOpts.setOpts(args);
        String isdrin = GetOpts.isAllRequiredOptionsPresent(new Options[] {Options.opt_logger,Options.opt_dbprops,Options.opt_jrxml});
        if (isdrin != null) {
            System.err.println("Folgende Optionen fehlen: " + isdrin);
            System.err.println(usage);
            System.exit(1);
        }
        if (GetOpts.isPresent(Options.opt_logger)) logfile = GetOpts.getValue(Options.opt_logger);
        if (GetOpts.isPresent(Options.opt_jrxml)) jrxmlFileName = GetOpts.getValue(Options.opt_jrxml);
        if (GetOpts.isPresent(Options.opt_jasper))
            jasperFileName = GetOpts.getValue(Options.opt_jasper);
        else
            jasperFileName = de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName) + ".jasper";
        if (GetOpts.isPresent(Options.opt_jrPrint))
            jrprintFileName = GetOpts.getValue(Options.opt_jrPrint);
        else
            jrprintFileName = de.memtext.util.FileUtils.getFileNameWithoutSuffix(jrxmlFileName) + ".jrprint";
        if (GetOpts.isPresent(Options.opt_xml)) XMLfileName = GetOpts.getValue(Options.opt_xml);
        if (GetOpts.isPresent(Options.opt_ignorePagination)) ignorePagination = GetOpts.getValue(Options.opt_ignorePagination);
        if (GetOpts.isPresent(Options.opt_xsl)) XSLfileName = GetOpts.getValue(Options.opt_xsl);
        if (GetOpts.isPresent(Options.opt_out))
            outfile = GetOpts.getValue(Options.opt_out);
        if (GetOpts.isPresent(Options.opt_dbprops)) dbpropfile = GetOpts.getValue(Options.opt_dbprops);
        if (GetOpts.isPresent(Options.opt_param)) params = GetOpts.getValue(Options.opt_param);

        File f = new File(logfile);
        if (!f.exists()) {
            throw new IOException("Datei nicht gefunden: " + logfile);
        }

        FileInputStream ins = new FileInputStream(logfile);
        LogManager MyLogManager = java.util.logging.LogManager.getLogManager();
        MyLogManager.readConfiguration(ins);
        logfile = MyLogManager.getProperty(".level");
        logger.info("Using Loggging-Level " + logfile);
        try {
            long start = System.currentTimeMillis();
            if (!jrxmlFileName.equals("")) {
                if (jasperFileName.equals(""))
                    jasperFileName = JasperCompileManager.compileReportToFile(jrxmlFileName);
                else
                    JasperCompileManager.compileReportToFile(jrxmlFileName, jasperFileName);
                logger.info("Compile time : " + (System.currentTimeMillis() - start));
            }
			if (!jasperFileName.equals("") &&
					(GetOpts.isPresent(Options.opt_dbprops) || GetOpts.isPresent(Options.opt_xml) )
					)
			{
                logger.info("Filling " + jasperFileName);

                //Preparing parameters
                Map parameters = new HashMap();
                if (!XMLfileName.equals("")) {
                    logger.info("XML-Source " + XMLfileName);
                    Document document = JRXmlUtils.parse(new File(XMLfileName));
                    parameters.put(JRXPathQueryExecuterFactory.PARAMETER_XML_DATA_DOCUMENT, document);
                    parameters.put(JRXPathQueryExecuterFactory.XML_DATE_PATTERN, "dd.MM.yyyy HH:mm:ss");
                    parameters.put(JRXPathQueryExecuterFactory.XML_NUMBER_PATTERN, "###0.00;-###0.00");
                    parameters.put(JRXPathQueryExecuterFactory.XML_LOCALE, Locale.GERMAN);
                    parameters.put(JRParameter.REPORT_LOCALE, Locale.GERMAN);
                } else
                    getConnection(logger, dbpropfile);

                //parameters.put("ReportTitle", "Rektorenliste");
                //parameters.put("FilterClause", "'Boston', 'Chicago', 'Oslo'");
                //parameters.put("OrderClause", "City");

                if (ignorePagination.equals("true")) {
                    parameters.put(JRParameter.IS_IGNORE_PAGINATION, Boolean.TRUE);
                }

                if (jrprintFileName.equals(""))
                    jrprintFileName = JasperFillManager.fillReportToFile(jasperFileName, parameters, myDb);
                else
                    JasperFillManager.fillReportToFile(jasperFileName, jrprintFileName, parameters, myDb);

                logger.info("Filling time : " + (System.currentTimeMillis() - start));

            }
            if (outfile.endsWith(".prn")) {
                JasperPrintManager.printReport(jrprintFileName, true);
                logger.info("Printing time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            if (outfile.endsWith(".pdf")) {
                JasperExportManager.exportReportToPdfFile(jrprintFileName, outfile);
                logger.info("PDF creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            if (outfile.endsWith(".rtf")) {
                File sourceFile = new File(jrprintFileName);

                JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);
                File destFile = new File(sourceFile.getParent(), outfile);

                JRRtfExporter exporter = new JRRtfExporter();

                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());

                exporter.exportReport();

                logger.info("RTF creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            if (outfile.endsWith(".xml")) {
                JasperExportManager.exportReportToXmlFile(jrprintFileName, outfile, false);
                logger.info("XML creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            /*else if (TASK_XML_EMBED.equals(taskName))
            {
            	if(outfile.equals(""))
            		outfile=jrxmlFileName + ".xml";
            	JasperExportManager.exportReportToXmlFile(jrprintFileName,outfile, true);
            	logger.info("XML creation time : " + (System.currentTimeMillis() - start));
            	System.exit(0);
            }*/
            if (outfile.endsWith(".htm") || outfile.endsWith(".html")) {
                JasperExportManager.exportReportToHtmlFile(jrprintFileName, outfile);
                logger.info("HTML creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            if (outfile.endsWith(".xls")) {
                File sourceFile = new File(jrprintFileName);

                JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);

                File destFile = new File(sourceFile.getParent(), outfile);

                JRXlsExporter exporter = new JRXlsExporter();

                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
                //exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.FALSE);

                exporter.exportReport();

                logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            /* else if (TASK_JXL.equals(taskName))
            {
            	File sourceFile = new File(jrprintFileName);
            
            	JasperPrint jasperPrint = (JasperPrint)JRLoader.loadObject(sourceFile);
            	if(outfile.equals(""))
            		outfile=jasperPrint.getName() + ".jxl.xls";
            
            	File destFile = new File(sourceFile.getParent(), outfile);
            
            	JExcelApiExporter exporter = new JExcelApiExporter();
            
            	exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
            	exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());
            	exporter.setParameter(JRXlsExporterParameter.IS_ONE_PAGE_PER_SHEET, Boolean.TRUE);
            
            	exporter.exportReport();
            
            	logger.info("XLS creation time : " + (System.currentTimeMillis() - start));
            	System.exit(0);
            }*/
            if (outfile.endsWith(".csv")) {
                File sourceFile = new File(jrprintFileName);

                JasperPrint jasperPrint = (JasperPrint) JRLoader.loadObject(sourceFile);
                File destFile = new File(sourceFile.getParent(), outfile);

                JRCsvExporter exporter = new JRCsvExporter();

                exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
                exporter.setParameter(JRExporterParameter.OUTPUT_FILE_NAME, destFile.toString());

                exporter.exportReport();

                logger.info("CSV creation time : " + (System.currentTimeMillis() - start));
                System.exit(0);
            }
            /*else if (TASK_RUN.equals(taskName))
            {
            	//Preparing parameters
            	Map parameters = new HashMap();
            	//parameters.put("ReportTitle", "Address Report");
            	//parameters.put("FilterClause", "'Boston', 'Chicago'");
            	//parameters.put("OrderClause", "City");
            	if(outfile.equals(""))
            		outfile=jrxmlFileName+".pdf";
            	getConnection(logger, dbpropfile);
            	JasperRunManager.runReportToPdfFile(jrxmlFileName+".jasper",outfile, parameters, myDb);
            	logger.info("PDF running time : " + (System.currentTimeMillis() - start));
            	System.exit(0);
            }*/
        } catch (JRException e) {
            e.printStackTrace();
            System.exit(1);
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
        //getConnection(logger, dbpropfile);


        logger.info("SxJasper erfolgreich beendet");

    }

    /*
     * Display some instructions on how to run the example
     */
    public static void instructions() {
        System.out.println("SuperX @version@\n");
        System.out.println("\nDieses Java-Programm führt einen SQL-Ausdruck aus und gibt das Ergebnis aus.\n");
        System.out.println("Gebrauch:\n java doquery <Pfad zu logger-properties> <pfad zu db.properties> <sql-Ausdruck> <Ausgabeformat (txt | html | xml)>(optional) <delimiter> <mit Spaltenüberschriften (true | false)>(optional) <Ausgabedatei>(optional)\n");
        System.exit(1);
    }

    public static void main(String args[]) {
        try {
            go(args);
        } catch (Exception ex) {
            System.err.println("Doquery Aufruf fehlgeschlagen.\n" + ex);
            ex.printStackTrace();
            System.exit(1);
        }
    }

    public static void getConnection(Logger logger, String propFile) throws SQLException {
        myConnection = new SxConnection();
        myConnection.setPropfile(propFile);
        logger.config("Starting Connection...");
        try {
            myDb = myConnection.getConnection();
            st = myDb.createStatement();
            //st = myDb.createStatement(java.sql.ResultSet.TYPE_FORWARD_ONLY,
            //          java.sql.ResultSet.CONCUR_READ_ONLY);
            //st.setFetchSize(100); 
            dbmd = myDb.getMetaData();
            //st = myDb.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
            //ResultSet.CONCUR_UPDATABLE);
        } catch (Exception e) {
            logger.severe("Keine DB-Verbindung: " + e.toString());
            throw new SQLException("Keine DB-Verbindung: " + e.toString());
        }
        db_driver = myConnection.m_DriverClass.stringValue();

    }


}