package com.hoten.db;

import java.io.*;
import java.sql.*;
import java.util.*;
import java.util.Date;
import com.hoten.util.Log;
/**
 * This class is a Singleton that provides access to one or many
 * connection pools defined in a Property file. A client gets
 * access to the single instance through the static getInstance()
 * method and can then check-out and check-in connections from a pool.
 * When the client shuts down it should call the release() method
 * to close all open connections and do other clean up.
 */
public class DBConnectionManager {
    static private DBConnectionManager instance; // The single instance
    static private int clients;
    private String logFile;
    private Vector drivers = new Vector();
    private Hashtable pools = new Hashtable();
  /**
 * Returns the single instance, creating one if it's the
 * first time this method is called.
 *
 * @return DBConnectionManager The single instance.
 */
    static synchronized public DBConnectionManager getInstance() {
        if (instance == null) {
            instance = new DBConnectionManager();
        }
        clients++;
        //System.out.println(clients);
        return instance;
    }
    public int getAccessNum(){
        return clients;
    }
    public String getLogFile(){
        return logFile;
    }
    public int getUsedConNum(String poolName){
        DBConnectionPool pool = (DBConnectionPool) pools.get(poolName);
        int size = 0;
        if (pool != null) {
            size = pool.getUsedConNum();
        }
        pool=null;
        return size;
    }
    public int getFreeConNum(String poolName){
        DBConnectionPool pool = (DBConnectionPool) pools.get(poolName);
        int size = 0;
        if (pool != null) {
            size = pool.getFreeConNum();
        }
        pool=null;
        return size;
    }
    public String[] getPoolName(){
        Enumeration names = pools.keys();
        String[] nameList = new String[pools.size()];
        int i=0;
        while(names.hasMoreElements()){
            nameList[i++] = (String)names.nextElement();
        }
        return nameList;
    }
/**
 * A private constructor since this is a Singleton
 */
    private DBConnectionManager() {
        init();
    }

/**
 * Returns a connection to the named pool.
 *
 * @param name The pool name as defined in the properties file
 * @param con The Connection
 */
    public void freeConnection(String name, Connection con) {
        DBConnectionPool pool = (DBConnectionPool) pools.get(name);
        if (pool != null) {
            pool.freeConnection(con);
        }
        pool=null;
    }

/**
 * Returns an open connection. If no one is available, and the max
 * number of connections has not been reached, a new connection is
 * created.
 *
 * @param name The pool name as defined in the properties file
 * @return Connection The connection or null
 */
    public java.sql.Connection getConnection(String name) {
       DBConnectionPool pool = (DBConnectionPool) pools.get(name);
        if (pool != null) {
            return pool.getConnection();
        }
        pool=null;
        return null;
    }

/**
 * Returns an open connection. If no one is available, and the max
 * number of connections has not been reached, a new connection is
 * created. If the max number has been reached, waits until one
 * is available or the specified time has elapsed.
 *
 * @param name The pool name as defined in the properties file
 * @param time The number of milliseconds to wait
 * @return Connection The connection or null
 */
    public java.sql.Connection getConnection(String name, long time) {

        DBConnectionPool pool = (DBConnectionPool) pools.get(name);
        if (pool != null) {
            return pool.getConnection(time);
        }
        pool=null;
        return null;
    }

/**
 * Closes all open connections and deregisters all drivers.
 */
    public synchronized void release() {
            // Wait until called by the last client
      if (--clients != 0) {
             return;
      }
      Enumeration allPools = pools.elements();
      while (allPools.hasMoreElements()) {
          DBConnectionPool pool = (DBConnectionPool) allPools.nextElement();
          pool.release();
      }
      Enumeration allDrivers = drivers.elements();
      while (allDrivers.hasMoreElements()) {
          Driver driver = (Driver) allDrivers.nextElement();
          try {
              DriverManager.deregisterDriver(driver);
              Log.printEvent("Deregistered JDBC driver " + driver.getClass().getName(),logFile);
          }
          catch (SQLException e) {
              Log.printEvent("Can't deregister JDBC driver: " + driver.getClass().getName()+" Exception:"+e.getMessage(),logFile);
          }
      }
  }

/**
 * Creates instances of DBConnectionPool based on the properties.
 * A DBConnectionPool can be defined with the following properties:
 * <PRE>
 * &lt;poolname&gt;.url The JDBC URL for the database
 * &lt;poolname&gt;.user  A database user (optional)
 * &lt;poolname&gt;.passwordA database user password (if user specified)
 * &lt;poolname&gt;.maxconn The maximal number of connections (optional)
 * </PRE>
 *
 * @param props The connection pool properties
 */
    private void createPools(Properties props) {
        Enumeration propNames = props.propertyNames();
        while (propNames.hasMoreElements()) {
            String name = (String) propNames.nextElement();
            if (name.endsWith(".url")) {
                String poolName = name.substring(0, name.lastIndexOf("."));
                String url = props.getProperty(poolName + ".url");
                if (url == null) {
                    Log.printEvent("No URL specified for " + poolName,logFile);
                    continue;
                }
                String user = props.getProperty(poolName + ".user");
                String password = props.getProperty(poolName + ".password");
                String maxconn = props.getProperty(poolName + ".maxconn", "3");
                String minconn = props.getProperty(poolName + ".minconn","1");
                String defconn = props.getProperty(poolName + ".defconn","2");
                int max,min,def;
                try {
                    max = Integer.valueOf(maxconn.trim()).intValue();
                    min = Integer.valueOf(minconn.trim()).intValue();
                    def = Integer.valueOf(defconn.trim()).intValue();
                }
                catch (Exception e) {
                    Log.printEvent("Invalid maxconn value " + maxconn + " for " + poolName,logFile);
                    Log.printEvent("Invalid minconn value " + minconn + " for " + poolName,logFile);
                    Log.printEvent("Invalid minconn value " + defconn + " for " + poolName,logFile);
                    max = 3;
                    min=1;
                    def=2;
                }
                DBConnectionPool pool = new DBConnectionPool(poolName, url.trim(), user, password, max,min,def);
                pools.put(poolName, pool);
                Log.printEvent("Initialized pool " + poolName,logFile);
            }
        }
  }

/**
 * Loads properties and initializes the instance with its values.
 */
    private void init() {
        FileInputStream is=null;
        try{
            if(System.getProperty("file.separator").equals("/"))
                is= new FileInputStream("./config/db.properties");
            else
                is= new FileInputStream(".\\config\\db.properties");
        }catch(FileNotFoundException e){
        System.out.println("File db.properties not found");
        }
        Properties dbProps = new Properties();
        try {
            dbProps.load(is);
        }
        catch (Exception e) {
            System.err.println("Can't read the properties file. " +
            "Make sure db.properties is in the CLASSPATH");
            return;
        }
        logFile = dbProps.getProperty("logFile", "DBConnectionManager.log");
        loadDrivers(dbProps);
        createPools(dbProps);
  }

/**
 * Loads and registers all JDBC drivers. This is done by the
 * DBConnectionManager, as opposed to the DBConnectionPool,
 * since many pools may share the same driver.
 *