package org.paneris.jal.model;
   
   import java.sql.Connection;
   import java.sql.PreparedStatement;
   import java.sql.ResultSet;
   import java.util.Enumeration;
   import java.util.Hashtable;
   import java.util.Vector;
   
  import javax.servlet.http.HttpSession;
  
  import org.paneris.util.UniqueVector;
  import org.webmacro.servlet.WebContext;
  
  /**
   * 
   * <p> A RecordSet provides functionality that allows you to navigate a set of results.</p>
   * <p> It does this by storing itself in the session so that it can be navigated</p>
   * <p> For this reason, the constructors are private, and you will be expected to
   * always get the RecordsSet using getInstance();</p>
   * <p> If you want to force the creation of a new record set, ensure that the context
   * contains a "submit" form value.  (inplying that a new search has been run.)</p>
   *
   * usage example:
   *
   * RecordSet set = RecordSet.getInstance(context, db, table, sqlString, null);
   * context.put("navigation", set);
   * for (Enumeration enum = set.getNext(); enum.hasMoreElements();) {
   *     Integer id = (Integer) enum.nextElement();
   *     body.addElement(new DDRecord(db,table,id));
   * }
   *
   */
  
  public class RecordSet {
  
    private UniqueVector recordIds;
    protected static final boolean debug = false;
    public String database;
    private String table;
    private int currentRecord;
    public String sqlString;
    public int increment;
    private int max;
    private TableMetaData metaData;
    private boolean limited = false;
    // hash of objects that can be used for storing state information associated with a record set
    private Hashtable state = new Hashtable();
    private Vector currentData = null;
    public DataCache dataCache = DataCache.getInstance();
    // allows records with a field 'deleted' to be ignored when loading the data
    private boolean ignoreDeleted;
  
    /**
     * Private Constructor to build a RecordSet given an sql string.
     */
    public RecordSet(String db, String table, String sql, Integer inc)
      throws Exception {
      init(db, table, inc);
      DBConnectionManager connMgr = DBConnectionManager.getInstance();
      sqlString = sql;
      String runSQL = sqlString;
      runSQL = metaData.applyMaxResults(database, runSQL);
      if (debug)
        System.err.println("sqlString: " + runSQL);
      Connection conn = connMgr.getConnection("RecordSet", database);
      PreparedStatement sqlStatement = conn.prepareStatement(runSQL);
      buildSet(db, table, sqlStatement, inc);
      connMgr.freeConnection(db, conn);
    }
  
    /**
     * Constructor to build a RecordSet given a vector of id's of results.
     */
    public RecordSet(String db, String table, UniqueVector results, Integer inc)
      throws Exception {
      init(db, table, inc);
      recordIds = results;
    }
  
    /**
     * Private Constructor to build a RecordSet given a prepared statement
     * nb this method does not set a max limit of the records returned.
     */
    public RecordSet(
      String db,
      String table,
      PreparedStatement sqlStatement,
      Integer inc)
      throws Exception {
      init(db, table, inc);
      buildSet(db, table, sqlStatement, inc);
    }
  
    public void buildSet(
      String db,
      String table,
      PreparedStatement sqlStatement,
      Integer inc)
     throws Exception {
     recordIds = new UniqueVector();
     ResultSet rs = sqlStatement.executeQuery();
     while (rs.next()) {
       Integer id;
       // eithier get the id, or the 1st field.
       try {
         id = new Integer(rs.getInt("id"));
       }
       catch (Exception e) {
         id = new Integer(rs.getInt(1));
       }
       recordIds.addElement(id);
     }
     if (recordIds.size() == metaData.getMaxResults()) {
       limited = true;
     }
   }
 
   /**
    * set initial values for this record set
    */
   private void init(String db, String t, Integer inc) throws Exception {
     currentRecord = 0;
     database = db;
     table = t;
     DataCache dataCache = DataCache.getInstance();
     metaData = dataCache.getTableMetaData(db, table);
     if (inc == null) {
       increment = metaData.getResultsPerPage().intValue();
     }
     else {
       increment = inc.intValue();
     }
   }
 
   /**
    * Returns the single instance, creating one if it can't be found (or has changed)
    * use this method if you have pre-built your results (ie a simple sql string does not
    * provide enough flexability).
    *
    * set the increment to null, in order to have it defaulted for this table
    */
   public static synchronized RecordSet getInstance(
     WebContext context,
     String db,
     String table,
     UniqueVector results,
     Integer inc)
     throws Exception {
     HttpSession session = context.getSession();
     RecordSet instance = (RecordSet)session.getAttribute(table);
     if (instance == null || (context.getForm("submit") != null)) {
       instance = new RecordSet(db, table, results, inc);
       session.setAttribute(table, instance);
       if (debug)
         System.err.println("new instance");
     }
     else {
       instance.doNavigation(context);
     }
     return instance;
   }
 
   /**
    * Returns the single instance, creating one if it can't be found (or has changed)
    *
    * set the increment to null, in order to have it defaulted for this table
    * the RecordSet is referenced in the session by the identifier
    */
   public static synchronized RecordSet getInstance(
     WebContext context,
     String db,
     String table,
     String sql,
     Integer inc,
     String identifier)
     throws Exception {
     HttpSession session = context.getSession();
     RecordSet instance = (RecordSet)session.getAttribute(identifier);
     if (instance == null
       || context.getForm("submit") != null
       || !sql.equals(instance.sqlString)
       || (inc != null && (inc.intValue() != instance.increment))) {
       instance = new RecordSet(db, table, sql, inc);
       session.setAttribute(identifier, instance);
     }
     else {
       instance.doNavigation(context);
     }
     return instance;
   }
 
   /**
    * Returns the single instance, creating one if it can't be found (or has changed)
    *
    * set the increment to null, in order to have it defaulted for this table
    * the RecordSet is referenced in the session by the identifier
    */
   public static synchronized RecordSet getInstance(
     WebContext context,
     String db,
     String table,
     PreparedStatement sql,
     Integer inc,
     String identifier)
     throws Exception {
     HttpSession session = context.getSession();
     RecordSet instance = (RecordSet)session.getAttribute(identifier);
     if (instance == null
       || context.getForm("submit") != null
       || (inc != null && (inc.intValue() != instance.increment))) {
       instance = new RecordSet(db, table, sql, inc);
       session.setAttribute(identifier, instance);
     }
     else {
       instance.doNavigation(context);
     }
     return instance;
   }
 
   /**
    * copes with situations where no identifier is specified (should be marked as depreciated)
    */
   public static synchronized RecordSet getInstance(
     WebContext context,
     String db,
     String table,
     String sql,
     Integer inc)
     throws Exception {
     return getInstance(context, db, table, sql, inc, table);
   }
 
   /**
    * set the ignore deleted flag
    */
   public void setIgnoreDeleted(boolean del) {
     ignoreDeleted = true;
   }
 
   /**
    * Returns the single instance, or null it can't be found (or has changed)
    *
    * the RecordSet is referenced in the session by the identifier
    */
   public static synchronized RecordSet getInstance(
     WebContext context,
     String identifier)
     throws Exception {
     HttpSession session = context.getSession();
     RecordSet instance = (RecordSet)session.getAttribute(identifier);
     if (instance == null || (context.getForm("submit") != null)) {
       session.removeAttribute(identifier);
       return null;
     }
     else {
       instance.doNavigation(context);
       return instance;
     }
   }
 
   public void doNavigation(WebContext context) throws Exception {
     if (context.getForm("next") != null) {
       moveNext();
     }
     if (context.getForm("previous") != null) {
       movePrevious();
     }
   }
 
   // get the next x records - returns an enumeration so that you can build your own results
   public Enumeration getNext() throws Exception {
     Vector results = new Vector();
     increment();
     for (int i = currentRecord; i < max; i++) {
       Integer id = (Integer)recordIds.elementAt(i);
       results.addElement(id);
     }
     return results.elements();
   }
 
   // get the next x records - returned as a vector of ddrecords, useful for very simple handlets
   public Vector getRows() throws Exception {
     loadData();
     return currentData;
   }
 
   // get the next x records - returned as a vector of ddrecords, useful for very simple handlets
   public void loadData() throws Exception {
     Vector results = new Vector();
     increment();
     for (int i = currentRecord; i < max; i++) {
       Integer id = null;
       // this is required in order to cope with situations when a record has 
       // been deleted
       try {
         id = (Integer)recordIds.elementAt(i);
       }
       catch (ArrayIndexOutOfBoundsException e) {
         ; // if record has been deleted
       }
       if (id != null) {
         DDRecord ddtable = getRecord(database, table, id);
         DDField field = (DDField)ddtable.get("id");
         // ignore deleted records?
         boolean del = false;
         if (ignoreDeleted) {
           try {
             DDField deleted = (DDField)ddtable.get("deleted");
             del = ((Boolean)deleted.getValue()).booleanValue();
           }
           catch (NoSuchFieldException e) { 
             ; // it might not be there
           }
         }
         if (field.getValue() == null || del) {
           recordIds.removeElementAt(i);
           i--;
         }
         else {
           results.addElement(ddtable);
         }
       }
     }
     setMaxRecord(max);
     currentData = results;
   }
 
   // split out this method so that it can be overwritten
   public DDRecord getRecord(String database, String table, Integer id)
     throws Exception {
     return dataCache.getDDRecord(database, table, id);
   }
 
   // remove a record for the table
   public boolean removeID(Integer id) {
     return recordIds.removeElement(id);
   }
 
   private void increment() {
     if (increment == 0) {
       max = recordIds.size();
     }
     else {
       max = currentRecord + increment;
     }
     setMaxRecord(max);
   }
 
   // allows records to be dynamically inserted into the recordset
   public void addElement(Integer id) {
     recordIds.insertElementAt(id, currentRecord);
   }
 
   public TableMetaData getMetaData() {
     return metaData;
   }
 
   public int getIncrement() {
     return increment;
   }
 
   public boolean getLimited() {
     return limited;
   }
 
   public int getSize() {
     return recordIds.size();
   }
 
   public int getCurrentRecord() {
     return currentRecord;
   }
 
   public void setCurrentRecord(int i) {
     currentRecord = i;
   }
 
   public int getDisplayCurrentRecord() {
     if (getSize() > 0) {
       return currentRecord + 1;
     }
     else {
       return 0;
     }
   }
 
   public int getMaxRecord() {
     return max;
   }
 
   public void setMaxRecord(int a) {
     max = a;
     if (max > recordIds.size()) {
       max = recordIds.size();
     }
   }
 
   public int getPages() {
     if (increment == 0) {
       return 1;
     }
     else {
       if ((recordIds.size() % increment) == 0) {
         return (recordIds.size() / increment);
       }
       else {
         return (recordIds.size() / increment) + 1;
       }
     }
   }
 
   public int getPage() {
     if (increment == 0) {
       return 1;
     }
     else {
       return ((currentRecord) / increment) + 1;
     }
   }
 
   public String getSqlString() {
     return sqlString;
   }
 
   public void moveNext() {
     currentRecord += increment;
   }
 
   public void movePrevious() {
     currentRecord -= increment;
   }
 
   public boolean getStart() {
     if (getPage() == 1) {
       return true;
     }
     else {
       return false;
     }
   }
 
   public boolean getEnd() {
     if (getPage() == getPages()) {
       return true;
     }
     else {
       return false;
     }
   }
 
   public Hashtable getState() {
     return state;
   }
 
 }