/*
    * Copyright (c) 2002-2014, Mairie de Paris
    * All rights reserved.
    *
    * Redistribution and use in source and binary forms, with or without
    * modification, are permitted provided that the following conditions
    * are met:
    *
    *  1. Redistributions of source code must retain the above copyright notice
   *     and the following disclaimer.
   *
   *  2. Redistributions in binary form must reproduce the above copyright notice
   *     and the following disclaimer in the documentation and/or other materials
   *     provided with the distribution.
   *
   *  3. Neither the name of 'Mairie de Paris' nor 'Lutece' nor the names of its
   *     contributors may be used to endorse or promote products derived from
   *     this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
   * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   * POSSIBILITY OF SUCH DAMAGE.
   *
   * License 1.0
   */
  package fr.paris.lutece.util.sql;
  
  import fr.paris.lutece.portal.service.database.AppConnectionService;
  import fr.paris.lutece.portal.service.database.PluginConnectionService;
  import fr.paris.lutece.portal.service.plugin.Plugin;
  import fr.paris.lutece.portal.service.util.AppException;
  
  import org.apache.commons.lang.StringUtils;
  
  import org.apache.log4j.Logger;
  
  import java.sql.Connection;
  import java.sql.PreparedStatement;
  import java.sql.SQLException;
  
  
  /**
   * Transaction
   */
  public class Transaction
  {
      /**
       * Status for opened transactions
       */
      public static final int OPENED = -1;
  
      /**
       * Status for committed transactions
       */
      public static final int COMMITTED = 0;
  
      /**
       * Status for roll backed transactions
       */
      public static final int ROLLEDBACK = 1;
      private static final String DEFAULT_MODULE_NAME = "core";
      private static final String LOGGER_DEBUG_SQL = "lutece.debug.sql.";
  
      /**
       * The last SQL query executed by this transaction
       */
      private String _strSQL = StringUtils.EMPTY;
  
      /** JDBC Connection */
      private Connection _connection;
  
      /** Connection Service providing connection from a defined pool */
      private PluginConnectionService _connectionService;
  
      /** Plugin name */
      private String _strPluginName;
  
      /** The debug logger */
      private Logger _logger;
      private PreparedStatement _statement;
      private int _nStatus = OPENED;
      private boolean _bAutoCommit;
  
      /**
       * Constructor
       */
      public Transaction(  )
      {
          beginTransaction( null );
      }
  
     /**
      * Constructor
      * @param plugin The plugin owner of the transaction
      */
     public Transaction( Plugin plugin )
     {
         beginTransaction( plugin );
     }
 
     /**
      * Gets a prepared statement
      * @param strSQL The SQL statement
      * @return The prepared statement
      * @throws SQLException If an SQL error occurs
      */
     public PreparedStatement prepareStatement( String strSQL )
         throws SQLException
     {
         // Close the previous statement if exists
         if ( _statement != null )
         {
             _statement.close(  );
         }
 
         // Get a new statement 
         _strSQL = strSQL;
 
         if ( _connection == null )
         {
             throw new SQLException( "Plugin : '" + _strPluginName +
                 "' - Connection has been closed. The new prepared statement can not be created : " + strSQL );
         }
 
         _statement = _connection.prepareStatement( _strSQL );
 
         return _statement;
     }
 
     /**
      * The current prepared statement
      * @return The current statement
      */
     public PreparedStatement getStatement(  )
     {
         return _statement;
     }
 
     /**
      * Execute the current statement
      * @throws SQLException If an SQL error occurs
      */
     public void executeStatement(  ) throws SQLException
     {
         _logger.debug( "Plugin : '" + _strPluginName + "' - EXECUTE STATEMENT : " + _strSQL );
         _statement.executeUpdate(  );
     }
 
     /**
      * Commit the transaction
      */
     public void commit(  )
     {
         try
         {
             if ( _connection == null )
             {
                 throw new SQLException( "Plugin : '" + _strPluginName +
                     "' - Transaction has already been closed and can not be committed" );
             }
 
             _connection.commit(  );
             _logger.debug( "Plugin : '" + _strPluginName + "' - COMMIT TRANSACTION" );
             closeTransaction( COMMITTED );
         }
         catch ( SQLException e )
         {
             rollback( e );
         }
     }
 
     /**
      * Rollback the transaction
      */
     public void rollback(  )
     {
         rollback( null );
     }
 
     /**
      * Rollback the transaction
      * @param e The exception that cause the rollback
      */
     public void rollback( Exception e )
     {
         if ( e != null )
         {
             _logger.error( "Transaction Error - Rollback in progress " + e.getMessage(  ), e.getCause(  ) );
         }
 
         try
         {
             if ( _connection != null )
             {
                 _connection.rollback(  );
                 _logger.debug( "Plugin : '" + _strPluginName + "' - ROLLBACK TRANSACTION" );
             }
             else
             {
                 _logger.debug( "Plugin : '" + _strPluginName + "' - TRANSACTION HAS ALREADY BEEN ROLLED BACK" );
             }
         }
         catch ( SQLException ex )
         {
             _logger.error( "Transaction Error - Rollback error : " + ex.getMessage(  ), ex.getCause(  ) );
         }
         finally
         {
             closeTransaction( ROLLEDBACK );
         }
     }
 
     /**
      * Return the transaction status
      * @return The transaction status
      */
     public int getStatus(  )
     {
         return _nStatus;
     }
 
     /**
      * Get the underlying connection.
      * @return The connection of this transaction. If the transaction has not
      *         begin, then return null.
      */
     protected Connection getConnection(  )
     {
         return _connection;
     }
 
     /**
      * Begin a transaction
      * @param plugin The plugin owner of the transaction
      */
     protected void beginTransaction( Plugin plugin )
     {
         if ( plugin != null )
         {
             _strPluginName = plugin.getName(  );
             _connectionService = plugin.getConnectionService(  );
         }
         else
         {
             _strPluginName = DEFAULT_MODULE_NAME;
             _connectionService = AppConnectionService.getDefaultConnectionService(  );
         }
 
         if ( _connectionService == null )
         {
             throw new AppException( "Database access error. Please check component installations and db.properties." );
         }
 
         _logger = Logger.getLogger( LOGGER_DEBUG_SQL + _strPluginName );
         _logger.debug( "Plugin : '" + _strPluginName + "' - BEGIN TRANSACTION" );
 
         try
         {
             _connection = _connectionService.getConnection(  );
 
             // Save the autocommit configuration of the connection
             _bAutoCommit = _connection.getAutoCommit(  );
             _connection.setAutoCommit( false );
         }
         catch ( SQLException e )
         {
             rollback( e );
         }
     }
 
     /**
      * Close the transaction
      * @param nStatus The status of the transaction
      */
     private void closeTransaction( int nStatus )
     {
         _nStatus = nStatus;
 
         try
         {
             if ( _statement != null )
             {
                 _statement.close(  );
             }
 
             // Restore the autocommit configuration of the connection
             if ( _connection != null )
             {
                 _connection.setAutoCommit( _bAutoCommit );
             }
         }
         catch ( SQLException ex )
         {
             _logger.error( "Transaction Error - Unable to close transaction " + ex.getMessage(  ), ex.getCause(  ) );
         }
         finally
         {
             _connectionService.freeConnection( _connection );
             _connection = null;
         }
     }
 
     /**
      * Checks that the transaction has been committed (or rolled back) before
      * being destroyed and release all transaction resources (statement,
      * connection, ...) if not. {@inheritDoc }
      */
     @Override
     protected void finalize(  ) throws Throwable
     {
         if ( _nStatus == OPENED )
         {
             _logger.error( "The transaction has not been commited" );
             closeTransaction( OPENED );
         }
 
         super.finalize(  );
     }
 }