package org.apache.ojb.broker.util.batch;

 /* Copyright 2002-2005 The Apache Software Foundation

  *

  * 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.

  */

 import org.apache.ojb.broker.metadata.JdbcConnectionDescriptor;

 import org.apache.ojb.broker.platforms.PlatformFactory;

 import org.apache.ojb.broker.platforms.PlatformException;

 import org.apache.ojb.broker.platforms.Platform;

 import java.lang.reflect.Method;

 import java.lang.reflect.InvocationTargetException;

 import java.math.BigDecimal;

 import java.sql.Connection;

 import java.sql.PreparedStatement;

 import java.sql.SQLException;

 import java.util.ArrayList;

 //#ifdef JDK13

 import java.lang.reflect.InvocationHandler;

 //#else

 /*

 import com.develop.java.lang.reflect.InvocationHandler;

 */

 //#endif

 /**

  * The implementation of {@link java.reflect.InvocationHandler} which is used

  * to create dynamic proxy which will implement {@link java.sql.PreparedStatement} and

  * {@link BatchPreparedStatement}.

  *

  * @author Oleg Nitz (<a href="mailto:olegnitz@apache.org">olegnitz@apache.org</a>)

  */

 public class PreparedStatementInvocationHandler implements InvocationHandler

 {

     private final static Integer ONE = new Integer(1);

     private static Method ADD_BATCH;

     private final static Method SET_BIG_DECIMAL;

     static

     {

         Method setBigDecimal = null;

         try

         {

             setBigDecimal = PreparedStatement.class.getMethod("setBigDecimal",

                                                               new Class[] {Integer.TYPE, BigDecimal.class});

         }

         catch ( Exception ex )

         {

             // ignore it

         }

         SET_BIG_DECIMAL = setBigDecimal;

     }

     private final BatchConnection _batchConn;

     private final String _sql;

     private ArrayList _methods = new ArrayList();

     private ArrayList _params = new ArrayList();

     private Platform m_platform = null;

     public PreparedStatementInvocationHandler(BatchConnection batchConn, String sql, JdbcConnectionDescriptor jcd)

     {

         _batchConn = batchConn;

         _sql = sql;

         m_platform = PlatformFactory.getPlatformFor(jcd);

         try

         {

             ADD_BATCH = m_platform.getClass().getMethod("addBatch",new Class[]{PreparedStatement.class});

         }

         catch ( NoSuchMethodException e )

         {

             /**

              * should never happen

              */

             ADD_BATCH = null;

         }

         catch ( SecurityException e )

         {

             // ignore it

         }

     }

     public Object invoke(Object proxy, Method method, Object[] args)

     throws Throwable

     {

         String name = method.getName();

         if ( name.equals("executeUpdate") )

         {

             _methods.add(ADD_BATCH);

             _params.add(null);

             _batchConn.nextExecuted(_sql);

             return ONE;

         }

         else if ( name.equals("doExecute") )

         {

             doExecute((Connection) args[0]);

         }

         else if ( name.startsWith("set") )

         {

             // workaround for the bug in Sybase jConnect JDBC driver

             if ( name.equals("setLong") )

             {

                 method = SET_BIG_DECIMAL;

                 args[1] = BigDecimal.valueOf(((Long) args[1]).longValue());

             }

             _methods.add(method);

             _params.add(args);

         }

         return null;

     }

     /**

      * This method performs database modification at the very and of transaction.

      */

     private void doExecute(Connection conn) throws SQLException

     {

         PreparedStatement stmt;

         int size;

         size = _methods.size();

         if ( size == 0 )

         {

             return;

         }

         stmt = conn.prepareStatement(_sql);

         try

         {

             m_platform.afterStatementCreate(stmt);

         }

         catch ( PlatformException e )

         {

             if ( e.getCause() instanceof SQLException )

             {

                 throw (SQLException)e.getCause();

             }

             else

             {

                 throw new SQLException(e.getMessage());

             }

         }

         try

         {

             m_platform.beforeBatch(stmt);

         }

         catch ( PlatformException e )

         {

             if ( e.getCause() instanceof SQLException )

             {

                 throw (SQLException)e.getCause();

             }

             else

             {

                 throw new SQLException(e.getMessage());

             }

         }

         try

         {

             for ( int i = 0; i < size; i++ )

             {

                 Method method = (Method) _methods.get(i);

                 try

                 {

                     if ( method.equals(ADD_BATCH) )

                     {

                         /**

                          * we invoke on the platform and pass the stmt as an arg.

                          */

                         m_platform.addBatch(stmt);

                     }

                     else

                     {

                         method.invoke(stmt, (Object[]) _params.get(i));

                     }

                 }

                 catch (IllegalArgumentException ex)

                 {

                                         StringBuffer buffer = generateExceptionMessage(i, stmt, ex);

                                         throw new SQLException(buffer.toString());

                 }

                 catch ( IllegalAccessException ex )

                 {

                                         StringBuffer buffer = generateExceptionMessage(i, stmt, ex);

                     throw new SQLException(buffer.toString());

                 }

                 catch ( InvocationTargetException ex )

                 {

                     Throwable th = ex.getTargetException();

                     if ( th == null )

                     {

                         th = ex;

                     }

                     if ( th instanceof SQLException )

                     {

                         throw ((SQLException) th);

                     }

                     else

                     {

                         throw new SQLException(th.toString());

                     }

                 }

                                 catch (PlatformException e)

                                 {

                                         throw new SQLException(e.toString());

                                 }

             }

             try

             {

                 /**

                  * this will call the platform specific call

                  */

                 m_platform.executeBatch(stmt);

             }

             catch ( PlatformException e )

             {

                 if ( e.getCause() instanceof SQLException )

                 {

                     throw (SQLException)e.getCause();

                 }

                 else

                 {

                     throw new SQLException(e.getMessage());

                 }

             }

         }

         finally

         {

             stmt.close();

             _methods.clear();

             _params.clear();

         }

     }

     private StringBuffer generateExceptionMessage(int i, PreparedStatement stmt, Exception ex)

         {

                 StringBuffer buffer = new StringBuffer();

                 buffer.append("Method of type: ");

                 buffer.append(_methods.get(i));

                 buffer.append(" invoking on instance: ");

                 if (( _methods.get(i)).equals(ADD_BATCH))

                         buffer.append(m_platform);

                 else

                         buffer.append(stmt);

                 buffer.append(" with parameters: ");

                 if ((_methods.get(i)).equals(ADD_BATCH))

                         buffer.append(stmt);

                 else

                         buffer.append(_params.get(i));

                 buffer.append(" with root: ");

                 buffer.append(ex.toString());

                 return buffer;

         }

 }