package de.memtext.db;

import java.io.File;
import java.io.IOException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

import javax.xml.transform.TransformerConfigurationException;

import org.apache.commons.dbcp.ConnectionFactory;
import org.apache.commons.dbcp.DriverManagerConnectionFactory;
import org.apache.commons.dbcp.PoolableConnectionFactory;
import org.apache.commons.dbcp.PoolingDriver;
import org.apache.commons.pool.impl.GenericObjectPool;

import de.memtext.baseobjects.NamedObjectI;
import de.memtext.tree.KeyParentEqualException;
import de.memtext.util.DSAHandler;

/**
 * A new Connection pool making use of Jakarta Commons dbcp.
 */
public class MemtextPool extends GenericObjectPool implements NamedObjectI {

    private String name, subpath;
    private String nameNoAppendix;

    private Properties props = new Properties();
    private String privateKeyEncoded = null;
    private String publicKeyEncoded = null;
    private DSAHandler dsaHandler;

    public MemtextPool(String name, String nameAppendix, String subpath)
            throws SQLException, IOException, DBServletException {
        this.subpath = subpath;
        nameNoAppendix = name;
        this.setName(name + nameAppendix);
        try {
            readPropertiesAndUrl();
            System.out
                    .print(" (" + props.getProperty("connectionURL") + ") ..");
        } catch (Exception e) {
            System.out
                    .println("Konnte properties / Passwort nicht lesen. " + e);
            e.printStackTrace();
            throw new DBServletException(
                    "Konnte properties / Passwort nicht lesen. " + e);
        }
        try {

            Class.forName(props.getProperty("driverName"));
        } catch (ClassNotFoundException e1) {
            throw new DBServletException("Treiber "
                    + props.getProperty("driverName")
                    + " nicht gefunden. Ggfs. nach tomcat/common/lib kopieren.");
        }

        initLogging();
        this.setTestOnBorrow(true);

        int minIdle = 5;
        if (props.getProperty("minIdle") != null
                && !props.getProperty("minIdle").trim().equals("")) {
            minIdle = Integer.parseInt(props.getProperty("minIdle"));
        }
        this.setMinIdle(minIdle);
        int maxIdle = -1;
        if (props.getProperty("maxIdle") != null
                && !props.getProperty("maxIdle").trim().equals("")) {
            maxIdle = Integer.parseInt(props.getProperty("maxIdle"));
        }
        if (maxIdle != -1)
            setMaxIdle(maxIdle);

        int maxActive = -1;
        if (props.getProperty("maxActive") != null
                && !props.getProperty("maxActive").trim().equals("")) {
            maxActive = Integer.parseInt(props.getProperty("maxActive"));
        }
        if (maxActive != -1)
            setMaxActive(maxActive);

        ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
                props.getProperty("connectionURL"), props);
        PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(
                connectionFactory, this, null, "select count(*) from xdummy;" //validationQuery
                , false, true);
        int i = 1;
        try {
            //        PoolingDriver driver = new PoolingDriver();
            Class.forName("org.apache.commons.dbcp.PoolingDriver");
        } catch (ClassNotFoundException e2) {
            throw new DBServletException(
                    "ConnectionPool Klasse org.apache.commons.dbcp.PoolingDriver nicht gefunden.\ncommons-dbcp nach tomcat/common/lib stellen.");
        }
        PoolingDriver driver = (PoolingDriver) DriverManager
                .getDriver("jdbc:apache:commons:dbcp:");

        driver.registerPool(this.getName(), this);

        Object x = driver.getConnectionPool(this.getName());
        try {
            Connection con = this.getConnection();
            Statement st = con.createStatement();
            ResultSet rs = st
                    .executeQuery("select value from properties where name='privatekey'");
            while (rs.next()) {
                privateKeyEncoded = rs.getString(1);
            }
            rs.close();
            rs = st
                    .executeQuery("select value from properties where name='publickey'");
            while (rs.next()) {
                publicKeyEncoded = rs.getString(1);
            }
            rs.close();
            st.close();
            con.close();
           
        } catch (SQLException e) {
            String msg = "Fehler beim Aufbau des ConnectionPools ";
            if (!getName().startsWith("default"))
                msg += " für Mandant: " + getName();
            msg += "\nKonnte keine Connection aus dem Pool holen.\n" + e;

            throw new SQLException(msg);
        }
        if (privateKeyEncoded != null)
            initDSAHandler();
    }

    protected void initLogging() throws IOException {
        /*
         * LogUtils.initRawFile("superx_" + getName(), getLogDir() + "/superx_" +
         * name + ".log", 2000, 1, false, true); LogUtils.initRawFile("superx_" +
         * getName() + "_xml", getLogDir() + "/superx_" + name + "_xml.log",
         * 2000, 1, false, true);
         * 
         * Level lev = Level.SEVERE;
         * 
         * try { if (props.getProperty("logLevelSQL") != null) lev =
         * Level.parse(props.getProperty("logLevelSQL")); } catch
         * (IllegalArgumentException e) { String msg = "Ungültiger Level für
         * sqlLogger "; if (!this.getName().equals("default")) msg += "(Mandant :" +
         * getName() + ") "; msg += " :" + props.getProperty("logLevelSQL");
         * System.out.println(msg); } Logger.getLogger("superx_" +
         * getName()).setLevel(lev); lev = Level.SEVERE;
         * 
         * try { if (props.getProperty("logLevelXML") != null) lev =
         * Level.parse(props.getProperty("logLevelXML")); } catch
         * (IllegalArgumentException e) { String msg = "Ungültiger Level für
         * XMLLogger "; if (!this.getName().equals("default")) msg += "(Mandant :" +
         * getName() + ") "; msg += " :" + props.getProperty("logLevelXML");
         * System.out.println(msg); } Logger.getLogger("superx_" + getName() +
         * "_xml").setLevel(lev);
         */
    }

    public static String getLogDir() {
        String tomcat_home = System.getProperty("catalina.home"); //tomcat 4
        // and 5
        if (tomcat_home == null)
            tomcat_home = System.getProperty("tomcat.home"); //tomcat 3.x
        if (tomcat_home == null)
            tomcat_home = "/home/superx/webserver/tomcat";

        return tomcat_home + "/logs";

    }

    public Properties getProperties() {
        return props;
    }

    private void readPropertiesAndUrl() throws Exception {
        String propname = "db_" + nameNoAppendix + ".properties";
        if (nameNoAppendix.equals("default"))
            propname = "db.properties";

        java.net.URL url = MemtextPool.class.getProtectionDomain()
                .getCodeSource().getLocation();
        File myJar = new File(url.getFile());
        File myPath = new File(myJar.getParent());
        String pfad = myPath.getParent() + System.getProperty("file.separator");
        if (subpath != null)
            pfad += subpath + System.getProperty("file.separator");
        props = PropsReader.prepareProps(new File(pfad + propname));
        int i = 1;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void close() throws SQLException {
        PoolingDriver driver = (PoolingDriver) DriverManager
                .getDriver("jdbc:apache:commons:dbcp:");
        driver.closePool(this.getName());

    }

    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:apache:commons:dbcp:"
                + this.getName());

    }

    public void init() throws TransformerConfigurationException,
            KeyParentEqualException, SQLException, DBServletException {
    }

    public void clearLogFiles() throws IOException {
    }

    private void initDSAHandler() throws DBServletException {
        //privateKey wird ggfs. im Konstruktur bei Connection-Test, public key
        // aus properties eingelesen
        if (privateKeyEncoded == null)
            throw new IllegalStateException(
                    "privatekey war null - properties-table auf Eintrag überprüfen");
        if (publicKeyEncoded == null)
            throw new IllegalStateException(
                    "publickey war null - properties-table prüfen");
        try {
            dsaHandler = new DSAHandler(privateKeyEncoded, publicKeyEncoded);
        } catch (Exception e) {
            throw new DBServletException(e.toString());
        }
    }

    public boolean hasDSAHandler() {
        return dsaHandler != null;
    }

    public boolean verifiy(String data, String signature)
            throws InvalidKeyException, NoSuchAlgorithmException,
            InvalidKeySpecException, SignatureException {
        if (dsaHandler == null)
            throw new IllegalStateException(
                    "DSAHandler ist null, public und private key definition prüfen");
        return dsaHandler.verify(data, signature);

    }

    public String getPrivateKey() {
        return privateKeyEncoded;
    }
}

//Created on 04.11.2004 at 20:18:11 as SxPool