/***
    *  The contents of this file are subject to the Mozilla Public
    *  License Version 1.1 (the "License"); you may not use this file
    *  except in compliance with the License. You may obtain a copy of
    *  the License at http://www.mozilla.org/MPL/
    *
    *  Software distributed under the License is distributed on an "AS
    *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    *  implied. See the License for the specific language governing
   *  rights and limitations under the License.
   *
   *  The Original Code is pow2toolkit library.
   *
   *  The Initial Owner of the Original Code is
   *  Power Of Two S.R.L. (www.pow2.com)
   *
   *  Portions created by Power Of Two S.R.L. are
   *  Copyright (C) Power Of Two S.R.L.
   *  All Rights Reserved.
   *
   * Contributor(s):
   */
  
  package com.pow2.dao;
  
  
  import java.sql.*;
  
  
  /***
   *  IdGenerator class.
   *  <br>
   *  Use the HIGH/LOW approach to generate an
   *  uinque Id.
   *  <br>
   *  This method uses the <code>app_identifier</code> database table
   *  <br>
   *   <table border="1" bgcolor="#f0f0f0">
   *   <tr>
   *     <td>field name</td>
   *     <td>field type</td>
   *     <td>is key ?</td>
   *   </tr>
   *   <tr>
   *     <td>id</td>
   *     <td>integer not null</td>
   *     <td>y</td>
   *   </tr>
   *   <tr>
   *     <td>high</td>
   *     <td>integer</td>
   *     <td>n</td>
   *   </tr>
   *  </table>
   *  <br><br>
   *
   * Initialize the unique table record with this SQL statement:
   * <br>
   * <code>INSERT INTO "app_identifier" VALUES (0,1);</code>
   *
   * @author     Luca Fossato
   */
  public class IdGenerator extends AbstractDAO
  {
    /*** low max value */
    public final static int LOW_MAXVALUE = 10;   // was: 10000
  
    /*** an handle to the unique IdGenerator instance */
    private static IdGenerator instance = null;
  
    /*** query used to retrieve the high value from the APP_IDENTIFIER table */
    private String qryGetHighValue;
  
    /*** query used to update the high value from the APP_IDENTIFIER table */
    private String qryUpdateHighValue;
  
    /*** id high value */
    private long high;
  
    /*** id low value */
    private int low;
  
  
    /***
     *  Protected default constructor.
     *  <br>
     *  Initialize the <code>high</code> and <code>low</code> values.
     */
    protected IdGenerator()
    {
      qryGetHighValue    = "select HIGH from APP_IDENTIFIER where id = 0";
      qryUpdateHighValue = "update APP_IDENTIFIER set HIGH = ? WHERE id = 0";
  
      try
      {
        high = getNextHighValue();
        cat.info("::IdGenerator - new high value: [" + high + "]");
      }
      catch (Exception e)
     {
       cat.error("::qryGetHighValue - cannot initialize the IdGenerator class: ", e);
       // exit here...
     }
 
     low = 0;
   }
 
 
   /***
    *  Get the instance of the IdGenerator class.
    *
    * @return    the instance of the IdGenerator class
    */
   public static synchronized IdGenerator instance()
   {
     if (instance == null)
       instance = new IdGenerator();
 
     return instance;
   }
 
 
   /***
    *  Sets the low attribute of the IdGenerator object
    *
    * @param  low  The new low value
    */
   public void setLow(int low)
   {
     this.low = low;
   }
 
 
   /***
    *  Gets the low attribute of the IdGenerator object
    *
    * @return    The low value
    */
   public int getLow()
   {
     return low;
   }
 
 
   /***
    *  Sets the high attribute of the IdGenerator object
    *
    * @param  high  The new high value
    */
   public void setHigh(long high)
   {
     this.high = high;
   }
 
 
   /***
    *  Gets the high attribute of the IdGenerator object
    *
    * @return    The high value
    */
   public long getHigh()
   {
     return high;
   }
 
 
   /***
    *  Get a new unique identifier number.
    *
    * @return                a new unique identifier number
    * @exception  Exception  Description of the Exception
    */
   public synchronized long getId() throws Exception
   {
     long id = -1;
 
     // every time a client requests a new id, the system increase low by 1 unit.
     // If low reaches LOW_MAXVALUE, it is set to 0, and the system increases
     // the high value by 1 unit.
     // The unique key is given by the combination of the high value and low value.
     low++;
 
     if (low >= LOW_MAXVALUE)
     {
       // 0 >= low < LOW_MAXVALUE
       // restart the low value;
       low = 0;
 
       // increase the high value (one database hit);
       high = getNextHighValue();
     }
 
     // i.e.: 10000 * 1 + 9999 , 10000 * 2 + 0;
     id = ((LOW_MAXVALUE * high) + low);
 
     //cat.debug(new StringBuffer("::getId - got new id [")
     //              .append(id).append("]; (high, low) = [")
     //              .append(high)
     //              .append(",")
     //              .append(low)
     //              .append("]").toString());
 
     return id;
   }
 
 
   /***
    * PRIVATE METHODS here
    */
 
 
   /***
    *  Get the next <code>HIGH</code> value from
    *  the <code>APP_IDENTIFIER</code> table.
    *  <br>
    *  Then update the table unique record increasing by 1
    *  the <code>HIGH</code> field value.
    *  <br>
    *  The queries are execute within a transaction with the
    *  isolation level set to <code>Connection.TRANSACTION_SERIALIZABLE</code>.
    *  <br>
    *  During the transaction, dirty reads, non-repeatable reads
    *  and phantom reads are prevented.
    *
    * @return  the next <code>HIGH</code> value from
    *          the <code>APP_IDENTIFIER</code> table
    * @exception  Exception  if any error occurs
    */
   private long getNextHighValue() throws Exception
   {
     Connection        con               = null;
     Statement         stGetHighValue    = null;
     PreparedStatement psUpdateHighValue = null;
     ResultSet         rs                = null;
     long              high              = -1;
 
     try
     {
       con = DAO.instance().getConnection();
 
       // starting the transaction;
       // it must prevent dirty reads, non-repeatable reads and phantom reads.
       con.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
       con.setAutoCommit(false);
 
       stGetHighValue = con.createStatement();
       rs = stGetHighValue.executeQuery(qryGetHighValue);
 
       // get the high value; this is the value that will be returned;
       if (rs.next())
         high = rs.getLong("HIGH");
 
       // update the HIGH field value;
       psUpdateHighValue = con.prepareStatement(qryUpdateHighValue);
       psUpdateHighValue.setLong(1, (high + 1));
       psUpdateHighValue.executeUpdate();
 
       // the transaction is committed into the finally clause...
       // commit the transaction;
       //con.commit();
       //con.setAutoCommit(true);
     }
     catch (SQLException e)
     {
       // rollback and *close* the transaction;
       // then execute the finally clause and rethrow the exception;
       cat.error("::getNextHighValue - rollback the current transaction", e);
       closeResources(con, false);
       throw e;
     }
     finally
     {
       closeResources(rs, stGetHighValue, psUpdateHighValue, con, true);
     }
 
     return high;
   }
 
 
   /***
    *  Close the JDBC resultSet, statement and preparedStatement objects,
    *  commit or rollback any uncommitted transaction and
    *  close the input connection.
    *  <br>
    *  Call this method into a <code>finally()</code> clause.
    *
    * @param  rs                the recordSet  object to close
    * @param  con               the Connection object to close
    * @param  st                the statement  object to close
    * @exception  SQLException  if any error occurs
    */
   private void closeResources(ResultSet         rs,
                               Statement         st,
                               PreparedStatement ps,
                               Connection        con,
                               boolean           commit)
     throws SQLException
   {
     if (ps  != null) ps.close();
     closeResources(rs, st, con, true);
   }
 }