package Jt;
import java.sql.*;
import javax.sql.*;
import java.text.*;
import Jt.jndi.*;

/**
 * Jt Adapter for the JDBC API. This implementation supports Data Sources.
 */

public class JtJDBCAdapter extends JtAdapter  {

    private static final long serialVersionUID = 1L;

    public static final String JtCLASS_NAME = JtJDBCAdapter.class.getName(); 
    public static final String JtCONNECT = "JtCONNECT"; 
    public static final String JtPREPARE_STATEMENT = "JtPREPARE_STATEMENT"; 
    public static final String JtEXECUTE_PREPARED_UPDATE = "JtEXECUTE_PREPARED_UPDATE"; 
    public static final String JtEXECUTE_PREPARED_QUERY = "JtEXECUTE_PREPARED_QUERY"; 
    public static final String JtEXECUTE_QUERY = "JtEXECUTE_QUERY"; 
    public static final String JtQUERY = "JtQUERY"; 
    public static final String JtEXECUTE_UPDATE = "JtEXECUTE_UPDATE"; 
    public static final String JtUPDATE = "JtUPDATE"; 
    public static final String JtCLOSE = "JtCLOSE"; 
    public static final String JtBEGIN_TRANSACTION = "JtBEGIN_TRANSACTION"; 
    public static final String JtCOMMIT = "JtCOMMIT"; 
    public static final String JtROLLBACK = "JtROLLBACK"; 
    
    private String user;
    private String password;
    private String url;  
    private String driver;
    private transient Connection connection = null;
    private String base;
    int n = 0;
    private transient Statement myStatement;
    private String datasource = null;
    private transient JtJNDIAdapter jndiAdapter = null;
    private transient DataSource dataSource = null;
    private transient boolean initted = false; 

    private DataSource locateDataSource (String datasource) {
        JtMessage msg = new JtMessage (JtJNDIAdapter.JtLOOKUP);


        if (datasource == null)
            return (null);

        msg.setMsgContent (datasource);
        jndiAdapter = new JtJNDIAdapter ();

        return ((DataSource) jndiAdapter.processMessage (msg));

    }

    private void initial () {



        if (datasource != null) {
            dataSource = locateDataSource (datasource);

            if (dataSource == null) {
                handleError ("JtJDBAdapter.connect: unable to locate datasource:" + 
                        datasource);
                connection = null;
                return;

            }

            try {
                connection = dataSource.getConnection ();
            } catch (Exception ex) {
                handleException (ex);
            }
        }

    }
    /*
    public boolean getAutoCommit () {
        boolean bool = false;

        if (connection == null) {
            handleWarning ("getAutoCommit: connection is null");
            return (false);
        }    
        try {
            bool = connection.getAutoCommit();
        } catch (Exception ex) {
            handleException (ex);            
        }
        return (bool);
    }

    public void setAutoCommit (boolean autocommit) {

        if (connection == null) {
            handleWarning ("setAutoCommit: connection is null");
            return;
        }

        try {
            connection.setAutoCommit(autocommit);
        } catch (Exception ex) {
            handleException (ex);            
        }
    }  
     */

    void connect ()
    {



        if (datasource != null) {

            if (dataSource == null) {
                handleWarning ("JtJDBAdapter.connect: unable to connect to Datasource: " + 
                        datasource);
                connection = null;
                return;

            }

            try {
                connection = dataSource.getConnection ();
                handleTrace ("JtJDBCAdapter.connect: using data source ....");

            } catch (Exception ex) {
                handleException (ex);
            }
            return;
        }

        if (connection != null) {
            return;
        }

        if (driver == null) {
            handleError ("connect: null attribute (driver)");
            return;
        }

        if (url == null) {
            handleError ("connect: null attribute (url)");
            return;
        }

        handleTrace ("JtJDBCAdapter.connect ....");
        try
        {
            Class.forName(driver);
            if (user == null)
                connection = DriverManager.getConnection(url);
            else
                connection = DriverManager.getConnection(url,
                        user, password);
            //System.out.println (connection.getAutoCommit ());
        }
        catch(ClassNotFoundException cnfe)
        {
            handleException (cnfe);
        }
        catch(SQLException sqle)
        {
            handleException (sqle);
        }
    }

    // close: close connection

    void close () {

        if (connection == null)
            return;

        try {
            connection.close ();	
        } 
        catch (SQLException sqle) {
            handleException (sqle);
        } 
        finally {
            connection = null; 
        }
    }

    // Executes a query

    ResultSet execute_query (String query) {

        if (query == null)
            return (null);

        if (connection == null) {
            handleError ("execute_query: no database connection");
            return (null);
        }

        try {
            myStatement = connection.createStatement ();
            ResultSet results = myStatement.executeQuery (query);

            if (results == null) // check
                myStatement.close ();

            return (results); // check - close later

            //results.close ();
        }
        catch(SQLException sqle)
        {
            handleTrace ("Message: " + sqle.getMessage ());
            handleTrace ("SQL State: " + sqle.getSQLState ());
            handleTrace ("Vendor code: " + sqle.getErrorCode ());
            handleException (sqle);
            return (null);
        } 
        /*
      finally {
        if (myStatement != null) {
          try {
            myStatement.close ();
          } catch (SQLException sqle) {
          }
        }
      }
         */

    }

    Object execute_update (String query) {
        int cnt = 0;
        Statement myStatement = null;

        if (query == null)
            return (null);

        if (connection == null) {
            handleError ("execute_query: no database connection");
            return (null);
        }

        try {
            myStatement = connection.createStatement ();
            cnt = myStatement.executeUpdate (query);
            myStatement.close ();
            return new Integer (cnt);
        }
        catch(SQLException sqle)
        {
            handleTrace ("Message: " + sqle.getMessage ());
            handleTrace ("SQL State: " + sqle.getSQLState ());
            handleTrace ("Vendor code: " + sqle.getErrorCode ());
            handleException (sqle);
            return (null);
        } 

    }

    // show_output: show output of the query 

    int show_output (ResultSet res) {

        int ncol, n;
        ResultSetMetaData meta;

        if (res == null)
            return (0);

        try {        
            meta = res.getMetaData ();
        }
        catch (SQLException e) {
            handleException (e);
            return (0);
        }



        try {
            while (res.next ()) {
                ncol = meta.getColumnCount ();
                handleTrace ("output:ncol:"+ ncol);
                for (n = 1; n <= ncol; n++) {
                    handleTrace ("output:" + 
                            meta.getColumnName (n) + ":" +
                            res.getString (n));
                }
            }
            return (1);
        }
        catch (SQLException e) {
            handleException (e);
            return (0);
        }
    }

    // map: map database row onto object

    int map (ResultSetMetaData meta, 
            ResultSet res, String obj_name) {

        int ncol, n;
        DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT);

        if ((meta == null) || (res == null) ||
                (obj_name == null))
            return (0);

        try {
            ncol = meta.getColumnCount ();
            for (n = 1; n <= ncol; n++) {
                //handleTrace ("JtJDBCAdapter.map:" + meta.getColumnTypeName(n));
                if (meta.getColumnTypeName(n).equals ("DATE") ||
                        meta.getColumnTypeName(n).equals ("DATETIME")) {
                    Date date = res.getDate (n);
                    if (date == null || date.equals (""))
                        continue; // check
                    String sdate = df.format (date);
                    this.setValue (obj_name, 
                            meta.getColumnName (n),
                            sdate);
                    continue;
                }
                this.setValue (obj_name, 
                        meta.getColumnName (n),
                        res.getString (n));
                /*
	  handleTrace ("JtJDBCAdapter.map:" + 
                 meta.getColumnName (n) + ":" +
                 res.getString (n));
                 */
            }

            return (1);
        }
        catch (SQLException e) {
            handleException (e);
            return (0);
        }
    }

    // map: map query onto object list. This method is being deprecated (see JtDAO)

    void map_query (String query, JtMessage me) {
        ResultSetMetaData mdata;
        ResultSet res;
        //int n = 0; - check memory leak
        String name;
        JtMessage event;
        JtObject tmp;

        //if (table == null)
        //return;

        handleTrace ("JtJDBCAdapter.map_query ....");

        if (query == null)
            return;

        if (base == null)
            return;

        //query = "select * from " + table; 

        res = execute_query (query);

        if (res == null) {
            handleTrace ("map_query:res:null");
            //myStatement.close ();
            return;
        }

        try {        
            mdata = res.getMetaData ();
        }
        catch (SQLException e) {
            handleException (e);
            return;
        }

        try {
            if (mdata == null) {
                myStatement.close ();
                //res.close (); // check
                return;
            }
        } catch (SQLException e) {
            handleException (e);
            return;
        }

        try {
            while (res.next ()) {
                n++;
                name = "" + n;
                handleTrace ("creating object ..." + name);
                tmp = (JtObject) this.createObject (base, name);	
                if (map (mdata, res, name) == 0)
                    continue;
                event = new JtMessage ();
                //event.setMsgContent (this.getObjName()+"."+name);
                event.setMsgContent (tmp);
                event.setMsgId ("JtOBJECT");
                event.setMsgSubject (me.getMsgSubject ());
                //event.setMsgSubject("JtMAP");


                // send a reply
                if (me.getMsgReplyTo () != null) {
                    // fireMessageEvent(event);
                    //      else { 
                    //event.setMsgIsReply (true);
                    this.sendMessage (me.getMsgReplyTo (), event);
                }

            }
            //	res.close (); // check
            myStatement.close ();
        }
        catch (SQLException e) {
            handleException (e);
        }
    }  

    private PreparedStatement prepareStatement (String query)
    {
        PreparedStatement pst = null;

        if (connection == null) {
            handleError ("JtJDBCAdapter.prepareStatement: invalid connection (null)");
            return (null);