/*

 * Licensed to the Apache Software Foundation (ASF) under one or more

 * contributor license agreements.  See the NOTICE file distributed with

 * this work for additional information regarding copyright ownership.

 * The ASF licenses this file to You 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.commons.dbcp;

import java.io.PrintWriter;

import java.sql.CallableStatement;

import java.sql.Connection;

import java.sql.DatabaseMetaData;

import java.sql.PreparedStatement;

import java.sql.SQLException;

import java.sql.SQLWarning;

import java.sql.Statement;

import java.util.Map;

import java.util.NoSuchElementException;

import javax.sql.DataSource;

import org.apache.commons.pool.ObjectPool;

/**

 * A simple {@link DataSource} implementation that obtains

 * {@link Connection}s from the specified {@link ObjectPool}.

 *

 * @author Rodney Waldhoff

 * @author Glenn L. Nielsen

 * @author James House

 * @author Dirk Verbeeck

 */

public class PoolingDataSource implements DataSource {

    /** Controls access to the underlying connection */

    private boolean accessToUnderlyingConnectionAllowed = false; 

    public PoolingDataSource() {

        this(null);

    }

    public PoolingDataSource(ObjectPool pool) {

        _pool = pool;

    }

    public void setPool(ObjectPool pool) throws IllegalStateException, NullPointerException {

        if(null != _pool) {

            throw new IllegalStateException("Pool already set");

        } else if(null == pool) {

            throw new NullPointerException("Pool must not be null.");

        } else {

            _pool = pool;

        }

    }

    /**

     * Returns the value of the accessToUnderlyingConnectionAllowed property.

     * 

     * @return true if access to the underlying is allowed, false otherwise.

     */

    public boolean isAccessToUnderlyingConnectionAllowed() {

        return this.accessToUnderlyingConnectionAllowed;

    }

    /**

     * Sets the value of the accessToUnderlyingConnectionAllowed property.

     * It controls if the PoolGuard allows access to the underlying connection.

     * (Default: false)

     * 

     * @param allow Access to the underlying connection is granted when true.

     */

    public void setAccessToUnderlyingConnectionAllowed(boolean allow) {

        this.accessToUnderlyingConnectionAllowed = allow;

    }

    /*

    public boolean isWrapperFor(Class<?> iface) throws SQLException {

        return false;

    }

    public <T> T unwrap(Class<T> iface) throws SQLException {

        throw new SQLException("PoolingDataSource is not a wrapper.");

    }

    */

    //--- DataSource methods -----------------------------------------

    /**

     * Return a {@link java.sql.Connection} from my pool,

     * according to the contract specified by {@link ObjectPool#borrowObject}.

     */

    public Connection getConnection() throws SQLException {

        try {

            Connection conn = (Connection)(_pool.borrowObject());

            if (conn != null) {

                conn = new PoolGuardConnectionWrapper(conn);

            } 

            return conn;

        } catch(SQLException e) {

            throw e;

        } catch(NoSuchElementException e) {

            throw new SQLNestedException("Cannot get a connection, pool error " + e.getMessage(), e);

        } catch(RuntimeException e) {

            throw e;

        } catch(Exception e) {

            throw new SQLNestedException("Cannot get a connection, general error", e);

        }

    }

    /**

     * Throws {@link UnsupportedOperationException}

     * @throws UnsupportedOperationException

     */

    public Connection getConnection(String uname, String passwd) throws SQLException {

        throw new UnsupportedOperationException();

    }

    /**

     * Returns my log writer.

     * @return my log writer

     * @see DataSource#getLogWriter

     */

    public PrintWriter getLogWriter() {

        return _logWriter;

    }

    /**

     * Throws {@link UnsupportedOperationException}.

     * @throws UnsupportedOperationException As this

     *   implementation does not support this feature.

     */

    public int getLoginTimeout() {

        throw new UnsupportedOperationException("Login timeout is not supported.");

    }

    /**

     * Throws {@link UnsupportedOperationException}.

     * @throws UnsupportedOperationException As this

     *   implementation does not support this feature.

     */

    public void setLoginTimeout(int seconds) {

        throw new UnsupportedOperationException("Login timeout is not supported.");

    }

    /**

     * Sets my log writer.

     * @see DataSource#setLogWriter

     */

    public void setLogWriter(PrintWriter out) {

        _logWriter = out;

    }

    /** My log writer. */

    protected PrintWriter _logWriter = null;

    protected ObjectPool _pool = null;

    /**

     * PoolGuardConnectionWrapper is a Connection wrapper that makes sure a 

     * closed connection cannot be used anymore.

     */

    private class PoolGuardConnectionWrapper extends DelegatingConnection {

        private Connection delegate;

        PoolGuardConnectionWrapper(Connection delegate) {

            super(delegate);

            this.delegate = delegate;

        }

        protected void checkOpen() throws SQLException {

            if(delegate == null) {

                throw new SQLException("Connection is closed.");

            }

        }

        public void close() throws SQLException {

            if (delegate != null) {

                this.delegate.close();

                this.delegate = null;

                super.setDelegate(null);

            }

        }

        public boolean isClosed() throws SQLException {

            if (delegate == null) {

                return true;

            }

            return delegate.isClosed();

        }

        public void clearWarnings() throws SQLException {

            checkOpen();

            delegate.clearWarnings();

        }

        public void commit() throws SQLException {

            checkOpen();

            delegate.commit();

        }

        public Statement createStatement() throws SQLException {

            checkOpen();

            return new DelegatingStatement(this, delegate.createStatement());

        }

        public Statement createStatement(int resultSetType, int resultSetConcurrency) throws SQLException {

            checkOpen();

            return new DelegatingStatement(this, delegate.createStatement(resultSetType, resultSetConcurrency));

        }

        public boolean innermostDelegateEquals(Connection c) {

            Connection innerCon = super.getInnermostDelegate();

            if (innerCon == null) {

                return c == null;

            } else {

                return innerCon.equals(c);

            }

        }

        public boolean getAutoCommit() throws SQLException {

            checkOpen();

            return delegate.getAutoCommit();

        }

        public String getCatalog() throws SQLException {

            checkOpen();

            return delegate.getCatalog();

        }

        public DatabaseMetaData getMetaData() throws SQLException {

            checkOpen();

            return delegate.getMetaData();

        }

        public int getTransactionIsolation() throws SQLException {

            checkOpen();

            return delegate.getTransactionIsolation();

        }

        public Map getTypeMap() throws SQLException {

            checkOpen();

            return delegate.getTypeMap();

        }

        public SQLWarning getWarnings() throws SQLException {

            checkOpen();

            return delegate.getWarnings();

        }

        public int hashCode() {

            if (delegate == null){

                return 0;

            }

            return delegate.hashCode();

        }

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (obj == this) {

                return true;

            }

            // Use superclass accessor to skip access test

            Connection conn = super.getInnermostDelegate();

            if (conn == null) {

                return false;

            }

            if (obj instanceof DelegatingConnection) {    

                DelegatingConnection c = (DelegatingConnection) obj;

                return c.innermostDelegateEquals(conn);

            }

            else {

                return conn.equals(obj);

            }

        }

        public boolean isReadOnly() throws SQLException {

            checkOpen();

            return delegate.isReadOnly();

        }

        public String nativeSQL(String sql) throws SQLException {

            checkOpen();

            return delegate.nativeSQL(sql);

        }

        public CallableStatement prepareCall(String sql) throws SQLException {

            checkOpen();

            return new DelegatingCallableStatement(this, delegate.prepareCall(sql));

        }

        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {

            checkOpen();

            return new DelegatingCallableStatement(this, delegate.prepareCall(sql, resultSetType, resultSetConcurrency));

        }

        public PreparedStatement prepareStatement(String sql) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this, delegate.prepareStatement(sql));

        }

        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this, delegate.prepareStatement(sql, resultSetType, resultSetConcurrency));

        }

        public void rollback() throws SQLException {

            checkOpen();

            delegate.rollback();

        }

        public void setAutoCommit(boolean autoCommit) throws SQLException {

            checkOpen();

            delegate.setAutoCommit(autoCommit);

        }

        public void setCatalog(String catalog) throws SQLException {

            checkOpen();

            delegate.setCatalog(catalog);

        }

        public void setReadOnly(boolean readOnly) throws SQLException {

            checkOpen();

            delegate.setReadOnly(readOnly);

        }

        public void setTransactionIsolation(int level) throws SQLException {

            checkOpen();

            delegate.setTransactionIsolation(level);

        }

        public void setTypeMap(Map map) throws SQLException {

            checkOpen();

            delegate.setTypeMap(map);

        }

        public String toString() {

            if (delegate == null){

                return "NULL";

            }

            return delegate.toString();

        }

        public int getHoldability() throws SQLException {

            checkOpen();

            return delegate.getHoldability();

        }

        public void setHoldability(int holdability) throws SQLException {

            checkOpen();

            delegate.setHoldability(holdability);

        }

        public java.sql.Savepoint setSavepoint() throws SQLException {

            checkOpen();

            return delegate.setSavepoint();

        }

        public java.sql.Savepoint setSavepoint(String name) throws SQLException {

            checkOpen();

            return delegate.setSavepoint(name);

        }

        public void releaseSavepoint(java.sql.Savepoint savepoint) throws SQLException {

            checkOpen();

            delegate.releaseSavepoint(savepoint);

        }

        public void rollback(java.sql.Savepoint savepoint) throws SQLException {

            checkOpen();

            delegate.rollback(savepoint);

        }

        public Statement createStatement(int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {

            checkOpen();

            return new DelegatingStatement(this, delegate.createStatement(resultSetType, resultSetConcurrency, resultSetHoldability));

        }

        public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {

            checkOpen();

            return new DelegatingCallableStatement(this, delegate.prepareCall(sql, resultSetType, resultSetConcurrency, resultSetHoldability));

        }

        public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this, delegate.prepareStatement(sql, autoGeneratedKeys));

        }

        public PreparedStatement prepareStatement(String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this,delegate.prepareStatement(sql, resultSetType, resultSetConcurrency, resultSetHoldability));

        }

        public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this, delegate.prepareStatement(sql, columnIndexes));

        }

        public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {

            checkOpen();

            return new DelegatingPreparedStatement(this, delegate.prepareStatement(sql, columnNames));

        }

        /**

         * @see org.apache.commons.dbcp.DelegatingConnection#getDelegate()

         */

        public Connection getDelegate() {

            if (isAccessToUnderlyingConnectionAllowed()) {

                return super.getDelegate();

            } else {

                return null;

            }

        }

        /**

         * @see org.apache.commons.dbcp.DelegatingConnection#getInnermostDelegate()

         */

        public Connection getInnermostDelegate() {

            if (isAccessToUnderlyingConnectionAllowed()) {

                return super.getInnermostDelegate();

            } else {

                return null;

            }

        }

    }

}