/*
    * 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.pool.service;
  
  import fr.paris.lutece.portal.service.util.AppException;
  
  import org.apache.log4j.Logger;
  
  import java.io.PrintWriter;
  
  import java.sql.Connection;
  import java.sql.DriverManager;
  import java.sql.SQLException;
  import java.sql.Statement;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import javax.sql.DataSource;
  
  
  /**
   * This class manages a database connection pool.
   * <br>
   * Connections are wrapped by a {@link LuteceConnection}
   * to avoid explicit calls to {@link Connection#close()}. Connections
   * are released to this pool when {@link Connection#close()} is called, and
   * are not actually closed until {@link #release()} call.
   * @see LuteceConnection
   */
  public class ConnectionPool implements DataSource
  {
      private static final String DEFAULT_CHECK_VALID_CONNECTION_SQL = "SELECT 1";
      private String _strUrl;
      private String _strUser;
      private String _strPassword;
      private int _nMaxConns;
      private int _nTimeOut;
      private Logger _logger;
      private int _nCheckedOut;
      private List<Connection> _freeConnections = new ArrayList<Connection>(  );
      private String _strCheckValidConnectionSql; // Added in v1.4
      private PrintWriter _logWriter;
  
      /**
       * Constructor.
       *
       * @param strName Nom du pool
       * @param strUrl JDBC Data source URL
       * @param strUser SQL User
       * @param strPassword SQL Password
       * @param nMaxConns Max connections
       * @param nInitConns Initials connections
       * @param nTimeOut Timeout to get a connection
       * @param logger the Logger object
       * @param strCheckValidConnectionSql The SQL syntax used for check connexion validatation
       */
      public ConnectionPool( String strName, String strUrl, String strUser, String strPassword, int nMaxConns,
          int nInitConns, int nTimeOut, Logger logger, String strCheckValidConnectionSql )
      {
          _strUrl = strUrl;
          _strUser = strUser;
          _strPassword = strPassword;
          _nMaxConns = nMaxConns;
          _nTimeOut = ( nTimeOut > 0 ) ? nTimeOut : 5;
          _logger = logger;
          initPool( nInitConns );
          _logger.info( "New pool created : " + strName );
 
         _strCheckValidConnectionSql = ( ( strCheckValidConnectionSql != null ) &&
             !strCheckValidConnectionSql.equals( "" ) ) ? strCheckValidConnectionSql : DEFAULT_CHECK_VALID_CONNECTION_SQL;
 
         String lf = System.getProperty( "line.separator" );
         _logger.debug( lf + " url=" + strUrl + lf + " user=" + _strUser + lf + " password=" + _strPassword + lf +
             " initconns=" + nInitConns + lf + " maxconns=" + _nMaxConns + lf + " logintimeout=" + _nTimeOut );
         _logger.debug( getStats(  ) );
     }
 
     /**
      * Initializes the pool
      *
      * @param initConns Number of connections to create at the initialisation
      */
     private void initPool( int initConns )
     {
         for ( int i = 0; i < initConns; i++ )
         {
             try
             {
                 Connection pc = newConnection(  );
                 _freeConnections.add( pc );
             }
             catch ( SQLException e )
             {
                 throw new AppException( "SQL Error executing command : " + e.toString(  ) );
             }
         }
     }
 
     /**
      * Returns a connection from the pool.
      *
      * @return An open connection
      * @throws SQLException The SQL exception
      */
     @Override
     public Connection getConnection(  ) throws SQLException
     {
         _logger.debug( "Request for connection received" );
 
         try
         {
             return getConnection( _nTimeOut * 1000L );
         }
         catch ( SQLException e )
         {
             _logger.error( "Exception getting connection", e );
             throw e;
         }
     }
 
     /**
      * Returns a connection from the pool.
      *
      * @param timeout The maximum time to wait for a connection
      * @return An open connection
      * @throws SQLException The SQL exception
      */
     private synchronized Connection getConnection( long timeout )
         throws SQLException
     {
         // Get a pooled Connection from the cache or a new one.
         // Wait if all are checked out and the max limit has
         // been reached.
         long startTime = System.currentTimeMillis(  );
         long remaining = timeout;
         Connection conn = null;
 
         while ( ( conn = getPooledConnection(  ) ) == null )
         {
             try
             {
                 _logger.debug( "Waiting for connection. Timeout=" + remaining );
 
                 wait( remaining );
             }
             catch ( InterruptedException e )
             {
                 _logger.debug( "A connection has been released by another thread." );
             }
 
             remaining = timeout - ( System.currentTimeMillis(  ) - startTime );
 
             if ( remaining <= 0 )
             {
                 // Timeout has expired
                 _logger.debug( "Time-out while waiting for connection" );
                 throw new SQLException( "getConnection() timed-out" );
             }
         }
 
         // Check if the Connection is still OK
         if ( !isConnectionOK( conn ) )
         {
             // It was bad. Try again with the remaining timeout
             _logger.error( "Removed selected bad connection from pool" );
 
             return getConnection( remaining );
         }
 
         _nCheckedOut++;
         _logger.debug( "Delivered connection from pool" );
         _logger.debug( getStats(  ) );
 
         return conn;
     }
 
     /**
      * Checks a connection to see if it's still alive
      *
      * @param conn The connection to check
      * @return true if the connection is OK, otherwise false.
      */
     private boolean isConnectionOK( Connection conn )
     {
         Statement testStmt = null;
 
         try
         {
             if ( !conn.isClosed(  ) )
             {
                 // Try to createStatement to see if it's really alive
                 testStmt = conn.createStatement(  );
                 testStmt.executeQuery( _strCheckValidConnectionSql );
                 testStmt.close(  );
             }
             else
             {
                 return false;
             }
         }
         catch ( SQLException e )
         {
             if ( testStmt != null )
             {
                 try
                 {
                     testStmt.close(  );
                 }
                 catch ( SQLException se )
                 {
                     throw new AppException( "ConnectionService : SQL Error executing command : " + se.toString(  ) );
                 }
             }
 
             _logger.error( "Pooled Connection was not okay", e );
 
             return false;
         }
 
         return true;
     }
 
     /**
      * Gets a connection from the pool
      *
      * @return An opened connection
      * @throws SQLException The exception
      */
     private Connection getPooledConnection(  ) throws SQLException
     {
         Connection conn = null;
 
         if ( _freeConnections.size(  ) > 0 )
         {
             // Pick the first Connection in the Vector
             // to get round-robin usage
             conn = _freeConnections.get( 0 );
             _freeConnections.remove( 0 );
         }
         else if ( ( _nMaxConns == 0 ) || ( _nCheckedOut < _nMaxConns ) )
         {
             conn = newConnection(  );
         }
 
         return conn;
     }
 
     /**
      * Creates a new connection.
      * <br>
      * The connection is wrapped by {@link LuteceConnection}
      *
      * @return The new created connection
      * @throws SQLException The SQL exception
      */
     private Connection newConnection(  ) throws SQLException
     {
         Connection conn;
 
         if ( _strUser == null )
         {
             conn = DriverManager.getConnection( _strUrl );
         }
         else
         {
             conn = DriverManager.getConnection( _strUrl, _strUser, _strPassword );
         }
 
         // wrap connection so this connection pool is used when conn.close() is called
         conn = LuteceConnectionFactory.newInstance( this, conn );
 
         _logger.info( "New connection created. Connections count is : " + ( getConnectionCount(  ) + 1 ) );
 
         return conn;
     }
 
     /**
      * Returns a connection to pool.
      *
      * @param conn The released connection to return to pool
      */
     public synchronized void freeConnection( Connection conn )
     {
         // Put the connection at the end of the Vector
         _freeConnections.add( conn );
         _nCheckedOut--;
         notifyAll(  );
         _logger.debug( "Returned connection to pool" );
         _logger.debug( getStats(  ) );
     }
 
     /**
      * Releases the pool by closing all its connections.
      */
     public synchronized void release(  )
     {
         for ( Connection connection : _freeConnections )
         {
             try
             {
                 if ( connection instanceof LuteceConnection )
                 {
                     ( (LuteceConnection) connection ).closeConnection(  );
                 }
                 else
                 {
                     connection.close(  );
                 }
 
                 _logger.debug( "Closed connection" );
             }
             catch ( SQLException e )
             {
                 _logger.error( "Couldn't close connection", e );
             }
         }
 
         _freeConnections.clear(  );
     }
 
     /**
      * Returns stats on pool's connections
      *
      * @return Stats as String.
      */
     private String getStats(  )
     {
         return "Total connections: " + getConnectionCount(  ) + " Available: " + getFreeConnectionCount(  ) +
         " Checked-out: " + getBusyConnectionCount(  );
     }
 
     /**
      * Returns the number of connections opened by the pool (available or busy)
      * @return A connection count
      */
     public int getConnectionCount(  )
     {
         return getFreeConnectionCount(  ) + getBusyConnectionCount(  );
     }
 
     /**
      * Returns the number of free connections of the pool (available or busy)
      * @return A connection count
      */
     public int getFreeConnectionCount(  )
     {
         return _freeConnections.size(  );
     }
 
     /**
      * Returns the number of busy connections of the pool (available or busy)
      * @return A connection count
      */
     public int getBusyConnectionCount(  )
     {
         return _nCheckedOut;
     }
 
     /**
      * Returns the maximum number of connections of the pool
      * @return A connection count
      */
     public int getMaxConnectionCount(  )
     {
         return _nMaxConns;
     }
 
     /**
      * Returns the connection of the pool.
      *
      * @param username the username
      * @param password the password
      * @return A connection
      * @throws SQLException the sQL exception
      */
     @Override
     public Connection getConnection( String username, String password )
         throws SQLException
     {
         return getConnection(  );
     }
 
     /**
      * Get the log.
      *
      * @return A log writer
      * @throws SQLException the sQL exception
      */
     @Override
     public PrintWriter getLogWriter(  ) throws SQLException
     {
         _logger.debug( "ConnectionPool : DataSource getLogWriter called" );
 
         return _logWriter;
     }
 
     /**
      * Set the log.
      *
      * @param out the new log writer
      * @throws SQLException the sQL exception
      */
     @Override
     public void setLogWriter( PrintWriter out ) throws SQLException
     {
         _logger.debug( "ConnectionPool : DataSource setLogWriter called" );
         _logWriter = out;
     }
 
     /**
      * Set Login Timeout.
      *
      * @param seconds the new login timeout
      * @throws SQLException the sQL exception
      */
     @Override
     public void setLoginTimeout( int seconds ) throws SQLException
     {
     }
 
     /**
      * Get loging timeout.
      *
      * @return A time out
      * @throws SQLException the sQL exception
      */
     @Override
     public int getLoginTimeout(  ) throws SQLException
     {
         return _nTimeOut;
     }
 
     /**
      * Get the unwrap.
      *
      * @param <T> the generic type
      * @param iface the iface
      * @return null
      * @throws SQLException the sQL exception
      */
     @Override
     public <T> T unwrap( Class<T> iface ) throws SQLException
     {
         return null;
     }
 
     /**
      * Get the wrapper.
      *
      * @param iface the iface
      * @return false
      * @throws SQLException the sQL exception
      */
     @Override
     public boolean isWrapperFor( Class<?> iface ) throws SQLException
     {
         return false;
     }
 
     /**
      * Implementation of JDBC 4.1's getParentLogger method (Java 7)
      *
      * @return the parent logger
      */
     public java.util.logging.Logger getParentLogger(  )
     {
         return java.util.logging.Logger.getLogger( java.util.logging.Logger.GLOBAL_LOGGER_NAME );
     }
 }