/**
    *    Copyright 2009-2015 the original author or authors.
    *
    *    Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
    *
   *    Unless required by applicable law or agreed to in writing, software
   *    distributed under the License is distributed on an "AS IS" BASIS,
   *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *    See the License for the specific language governing permissions and
   *    limitations under the License.
   */
  package org.apache.ibatis.datasource.pooled;
  
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.sql.Connection;
  import java.sql.SQLException;
  
  import org.apache.ibatis.reflection.ExceptionUtil;
  
  /**
   * @author Clinton Begin
   */
  class PooledConnection implements InvocationHandler {
  
    private static final String CLOSE = "close";
    private static final Class<?>[] IFACES = new Class<?>[] { Connection.class };
  
    private int hashCode = 0;
    private PooledDataSource dataSource;
    private Connection realConnection;
    private Connection proxyConnection;
    private long checkoutTimestamp;
    private long createdTimestamp;
    private long lastUsedTimestamp;
    private int connectionTypeCode;
    private boolean valid;
  
    /*
     * Constructor for SimplePooledConnection that uses the Connection and PooledDataSource passed in
     *
     * @param connection - the connection that is to be presented as a pooled connection
     * @param dataSource - the dataSource that the connection is from
     */
    public PooledConnection(Connection connection, PooledDataSource dataSource) {
      this.hashCode = connection.hashCode();
      this.realConnection = connection;
      this.dataSource = dataSource;
      this.createdTimestamp = System.currentTimeMillis();
      this.lastUsedTimestamp = System.currentTimeMillis();
      this.valid = true;
      this.proxyConnection = (Connection) Proxy.newProxyInstance(Connection.class.getClassLoader(), IFACES, this);
    }
  
    /*
     * Invalidates the connection
     */
    public void invalidate() {
      valid = false;
    }
  
    /*
     * Method to see if the connection is usable
     *
     * @return True if the connection is usable
     */
    public boolean isValid() {
      return valid && realConnection != null && dataSource.pingConnection(this);
    }
  
    /*
     * Getter for the *real* connection that this wraps
     *
     * @return The connection
     */
    public Connection getRealConnection() {
      return realConnection;
    }
  
    /*
     * Getter for the proxy for the connection
     *
     * @return The proxy
     */
    public Connection getProxyConnection() {
      return proxyConnection;
    }
  
    /*
     * Gets the hashcode of the real connection (or 0 if it is null)
     *
     * @return The hashcode of the real connection (or 0 if it is null)
     */
    public int getRealHashCode() {
     return realConnection == null ? 0 : realConnection.hashCode();
   }
 
   /*
    * Getter for the connection type (based on url + user + password)
    *
    * @return The connection type
    */
   public int getConnectionTypeCode() {
     return connectionTypeCode;
   }
 
   /*
    * Setter for the connection type
    *
    * @param connectionTypeCode - the connection type
    */
   public void setConnectionTypeCode(int connectionTypeCode) {
     this.connectionTypeCode = connectionTypeCode;
   }
 
   /*
    * Getter for the time that the connection was created
    *
    * @return The creation timestamp
    */
   public long getCreatedTimestamp() {
     return createdTimestamp;
   }
 
   /*
    * Setter for the time that the connection was created
    *
    * @param createdTimestamp - the timestamp
    */
   public void setCreatedTimestamp(long createdTimestamp) {
     this.createdTimestamp = createdTimestamp;
   }
 
   /*
    * Getter for the time that the connection was last used
    *
    * @return - the timestamp
    */
   public long getLastUsedTimestamp() {
     return lastUsedTimestamp;
   }
 
   /*
    * Setter for the time that the connection was last used
    *
    * @param lastUsedTimestamp - the timestamp
    */
   public void setLastUsedTimestamp(long lastUsedTimestamp) {
     this.lastUsedTimestamp = lastUsedTimestamp;
   }
 
   /*
    * Getter for the time since this connection was last used
    *
    * @return - the time since the last use
    */
   public long getTimeElapsedSinceLastUse() {
     return System.currentTimeMillis() - lastUsedTimestamp;
   }
 
   /*
    * Getter for the age of the connection
    *
    * @return the age
    */
   public long getAge() {
     return System.currentTimeMillis() - createdTimestamp;
   }
 
   /*
    * Getter for the timestamp that this connection was checked out
    *
    * @return the timestamp
    */
   public long getCheckoutTimestamp() {
     return checkoutTimestamp;
   }
 
   /*
    * Setter for the timestamp that this connection was checked out
    *
    * @param timestamp the timestamp
    */
   public void setCheckoutTimestamp(long timestamp) {
     this.checkoutTimestamp = timestamp;
   }
 
   /*
    * Getter for the time that this connection has been checked out
    *
    * @return the time
    */
   public long getCheckoutTime() {
     return System.currentTimeMillis() - checkoutTimestamp;
   }
 
   @Override
   public int hashCode() {
     return hashCode;
   }
 
   /*
    * Allows comparing this connection to another
    *
    * @param obj - the other connection to test for equality
    * @see Object#equals(Object)
    */
   @Override
   public boolean equals(Object obj) {
     if (obj instanceof PooledConnection) {
       return realConnection.hashCode() == (((PooledConnection) obj).realConnection.hashCode());
     } else if (obj instanceof Connection) {
       return hashCode == obj.hashCode();
     } else {
       return false;
     }
   }
 
   /*
    * Required for InvocationHandler implementation.
    *
    * @param proxy  - not used
    * @param method - the method to be executed
    * @param args   - the parameters to be passed to the method
    * @see java.lang.reflect.InvocationHandler#invoke(Object, java.lang.reflect.Method, Object[])
    */
   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     String methodName = method.getName();
     if (CLOSE.hashCode() == methodName.hashCode() && CLOSE.equals(methodName)) {
       dataSource.pushConnection(this);
       return null;
     } else {
       try {
         if (!Object.class.equals(method.getDeclaringClass())) {
           // issue #579 toString() should never fail
           // throw an SQLException instead of a Runtime
           checkConnection();
         }
         return method.invoke(realConnection, args);
       } catch (Throwable t) {
         throw ExceptionUtil.unwrapThrowable(t);
       }
     }
   }
 
   private void checkConnection() throws SQLException {
     if (!valid) {
       throw new SQLException("Error accessing PooledConnection. Connection is invalid.");
     }
   }
 
 }