package org.openbravo.base;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.PreparedStatement;
import java.util.ArrayList;
import java.util.List;

import javax.enterprise.context.ApplicationScoped;

import org.apache.tomcat.jdbc.pool.ConnectionPool;
import org.apache.tomcat.jdbc.pool.JdbcInterceptor;
import org.apache.tomcat.jdbc.pool.PooledConnection;
import org.openbravo.database.PoolInterceptorProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@ApplicationScoped
public class PoolInterceptor extends JdbcInterceptor implements PoolInterceptorProvider {

  private static final Logger log = LoggerFactory.getLogger(PoolInterceptor.class);

  // TODO: make these params configurable at runtime
  private static final long minDurationStatements = 100L;
  private static final boolean logParamValues = true;
  private static final boolean logStatementStackTrace = true;

  @Override
  public void reset(ConnectionPool parent, PooledConnection con) {
    // System.out.println("connection borrowed " + con);

  }

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    // System.out.println("invoke " + method.getName());

    Object chain = super.invoke(proxy, method, args);
    // for prepared statements, return a proxy so we can log info about params and execution time
    if (compare("prepareStatement", method) && chain instanceof PreparedStatement) {
      return Proxy.newProxyInstance(PoolInterceptorProvider.class.getClassLoader(),
          new Class<?>[] { PreparedStatement.class }, new PSInvokationHandler(
              (PreparedStatement) chain, (String) args[0]));
    }
    return chain;
  }

  @Override
  public void disconnected(ConnectionPool parent, PooledConnection con, boolean finalizing) {
    System.out.println("disconnect " + con);
    super.disconnected(parent, con, finalizing);
  }

  @Override
  public String getPoolInterceptorsClassNames() {
    String fullClassName = this.getClass().getName();
    return fullClassName + ";";
  }

  private static class PSInvokationHandler implements InvocationHandler {

    private PreparedStatement ps;
    private String sql;
    private List<String> params;

    public PSInvokationHandler(PreparedStatement ps, String sql) {
      this.ps = ps;
      this.sql = sql;
      if (logParamValues) {
        params = new ArrayList<String>();
      }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
      String methodName = method.getName();

      if (logParamValues && methodName.startsWith("set") && args.length == 2) {
        // setting parameters, keep them so we can display values if required
        params.add("\n     $" + args[0] + ": " + args[1]);
      }

      long t = System.currentTimeMillis();

      Object obj = method.invoke(ps, args);

      long totalTime = System.currentTimeMillis() - t;
      if (totalTime > minDurationStatements) {
        StringBuilder logMsg = new StringBuilder();
        logMsg.append(methodName + " --- SQL: \n" + sql + "\n  t:" + totalTime);

        if (logParamValues) {
          for (String param : params) {
            logMsg.append(param);
          }
        }
        if (logStatementStackTrace) {
          log.info(logMsg.toString(), new Exception());
        } else {
          log.info(logMsg.toString());
        }
      }
      return obj;
    }

  }

}