import java.rmi.*;
import java.rmi.server.*;
import java.util.*;
import java.sql.*;
import javax.swing.JOptionPane;


public class GatewayManager
  extends UnicastRemoteObject
  implements GatewayInterface
{
  private Hashtable connections;          // handle --> Connection or Statement
  private Hashtable statements;           // handle --> Connection or Statement
  private Hashtable resultSets;           // handle to Statement --> ResultSet
  private Hashtable resultSetMetaDatas;   // handle to Statement --> ResultSetMetaData
  private Hashtable exceptionMessages ;   // handle to Statement --> String
  private int numberOfHandles;

  java.text.DecimalFormat nf = new java.text.DecimalFormat  ("########");

  //---------------------------------------------------------------------------
  public GatewayManager (int numberOfHandlesToManage) throws RemoteException
  {
    this.numberOfHandles    = numberOfHandlesToManage;
    this.connections        = new Hashtable (numberOfHandlesToManage);
    this.statements         = new Hashtable ();
    this.resultSets         = new Hashtable ();
    this.resultSetMetaDatas = new Hashtable ();
    this.exceptionMessages  = new Hashtable ();
  }

  //---------------------------------------------------------------------------
  private Integer getHandle () {
    Integer handle;  // has to be an object so that it can be used in a Hashtable
    do {
      handle = new Integer ( (int) Math.floor (Math.random() * 1e8));
    }
    while (
        connections.containsKey (handle)
     || statements.containsKey(handle)
     || resultSets.containsKey(handle)
     || exceptionMessages.containsKey(handle)
    );

    return handle;
  }

  //---------------------------------------------------------------------------
  private Object getObjectOfKey(Hashtable H, Object key, boolean clearMessage) throws Exception
  {
    Object mv = H.get (key);

    if (mv == null) {
      Thread.currentThread().sleep(500);
      throw new Exception ("Invalid handle.");
    }

    if (clearMessage)
      exceptionMessages.put (key, new String());

    return mv;
  }

  //---------------------------------------------------------------------------
  private Connection getConnectionOfHandle(int handle, boolean clearMessage) throws Exception
  {
    Integer key = new Integer(handle);
    return (Connection) getObjectOfKey (connections, key, clearMessage);
  }

  //---------------------------------------------------------------------------
  private Statement getStatementOfHandle(int handle, boolean clearMessage) throws Exception
  {
    Integer key = new Integer(handle);
    return (Statement) getObjectOfKey (statements, key, clearMessage);
  }

  //---------------------------------------------------------------------------
  private ResultSet getResultSetOfHandle(int handle, boolean clearMessage) throws Exception
  {
    Integer key = new Integer(handle);
    return (ResultSet) getObjectOfKey (resultSets, key, clearMessage);
  }

  //---------------------------------------------------------------------------
  private ResultSetMetaData getResultSetMetaDataOfHandle(int handle, boolean clearMessage) throws Exception
  {
    Integer key = new Integer(handle);
    return (ResultSetMetaData) getObjectOfKey (resultSetMetaDatas, key, clearMessage);
  }

  //---------------------------------------------------------------------------
  public int getConnectionHandle (String driverClass, String databaseURL, String username, String password) throws RemoteException
  {
    Integer cHandle = getHandle();
    Connection con ;

    if (connections.size() == numberOfHandles) {
      System.out.println ("No more handles available.");
      throw new RemoteException ("No more handles available.");
    }

    try {
      System.out.println ("loading "+driverClass);
      Class.forName(driverClass);
      System.out.println ("connecting to "+databaseURL);
      con = DriverManager.getConnection (databaseURL, username, password);
      System.out.println ("connected");
    }
    catch (Exception e) {
      System.out.println (e);
      throw new RemoteException ("Problem connecting to database", e);
    }

    connections.put (cHandle, con);

    System.out.println ("Connection handle " + nf.format(cHandle) + " is for " + username + " connected to " + databaseURL);

    return cHandle.intValue();
  }

  //---------------------------------------------------------------------------
  public int getStatementHandle (int cHandle) throws RemoteException
  {
    Integer sHandle = getHandle ();
    Connection con ;
    Statement st;

    try {
      con = getConnectionOfHandle (cHandle, true);
      st = con.createStatement ();
    }
    catch (Exception e) {
      throw new RemoteException ("Problem getting a statement", e);
    }

    statements.put (sHandle, st);

    System.out.println ("Statement handle " + nf.format(sHandle) + " ready");

    return sHandle.intValue();
  }

  //---------------------------------------------------------------------------
  public void closeConnectionHandle (int handle) throws RemoteException
  {
    Integer key = new Integer(handle);
    try {
      Connection con = getConnectionOfHandle (handle, false);
      for (Enumeration e = statements.keys() ; e.hasMoreElements() ;) {
        Integer skey = (Integer) e.nextElement();
        Statement st = (Statement) statements.get(skey);
        if (st.getConnection() == con) {
          closeStatementHandle (skey.intValue());
        }
      }
      con.close();
      connections.remove (key);
      exceptionMessages.remove (key);
    }
    catch (Exception e) { throw new RemoteException("", e); }

    System.out.println ("Connection handle " + nf.format(handle) + " was closed");
  }

  //---------------------------------------------------------------------------
  public void closeStatementHandle (int handle) throws RemoteException
  {
    Integer key = new Integer(handle);
    try {
      Statement st = getStatementOfHandle (handle, false);

      for (Enumeration e = resultSets.keys() ; e.hasMoreElements() ;) {
        Integer rkey = (Integer) e.nextElement();
        ResultSet rs = (ResultSet) resultSets.get(rkey);
        if (rs.getStatement() == st) {
          closeResultSetHandle (rkey.intValue());
        }
      }
      st.close();
      statements.remove (key);
      exceptionMessages.remove (key);
    }
    catch (Exception e) { throw new RemoteException("", e); }

    System.out.println ("Statement handle " + nf.format(handle) + " was closed");
  }

  //---------------------------------------------------------------------------
  public void closeResultSetHandle (int handle) throws RemoteException
  {
    Integer key = new Integer (handle);
    try {
      ResultSet rs = getResultSetOfHandle (handle, false);
      rs.close();
      resultSets.remove (key);
      resultSetMetaDatas.remove (key);
      exceptionMessages.remove (key);
    }
    catch (Exception e) { throw new RemoteException("", e); }

    System.out.println ("ResultSet handle " + nf.format(handle) + " was closed");
  }

  //---------------------------------------------------------------------------
  private void createExceptionMessage(int handle, Exception e)
               { createExceptionMessage (handle, e, null); }

  //---------------------------------------------------------------------------
  private void createExceptionMessage
                          (int handle, Exception e, String text)
  {
    String msg;
    Integer key = new Integer (handle);

    if (text != null)
      msg = text + "\n";
    else
      msg = "";

    msg += e.toString();
/*
    for (int i=0;i<e.getStackTrace().length; i++) {
      msg += "\n" + e.getStackTrace()[i];
    }
*/
    exceptionMessages.put(key,msg);
  }

  //---------------------------------------------------------------------------
  public String getExceptionMessage (int handle) throws RemoteException
  {
    Integer key = new Integer (handle);
    try {
      return (String) getObjectOfKey (exceptionMessages, key, false);
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public void executeUpdate (int sHandle, String sql) throws RemoteException
  {
    try {
      Statement st = getStatementOfHandle (sHandle, true);
      System.out.println ("handle " + nf.format(sHandle) + " is executing update: " + sql);
      try {
        int rowCount = st.executeUpdate (sql);
        System.out.println ("handle " + nf.format(sHandle) + " updated " + rowCount + " rows");
      }
      catch (Exception e) {
        createExceptionMessage(sHandle, e, sql);
      }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  // returns handle to a ResultSet
  public int executeQuery (int sHandle, String sql) throws RemoteException
  {
    Integer rHandle = getHandle();
    try {
      Statement st = getStatementOfHandle (sHandle, true);
      System.out.println ("handle " + nf.format(sHandle) + " is executing query: " + sql);
      try {
        ResultSet rs = st.executeQuery (sql);
        ResultSetMetaData rsmd = rs.getMetaData();
        resultSets.put (rHandle, rs);
        resultSetMetaDatas.put (rHandle, rsmd);
      }
      catch (Exception e) {
        createExceptionMessage(sHandle, e, sql);
      }
    }
    catch (Exception e) { throw new RemoteException("", e); }

    return rHandle.intValue();
  }

  //---------------------------------------------------------------------------
  public boolean nextRow (int rHandle) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { return rs.next(); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return false; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public double getValue (int rHandle, int colNum) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { return rs.getDouble((int)colNum); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return Double.NaN;}
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public String getText (int rHandle, int colNum) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { return rs.getString((int)colNum); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return ""; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public void setValue (int rHandle, int colNum, double value) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { rs.updateDouble((int)colNum, value); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public void setText (int rHandle, int colNum, String text) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { rs.updateString((int)colNum,text); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public void insertRow (int rHandle) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { rs.insertRow(); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public void moveToInsertRow (int rHandle) throws RemoteException
  {
    try {
      ResultSet rs = getResultSetOfHandle (rHandle, true);
      try
      { rs.moveToInsertRow(); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public String getColumnName (int rHandle, int colNum) throws RemoteException
  {
    try {
      ResultSetMetaData rsmd = getResultSetMetaDataOfHandle (rHandle, true);
      try
      { return rsmd.getColumnName((int)colNum); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return ""; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }


  //---------------------------------------------------------------------------
  public int getColumnType (int rHandle, int colNum) throws RemoteException
  {
    try {
      ResultSetMetaData rsmd = getResultSetMetaDataOfHandle (rHandle, true);
      try
      { return rsmd.getColumnType((int)colNum); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return -1; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public int getColumnCount (int rHandle) throws RemoteException
  {
    try {
      ResultSetMetaData rsmd = getResultSetMetaDataOfHandle (rHandle, true);
      try
      { return rsmd.getColumnCount(); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return -1; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }

  //---------------------------------------------------------------------------
  public int getColumnDisplaySize (int rHandle, int colNum) throws RemoteException
  {
    try {
      ResultSetMetaData rsmd = getResultSetMetaDataOfHandle (rHandle, true);
      try
      { return rsmd.getColumnDisplaySize((int)colNum); }
      catch (Exception e)
      { createExceptionMessage(rHandle, e); return -1; }
    }
    catch (Exception e) { throw new RemoteException("", e); }
  }
}