/*

    * $Id: BaseGDSImpl.java 58723 2013-10-26 14:51:28Z mrotteveel $

    * 

    * Firebird Open Source J2ee connector - jdbc driver

    *

    * Distributable under LGPL license.

    * You may obtain a copy of the License at http://www.gnu.org/copyleft/lgpl.html

    *

    * This program is distributed in the hope that it will be useful,

   * but WITHOUT ANY WARRANTY; without even the implied warranty of

   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   * LGPL License for more details.

   *

   * This file was created by members of the firebird development team.

   * All individual contributions remain the Copyright (C) of those

   * individuals.  Contributors to this file are either listed here or

   * can be obtained from a CVS history command.

   *

   * All rights reserved.

   */

  package org.firebirdsql.gds.impl.jni;

  import java.io.UnsupportedEncodingException;

  import org.firebirdsql.encodings.EncodingFactory;

  import org.firebirdsql.gds.*;

  import org.firebirdsql.gds.impl.AbstractGDS;

  import org.firebirdsql.gds.impl.AbstractIscTrHandle;

  import org.firebirdsql.gds.impl.DatabaseParameterBufferExtension;

  import org.firebirdsql.gds.impl.GDSType;

  import org.firebirdsql.logging.Logger;

  import org.firebirdsql.logging.LoggerFactory;

  public abstract class BaseGDSImpl extends AbstractGDS {

      private static Logger log = LoggerFactory.getLogger(BaseGDSImpl.class,

              false);

      private static final String WARNING_CONNECT_TIMEOUT_NATIVE = 

              "WARNING: The native driver does not apply connectTimeout for establishing the socket connection (only for protocol negotiation with the Firebird server), " + 

              "it will not detect unreachable hosts within the specified timeout";

      protected static final byte[] DESCRIBE_DATABASE_INFO_BLOCK = new byte[] {

          ISCConstants.isc_info_db_sql_dialect,

          ISCConstants.isc_info_firebird_version,

          ISCConstants.isc_info_ods_version,

          ISCConstants.isc_info_ods_minor_version,

          ISCConstants.isc_info_implementation,

          ISCConstants.isc_info_db_class, 

          ISCConstants.isc_info_base_level,

          ISCConstants.isc_info_end };

      private static byte[] stmtInfo = new byte[] {

                  ISCConstants.isc_info_sql_records,

                  ISCConstants.isc_info_sql_stmt_type, ISCConstants.isc_info_end};

      private static int INFO_SIZE = 128;

      public int isc_api_handle;

      public BaseGDSImpl() {

          super();

      }

      public BaseGDSImpl(GDSType gdsType) {

          super(gdsType);

      }

      protected abstract String getServerUrl(String file_name)

              throws GDSException;

      public BlobParameterBuffer createBlobParameterBuffer() {

          return new BlobParameterBufferImp();

      }

      public DatabaseParameterBuffer createDatabaseParameterBuffer() {

          return new DatabaseParameterBufferImp();

      }

      public IscBlobHandle createIscBlobHandle() {

          return new isc_blob_handle_impl();

      }

      // Handle declaration methods

      public IscDbHandle createIscDbHandle() {

          return new isc_db_handle_impl();

      }

      public IscStmtHandle createIscStmtHandle() {

          return new isc_stmt_handle_impl();

      }

      public IscSvcHandle createIscSvcHandle() {

          return new isc_svc_handle_impl();

      }

      public IscTrHandle createIscTrHandle() {

          return new isc_tr_handle_impl();

     }

     // GDS Implementation

     // ----------------------------------------------------------------------------------------------

     public ServiceParameterBuffer createServiceParameterBuffer() {

         return new ServiceParameterBufferImp();

     }

     public ServiceRequestBuffer createServiceRequestBuffer(int taskIdentifier) {

         return new ServiceRequestBufferImp(taskIdentifier);

     }

     // isc_attach_database

     // ---------------------------------------------------------------------------------------------

     public void iscAttachDatabase(String file_name, IscDbHandle db_handle,

             DatabaseParameterBuffer databaseParameterBuffer)

             throws GDSException {

         validateHandle(db_handle);

         final byte[] dpbBytes;

         final String filenameCharset;

         if (databaseParameterBuffer != null) {

             DatabaseParameterBuffer cleanDPB = ((DatabaseParameterBufferExtension)databaseParameterBuffer).removeExtensionParams();

             if (cleanDPB.hasArgument(DatabaseParameterBuffer.CONNECT_TIMEOUT)) {

                 // For the native driver isc_dpb_connect_timeout is not a socket connect timeout

                 // It only applies to the steps for op_accept (negotiating protocol, etc)

                 if (log != null) {

                     log.warn(WARNING_CONNECT_TIMEOUT_NATIVE);

                 }

                 db_handle.addWarning(new GDSWarning(WARNING_CONNECT_TIMEOUT_NATIVE));

             }

             if (!cleanDPB.hasArgument(DatabaseParameterBuffer.SQL_DIALECT)) {

                 cleanDPB.addArgument(DatabaseParameterBuffer.SQL_DIALECT, ISCConstants.SQL_DIALECT_CURRENT);

             }

             dpbBytes = ((DatabaseParameterBufferImp) cleanDPB).getBytesForNativeCode();

             filenameCharset = databaseParameterBuffer.getArgumentAsString(DatabaseParameterBufferExtension.FILENAME_CHARSET);

         } else {

             dpbBytes = null;

             filenameCharset = null;

         }

         String serverUrl = getServerUrl(file_name);

         byte[] urlData;

         try {

             if (filenameCharset != null)

                 urlData = serverUrl.getBytes(filenameCharset);

             else

                 urlData = serverUrl.getBytes();

             byte[] nullTerminated = new byte[urlData.length + 1];

             System.arraycopy(urlData, 0, nullTerminated, 0, urlData.length);

             urlData = nullTerminated;

         } catch(UnsupportedEncodingException ex) {

             throw new GDSException(ISCConstants.isc_bad_dpb_content);

         }

         synchronized (db_handle) {

             native_isc_attach_database(urlData, db_handle, dpbBytes);

         }

         parseAttachDatabaseInfo(iscDatabaseInfo(db_handle,

                 DESCRIBE_DATABASE_INFO_BLOCK, 1024), db_handle);

     }

     public byte[] iscBlobInfo(IscBlobHandle handle, byte[] items,

             int buffer_length) throws GDSException {

         isc_blob_handle_impl blob = validateHandle(handle);

         final isc_db_handle_impl db = validateHandle(blob.getDb());

         synchronized (db) {

             return native_isc_blob_info(blob, items, buffer_length);

         }

     }

     // isc_close_blob

     // ---------------------------------------------------------------------------------------------

     public void iscCloseBlob(IscBlobHandle blob_handle) throws GDSException {

         isc_blob_handle_impl blob = validateHandle(blob_handle);

         isc_db_handle_impl db = validateHandle(blob.getDb());

         isc_tr_handle_impl tr = validateHandle(blob.getTr());

         synchronized (db) {

             native_isc_close_blob(blob_handle);

         }

         tr.removeBlob(blob);

     }

     // isc_commit_retaining

     // ---------------------------------------------------------------------------------------------

     public void iscCommitRetaining(IscTrHandle tr_handle) throws GDSException {

         isc_tr_handle_impl tr = validateHandle(tr_handle);

         isc_db_handle_impl db = validateHandle(tr.getDbHandle());

         synchronized (db) {

             if (tr.getState() != AbstractIscTrHandle.TRANSACTIONSTARTED

                     && tr.getState() != AbstractIscTrHandle.TRANSACTIONPREPARED) { throw new GDSException(

                     ISCConstants.isc_tra_state); }

             tr.setState(AbstractIscTrHandle.TRANSACTIONCOMMITTING);

             native_isc_commit_retaining(tr_handle);

             tr.setState(AbstractIscTrHandle.TRANSACTIONSTARTED);

         }

     }

     // isc_commit_transaction

     // ---------------------------------------------------------------------------------------------

     public void iscCommitTransaction(IscTrHandle tr_handle) throws GDSException {

         isc_tr_handle_impl tr = validateHandle(tr_handle);

         isc_db_handle_impl db = validateHandle(tr.getDbHandle());

         synchronized (db) {

             if (tr.getState() != AbstractIscTrHandle.TRANSACTIONSTARTED

                     && tr.getState() != AbstractIscTrHandle.TRANSACTIONPREPARED) { throw new GDSException(

                     ISCConstants.isc_tra_state); }

             tr.setState(AbstractIscTrHandle.TRANSACTIONCOMMITTING);

             native_isc_commit_transaction(tr_handle);

             tr.setState(AbstractIscTrHandle.NOTRANSACTION);

             tr.unsetDbHandle();

         }

     }

     // isc_create_blob2

     // ---------------------------------------------------------------------------------------------

     public void iscCreateBlob2(IscDbHandle db_handle, IscTrHandle tr_handle,

             IscBlobHandle blob_handle, BlobParameterBuffer blobParameterBuffer)

             throws GDSException {

         isc_db_handle_impl db = validateHandle(db_handle);

         isc_tr_handle_impl tr = validateHandle(tr_handle);

         isc_blob_handle_impl blob = validateHandle(blob_handle);

         final byte[] bpb = blobParameterBuffer == null ? null

                 : ((BlobParameterBufferImp) blobParameterBuffer)

                         .getBytesForNativeCode();

         synchronized (db) {

             native_isc_create_blob2(db_handle, tr_handle, blob_handle, bpb);

             blob.setDb(db);

             blob.setTr(tr);

             tr.addBlob(blob);

         }

     }

     // isc_create_database

     // ---------------------------------------------------------------------------------------------

     public void iscCreateDatabase(String file_name, IscDbHandle db_handle,

             DatabaseParameterBuffer dpb)

             throws GDSException {

         validateHandle(db_handle);

         final byte[] dpbBytes;

         final String filenameCharset;

         if (dpb != null) {

             DatabaseParameterBuffer cleanDPB = ((DatabaseParameterBufferExtension)dpb).removeExtensionParams();

             if (cleanDPB.hasArgument(DatabaseParameterBuffer.CONNECT_TIMEOUT)) {

                 // For the native driver isc_dpb_connect_timeout is not a socket connect timeout

                 // It only applies to the steps for op_accept (negotiating protocol, etc)

                 if (log != null) {

                     log.warn(WARNING_CONNECT_TIMEOUT_NATIVE);

                 }

                 db_handle.addWarning(new GDSWarning(WARNING_CONNECT_TIMEOUT_NATIVE));

             }

             if (!cleanDPB.hasArgument(DatabaseParameterBuffer.SQL_DIALECT)) {

                 cleanDPB.addArgument(DatabaseParameterBuffer.SQL_DIALECT, ISCConstants.SQL_DIALECT_CURRENT);

             }

             dpbBytes = ((DatabaseParameterBufferImp) cleanDPB).getBytesForNativeCode();

             filenameCharset = dpb.getArgumentAsString(DatabaseParameterBufferExtension.FILENAME_CHARSET);

         } else {

             dpbBytes = null;

             filenameCharset = null;

         }

         synchronized (db_handle) {

             String serverUrl  = getServerUrl(file_name);

             byte[] urlData;

             try {

                 if (filenameCharset != null)

                     urlData = serverUrl.getBytes(filenameCharset);

                 else

                     urlData = serverUrl.getBytes();

                 byte[] nullTerminated = new byte[urlData.length + 1];

                 System.arraycopy(urlData, 0, nullTerminated, 0, urlData.length);

                 urlData = nullTerminated;

             } catch(UnsupportedEncodingException ex) {

                 throw new GDSException(ISCConstants.isc_bad_dpb_content);

             }

             native_isc_create_database(urlData, db_handle,

                     dpbBytes);

         }

     }

     // isc_attach_database

     // ---------------------------------------------------------------------------------------------

     public byte[] iscDatabaseInfo(IscDbHandle db_handle, byte[] items,

             int buffer_length) throws GDSException {

         validateHandle(db_handle);

         synchronized (db_handle) {

             final byte[] returnValue = new byte[buffer_length];

             native_isc_database_info(db_handle, items.length, items,

                     buffer_length, returnValue);

             return returnValue;

         }

     }

     // isc_detach_database

     // ---------------------------------------------------------------------------------------------

     public void iscDetachDatabase(IscDbHandle db_handle) throws GDSException {

         isc_db_handle_impl db = validateHandle(db_handle);

         synchronized (db) {

 //            if (db.hasTransactions()) { throw new GDSException(

 //                    ISCConstants.isc_open_trans, db.getOpenTransactionCount()); }

             native_isc_detach_database(db_handle);

             db.invalidate();

         }

     }

     // isc_drop_database

     // ---------------------------------------------------------------------------------------------

     public void iscDropDatabase(IscDbHandle db_handle) throws GDSException {

         validateHandle(db_handle);

         synchronized (db_handle) {

             native_isc_drop_database(db_handle);

         }

     }

     // isc_dsql_allocate_statement

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlAllocateStatement(IscDbHandle db_handle,

             IscStmtHandle stmt_handle) throws GDSException {

         isc_db_handle_impl db = validateHandle(db_handle);

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         synchronized (db) {

             native_isc_dsql_allocate_statement(db_handle, stmt_handle);

             stmt.setRsr_rdb((isc_db_handle_impl) db_handle);

             stmt.setAllRowsFetched(false);

         }

     }

     // isc_dsql_describe

     // ---------------------------------------------------------------------------------------------

     public XSQLDA iscDsqlDescribe(IscStmtHandle stmt_handle, int da_version)

             throws GDSException {

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         final isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             // TODO setInSqlda here ??

             stmt.setInSqlda(native_isc_dsql_describe(stmt_handle, da_version));

             return stmt_handle.getInSqlda();

         }

     }

     // isc_dsql_describe_bind

     // ---------------------------------------------------------------------------------------------

     public XSQLDA iscDsqlDescribeBind(IscStmtHandle stmt_handle, int da_version)

             throws GDSException {

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         final isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             stmt.setInSqlda(native_isc_dsql_describe_bind(stmt_handle, da_version));

             return stmt_handle.getInSqlda();

         }

     }

     public void iscDsqlExecImmed2(IscDbHandle db_handle, IscTrHandle tr_handle,

             byte[] statement, int dialect, XSQLDA in_xsqlda, XSQLDA out_xsqlda)

             throws GDSException {

         validateHandle(db_handle);

         synchronized (db_handle) {

             native_isc_dsql_exec_immed2(db_handle, tr_handle,

                     getZeroTerminatedArray(statement), dialect, in_xsqlda,

                     out_xsqlda);

         }

     }

     public void iscDsqlExecImmed2(IscDbHandle db_handle, IscTrHandle tr_handle,

             String statement, int dialect, XSQLDA in_xsqlda, XSQLDA out_xsqlda)

             throws GDSException {

         iscDsqlExecImmed2(db_handle, tr_handle, statement, "NONE", dialect,

                 in_xsqlda, out_xsqlda);

     }

     public void iscDsqlExecImmed2(IscDbHandle db_handle, IscTrHandle tr_handle,

             String statement, String encoding, int dialect, XSQLDA in_xsqlda,

             XSQLDA out_xsqlda) throws GDSException {

         validateHandle(db_handle);

         try {

             synchronized (db_handle) {

                 native_isc_dsql_exec_immed2(db_handle, tr_handle,

                         getByteArrayForString(statement, encoding), dialect,

                         in_xsqlda, out_xsqlda);

             }

         } catch (UnsupportedEncodingException e) {

             throw new GDSException("Unsupported encoding. " + e.getMessage());

         }

     }

     // isc_dsql_execute

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlExecute(IscTrHandle tr_handle,

             IscStmtHandle stmt_handle, int da_version, XSQLDA xsqlda)

             throws GDSException {

         iscDsqlExecute2(tr_handle, stmt_handle, da_version, xsqlda, null);

     }

     // public synchronized abstract void native_isc_dsql_execute(isc_tr_handle

     // tr_handle, isc_stmt_handle stmt_handle, int da_version, XSQLDA xsqlda)

     // throws GDSException;

     // isc_dsql_execute2

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlExecute2(IscTrHandle tr_handle,

             IscStmtHandle stmt_handle, int da_version, XSQLDA in_xsqlda,

             XSQLDA out_xsqlda) throws GDSException {

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         final isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             // TODO Fetch Statements

             native_isc_dsql_execute2(tr_handle, stmt_handle, da_version,

                     in_xsqlda, out_xsqlda);

             if (stmt.getOutSqlda() != null) stmt.notifyOpenResultSet();

             if (out_xsqlda != null) {

                 // this would be an Execute procedure

                 stmt.ensureCapacity(1);

                 readSQLData(out_xsqlda, stmt);

                 stmt.setAllRowsFetched(true);

                 stmt.setSingletonResult(true);

             } else {

                 stmt.setAllRowsFetched(false);

                 stmt.setSingletonResult(false);

             }

             stmt.registerTransaction((AbstractIscTrHandle)tr_handle);

         }

     }

     public void iscDsqlExecuteImmediate(IscDbHandle db_handle,

             IscTrHandle tr_handle, byte[] statement, int dialect, XSQLDA xsqlda)

             throws GDSException {

         iscDsqlExecImmed2(db_handle, tr_handle, statement, dialect, xsqlda,

                 null);

     }

     // isc_dsql_execute_immediateX

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlExecuteImmediate(IscDbHandle db_handle,

             IscTrHandle tr_handle, String statement, int dialect, XSQLDA xsqlda)

             throws GDSException {

         iscDsqlExecImmed2(db_handle, tr_handle, statement, dialect, xsqlda,

                 null);

     }

     public void iscDsqlExecuteImmediate(IscDbHandle db_handle,

             IscTrHandle tr_handle, String statement, String encoding,

             int dialect, XSQLDA xsqlda) throws GDSException {

         iscDsqlExecImmed2(db_handle, tr_handle, statement, encoding, dialect,

                 xsqlda, null);

     }

     // isc_dsql_fetch

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlFetch(IscStmtHandle stmt_handle, int da_version,

             XSQLDA xsqlda, int fetchSize) throws GDSException {

         fetchSize = 1;

         if (xsqlda == null) { 

             throw new GDSException(ISCConstants.isc_dsql_sqlda_err);

         }

         // TODO: Above declares fetchSize = 1, so parameter is ignored and this check is not necessary

         if (fetchSize <= 0) { 

             throw new GDSException(ISCConstants.isc_dsql_sqlda_err);

         }

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             // Apply fetchSize

             // Fetch next batch of rows

             stmt.ensureCapacity(fetchSize);

             for (int i = 0; i < fetchSize; i++) {

                 try {

                     boolean isRowPresent = native_isc_dsql_fetch(stmt_handle,

                             da_version, xsqlda, fetchSize);

                     if (isRowPresent) {

                         readSQLData(xsqlda, stmt);

                     } else {

                         stmt.setAllRowsFetched(true);

                         return;

                     }

                 } finally {

                     stmt.notifyOpenResultSet();

                 }

             }

         }

     }

     // isc_dsql_free_statement

     // ---------------------------------------------------------------------------------------------

     public void iscDsqlFreeStatement(IscStmtHandle stmt_handle, int option)

             throws GDSException {

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             // Does not seem to be possible or necessary to close

             // an execute procedure statement.

             if (stmt.isSingletonResult() && option == ISCConstants.DSQL_close) { return; }

             if (option == ISCConstants.DSQL_drop) {

                 stmt.setInSqlda(null);

                 stmt.setOutSqlda(null);

                 stmt.setRsr_rdb(null);

             }

             native_isc_dsql_free_statement(stmt_handle, option);

             // clear association with transaction

             try {

                 AbstractIscTrHandle tr = stmt.getTransaction();

                 if (tr != null)

                     tr.unregisterStatementFromTransaction(stmt);

             } finally {

                 stmt.unregisterTransaction();

             }

         }

     }

     // isc_dsql_free_statement

     // ---------------------------------------------------------------------------------------------

     public XSQLDA iscDsqlPrepare(IscTrHandle tr_handle,

             IscStmtHandle stmt_handle, byte[] statement, int dialect)

             throws GDSException {

         validateHandle(tr_handle);

         isc_stmt_handle_impl stmt = validateHandle(stmt_handle);

         isc_db_handle_impl db = validateHandle(stmt.getRsr_rdb());

         synchronized (db) {

             stmt.setInSqlda(null);

             stmt.setOutSqlda(null);

             stmt.setOutSqlda(native_isc_dsql_prepare(tr_handle, stmt_handle,

                     getZeroTerminatedArray(statement), dialect));

             getStatementType(stmt);

             return stmt_handle.getOutSqlda();

         }

     }

    

     private void getStatementType(isc_stmt_handle_impl stmt) throws GDSException {

         final byte [] REQUEST = new byte [] {

             ISCConstants.isc_info_sql_stmt_type,

             ISCConstants.isc_info_end };

         int bufferSize = 1024;

         byte[] buffer;

         buffer = iscDsqlSqlInfo(stmt, REQUEST, bufferSize); 

         /*

         if (buffer[0] == ISCConstants.isc_info_end){

             throw new GDSException("Statement info could not be retrieved");

         }

         */

         int dataLength = -1; 

         for (int i = 0; i < buffer.length; i++){

             switch(buffer[i]){

                 case ISCConstants.isc_info_sql_stmt_type:

                     dataLength = iscVaxInteger(buffer, ++i, 2);

                     i += 2;

                     stmt.setStatementType(iscVaxInteger(buffer, i, dataLength));

                     i += dataLength;

                     break;

                 case ISCConstants.isc_info_end:

                 case 0:

                     break;

                 default:

                     throw new GDSException("Unknown data block [" 

                             + buffer[i] + "]");

             }

         }

     }

     // isc_dsql_free_statement

     // ---------------------------------------------------------------------------------------------

     public XSQLDA iscDsqlPrepare(IscTrHandle tr_handle,

             IscStmtHandle stmt_handle, String statement, int dialect)

             throws GDSException {

         return iscDsqlPrepare(tr_handle, stmt_handle, statement, "NONE",

                 dialect);

     }

     public XSQLDA iscDsqlPrepare(IscTrHandle tr_handle,

             IscStmtHandle stmt_handle, String statement, String encoding,

             int dialect) throws GDSException {

         try {

             return iscDsqlPrepare(tr_handle, stmt_handle,

                     getByteArrayForString(statement, encoding), dialect);

         } catch (UnsupportedEncodingException e) {