/*
 * 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.tomcat.jdbc.pool.interceptor;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.ResultSet;
import java.sql.Statement;

import org.apache.tomcat.jdbc.pool.ConnectionPool;
import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
import org.apache.tomcat.jdbc.pool.PooledConnection;

/**
 * Abstraction interceptor. This component intercepts all calls to create some type of SQL statement. By extending this
 * class, one can intercept queries and update statements by overriding the
 * {@link #createStatement(Object, Method, Object[], Object, long)} method.
 */
public abstract class AbstractCreateStatementInterceptor extends JdbcInterceptor {
    protected static final String CREATE_STATEMENT = "createStatement";
    protected static final int CREATE_STATEMENT_IDX = 0;
    protected static final String PREPARE_STATEMENT = "prepareStatement";
    protected static final int PREPARE_STATEMENT_IDX = 1;
    protected static final String PREPARE_CALL = "prepareCall";
    protected static final int PREPARE_CALL_IDX = 2;

    /**
     * {@link Statement#getResultSet()}
     */
    protected static final String GET_RESULTSET = "getResultSet";

    /**
     * {@link Statement#getGeneratedKeys()}
     */
    protected static final String GET_GENERATED_KEYS = "getGeneratedKeys";

    /**
     * {@link ResultSet#getStatement()}
     */
    protected static final String GET_STATEMENT = "getStatement";

    protected static final int RESULTSET_IDX = 3;

    protected static final String[] STATEMENT_TYPES = { CREATE_STATEMENT, PREPARE_STATEMENT, PREPARE_CALL };
    protected static final int STATEMENT_TYPE_COUNT = STATEMENT_TYPES.length;

    protected static final String EXECUTE = "execute";
    protected static final String EXECUTE_QUERY = "executeQuery";
    protected static final String EXECUTE_UPDATE = "executeUpdate";
    protected static final String EXECUTE_BATCH = "executeBatch";

    protected static final String[] EXECUTE_TYPES = { EXECUTE, EXECUTE_QUERY, EXECUTE_UPDATE, EXECUTE_BATCH };

    /**
     * the constructors that are used to create statement proxies
     */
    protected static final Constructor<?>[] constructors = new Constructor[STATEMENT_TYPE_COUNT + 1];

    public AbstractCreateStatementInterceptor() {
        super();
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (compare(CLOSE_VAL, method)) {
            closeInvoked();
            return super.invoke(proxy, method, args);
        } else {
            boolean process = false;
            process = isStatement(method, process);
            if (process) {
                long start = System.currentTimeMillis();
                Object statement = super.invoke(proxy, method, args);
                long delta = System.currentTimeMillis() - start;
                return createStatement(proxy, method, args, statement, delta);
            } else {
                return super.invoke(proxy, method, args);
            }
        }
    }

    /**
     * Creates a constructor for a proxy class, if one doesn't already exist
     *
     * @param idx   - the index of the constructor
     * @param clazz - the interface that the proxy will implement
     *
     * @return - returns a constructor used to create new instances
     *
     * @throws NoSuchMethodException Constructor not found
     */
    protected Constructor<?> getConstructor(int idx, Class<?> clazz) throws NoSuchMethodException {
        if (constructors[idx] == null) {
            Class<?> proxyClass = Proxy.getProxyClass(AbstractCreateStatementInterceptor.class.getClassLoader(),
                    new Class[] { clazz });
            constructors[idx] = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
        }
        return constructors[idx];
    }

    /**
     * This method will be invoked after a successful statement creation. This method can choose to return a wrapper
     * around the statement or return the statement itself. If this method returns a wrapper then it should return a
     * wrapper object that implements one of the following interfaces. {@link java.sql.Statement},
     * {@link java.sql.PreparedStatement} or {@link java.sql.CallableStatement}
     *
     * @param proxy     the actual proxy object
     * @param method    the method that was called. It will be one of the methods defined in {@link #STATEMENT_TYPES}
     * @param args      the arguments to the method
     * @param statement the statement that the underlying connection created
     * @param time      Elapsed time
     *
     * @return a {@link java.sql.Statement} object
     */
    public abstract Object createStatement(Object proxy, Method method, Object[] args, Object statement, long time);

    /**
     * Method invoked when the operation {@link java.sql.Connection#close()} is invoked.
     */
    public abstract void closeInvoked();

    /**
     * Returns true if the method that is being invoked matches one of the statement types.
     *
     * @param method  the method being invoked on the proxy
     * @param process boolean result used for recursion
     *
     * @return returns true if the method name matched
     */
    protected boolean isStatement(Method method, boolean process) {
        return process(STATEMENT_TYPES, method, process);
    }

    /**
     * Returns true if the method that is being invoked matches one of the execute types.
     *
     * @param method  the method being invoked on the proxy
     * @param process boolean result used for recursion
     *
     * @return returns true if the method name matched
     */
    protected boolean isExecute(Method method, boolean process) {
        return process(EXECUTE_TYPES, method, process);
    }

    /*
     * Returns true if the method that is being invoked matches one of the method names passed in
     *
     * @param names list of method names that we want to intercept
     *
     * @param method the method being invoked on the proxy
     *
     * @param process boolean result used for recursion
     *
     * @return returns true if the method name matched
     */
    protected boolean process(String[] names, Method method, boolean process) {
        final String name = method.getName();
        for (int i = 0; (!process) && i < names.length; i++) {
            process = compare(names[i], name);
        }
        return process;
    }

    /**
     * no-op for this interceptor. no state is stored.
     */
    @Override
    public void reset(ConnectionPool parent, PooledConnection con) {
        // NOOP
    }
}
