// @@@ START COPYRIGHT @@@
//
// 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.
//
// @@@ END COPYRIGHT @@@

#include "LmRoutineJavaObj.h"
#include "org_trafodion_sql_udr_UDR.h"

LmResult LmRoutineJavaObj::setRuntimeInfo(
     const char   *qid,
     int           totalNumInstances,
     int           myInstanceNum,
     ComDiagsArea *da)
{
  LmResult result = LM_OK;
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;
  jstring jqid = jni->NewString((const jchar *) qid, strlen(qid));

  // call the Java method that will ultimately call the user code
  jni->CallVoidMethod(
       udrInvokeObjectG_,
       (jmethodID) getLM()->setRuntimeInfoId_,
       jqid,
       (jint) totalNumInstances,
       (jint) myInstanceNum);

  if (jni->ExceptionOccurred())
    {
      getLM()->exceptionReporter_->checkJVMException(da, 0);
      if (da)
        {
          // an error without a diagnostic message from Java
          *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
              << DgString0(getNameForDiags())
              << DgString1("runtime")
              << DgString2("LmRoutineJavaObj::setRuntimeInfo()")
              << DgString3("Exception in JNI call");
        }
      result = LM_ERR;
    }

  // delete input parameter objects
  jni->DeleteLocalRef(jqid);

  return result;
}

LmResult LmRoutineJavaObj::invokeRoutineMethod(
     /* IN */     tmudr::UDRInvocationInfo::CallPhase phase,
     /* IN */     const char   *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN */     const char   *serializedPlanInfo,
     /* IN */     Int32         planInfoLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN */     char         *inputRow,
     /* IN */     Int32         inputRowLen,
     /* OUT */    char         *outputRow,
     /* IN */     Int32         outputRowLen,
     /* IN/OUT */ ComDiagsArea *da)
{
  LmResult result = LM_OK;
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;
  if (inputRowLen >= 0)
    inputRowLen_ = inputRowLen;
  if (outputRowLen >= 0)
    outputRowLen_ = outputRowLen;

  jbyteArray jii = jni->NewByteArray((jint) invocationInfoLen);
  jbyteArray jpi = jni->NewByteArray((jint) planInfoLen);
  jbyteArray jir = jni->NewByteArray((jint) inputRowLen_);

  jni->SetByteArrayRegion(jii,
                          (jsize) 0,
                          (jsize) invocationInfoLen,
                          (const jbyte *) serializedInvocationInfo);
  jni->SetByteArrayRegion(jpi,
                          (jsize) 0,
                          (jsize) planInfoLen,
                          (const jbyte *) serializedPlanInfo);
  jni->SetByteArrayRegion(jir,
                          (jsize) 0,
                          (jsize) inputRowLen_,
                          (const jbyte *) inputRow);

  // call the Java method that will ultimately call the user code
  jobject jniResult = jni->CallObjectMethod(
       udrInvokeObjectG_,
       (jmethodID) getLM()->routineMethodInvokeId_,
       (jint) phase,
       jii,
       jpi,
       (jint) planNum,
       jir);

  if (jniResult == NULL || jni->ExceptionOccurred())
    {
      // this catches any exceptions other than UDRException
      // thrown in the Java code
      getLM()->exceptionReporter_->checkJVMException(da, 0);
      if (da && da->mainSQLCODE() >= 0)
        {
          // an error without a diagnostic message from Java
          char buf[4];
          snprintf(buf, sizeof(buf), "%d", static_cast<int>(phase));
          *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
              << DgString0(getNameForDiags())
              << DgString1(buf)
              << DgString2("LmRoutineJavaObj::invokeRoutineMethod()")
              << DgString3("JNI call returned a NULL object");
        }
      result = LM_ERR;
    }

  // delete input parameter objects
  jni->DeleteLocalRef(jii);
  jni->DeleteLocalRef(jpi);
  jni->DeleteLocalRef(jir);

  // clear return info from any previous calls
  if (returnedIIL_)
    {
      jni->DeleteLocalRef(returnedIIL_);
      returnedIIL_ = NULL;
    }
  if (returnedPIL_)
    {
      jni->DeleteLocalRef(returnedPIL_);
      returnedPIL_ = NULL;
    }

  iiLen_ = piLen_ = 0;

  if (result == LM_OK)
    {
      // retrieve returned information
      jint returnStatus = jni->GetIntField(
           jniResult, 
           (jfieldID) getLM()->returnInfoStatusField_);

      if (returnStatus != 0)
        {
          getLM()->exceptionReporter_->processJavaObjException(
               jniResult,
               returnStatus,
               static_cast<int>(phase),
               "LmRoutineJavaObj::invokeRoutineMethod()",
               getNameForDiags(),
               da);
          result = LM_ERR;
        }
      else
        {
          returnedIIL_ = static_cast<jbyteArray>(
               jni->GetObjectField(
                    jniResult,
                    (jfieldID) getLM()->returnInfoRIIField_));
          returnedPIL_ = static_cast<jbyteArray>(
               jni->GetObjectField(
                    jniResult,
                    (jfieldID) getLM()->returnInfoRPIField_));

          if (returnedIIL_)
            iiLen_ = jni->GetArrayLength(returnedIIL_);

          if (returnedPIL_)
            piLen_ = jni->GetArrayLength(returnedPIL_);
        }

      if (phase == tmudr::UDRInvocationInfo::RUNTIME_WORK_CALL &&
          result == LM_OK)
        {
          SQLUDR_Q_STATE qs = SQLUDR_Q_EOD;
          // emit the EOD (end of data) for the result table
          (*emitRowPtr_)(NULL,0,&qs);
        }
    }
  jni->DeleteLocalRef(jniResult);

  if (invocationInfoLenOut)
    *invocationInfoLenOut = static_cast<Int32>(iiLen_);

  if (planInfoLenOut)
    *planInfoLenOut = static_cast<Int32>(piLen_);

  return result;
}

LmResult LmRoutineJavaObj::getRoutineInvocationInfo(
     /* IN/OUT */ char         *serializedInvocationInfo,
     /* IN */     Int32         invocationInfoMaxLen,
     /* OUT */    Int32        *invocationInfoLenOut,
     /* IN/OUT */ char         *serializedPlanInfo,
     /* IN */     Int32         planInfoMaxLen,
     /* IN */     Int32         planNum,
     /* OUT */    Int32        *planInfoLenOut,
     /* IN/OUT */ ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;
  LmResult result = LM_OK;

  // return the serialized invocation info
  if (returnedIIL_)
    {
      if (invocationInfoMaxLen < iiLen_ && serializedInvocationInfo)
        {
          if (da)
            *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
                << DgString0(getNameForDiags())
                << DgString1("unknown")
                << DgString2("getRoutineInvocationInfo()")
                << DgString3("Buffer too short for invocation info");
          iiLen_ = 0;
          result = LM_ERR;
        }
      else if (serializedInvocationInfo)
        {
          jbyte * returnedIIChar = jni->GetByteArrayElements(returnedIIL_, NULL);
          str_cpy_all(serializedInvocationInfo,
                      reinterpret_cast<const char *>(returnedIIChar),
                      iiLen_);
          jni->ReleaseByteArrayElements(returnedIIL_, returnedIIChar, JNI_ABORT);
        }
      jni->DeleteLocalRef(returnedIIL_);
      returnedIIL_ = NULL;
    }

  if (invocationInfoLenOut)
    *invocationInfoLenOut = iiLen_;
  iiLen_ = 0;

  // return the serialized plan info
  if (returnedPIL_)
    {
      if (planInfoMaxLen < piLen_ && serializedPlanInfo)
        {
          if (da)
            *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
                << DgString0(getNameForDiags())
                << DgString1("unknown")
                << DgString2("getRoutineInvocationInfo()")
                << DgString3("Buffer too short for plan info");
          piLen_ = 0;
          result = LM_ERR;
        }
      else if (serializedPlanInfo)
        {
          jbyte * returnedPIChar = jni->GetByteArrayElements(returnedPIL_, NULL);
          str_cpy_all(serializedPlanInfo,
                      reinterpret_cast<const char *>(returnedPIChar),
                      piLen_);
          jni->ReleaseByteArrayElements(returnedPIL_, returnedPIChar, JNI_ABORT);
        }
      jni->DeleteLocalRef(returnedPIL_);
      returnedPIL_ = NULL;
    }

  if (planInfoLenOut)
    *planInfoLenOut = piLen_;
  piLen_ = 0;

  return result;
}

LmResult LmRoutineJavaObj::setFunctionPtrs(
     SQLUDR_GetNextRow getNextRowPtr,
     SQLUDR_EmitRow emitRowPtr,
     ComDiagsArea *da)
{
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;
  LmResult result = LM_OK;

  // save a local copy to be able to emit the EOD (end of data)
  emitRowPtr_ = emitRowPtr;

  const JNINativeMethod methods[2] = {
    { const_cast<char *>("SpInfoGetNextRowJava"),
      const_cast<char *>("([BILorg/trafodion/sql/udr/UDR$QueueStateInfo;)V"),
      reinterpret_cast<void *>(jniGetNextRowPtr_) },
    { const_cast<char *>("SpInfoEmitRowJava"),
      const_cast<char *>("([BILorg/trafodion/sql/udr/UDR$QueueStateInfo;)V"),
      reinterpret_cast<void *>(jniEmitRowPtr_) }
  };

  // use this method to register the native methods, which are already
  // loaded in the executable, not need to load a separate DLL
  jint returnStatus = jni->RegisterNatives(
       reinterpret_cast<jclass>(getLM()->udrClass_),
       methods,
       static_cast<jint>(sizeof(methods)/sizeof(methods[0])));
       
  if (returnStatus != 0 || jni->ExceptionOccurred())
    {
      getLM()->exceptionReporter_->insertDiags(
           da,
           -LME_INTERNAL_ERROR,
           ": Error in LmRoutineJavaObj::setFunctionPtrs()");

      if (da)
        {
          char buf2[80];
          snprintf(buf2, sizeof(buf2), "Return status %d from JNI call", returnStatus);

          *da << DgSqlCode(-LME_OBJECT_INTERFACE_ERROR)
              << DgString0(getNameForDiags())
              << DgString1("runtime initial")
              << DgString2("LmRoutineJavaObj::setFunctionPtrs()")
              << DgString3(buf2);
        }
      result = LM_ERR;
    }

  return result;
}

void LmRoutineJavaObj::setJNIFunctionPtrs(void *jniGetNextRowPtr,
                                          void *jniEmitRowPtr)
{
  jniGetNextRowPtr_ = jniGetNextRowPtr;
  jniEmitRowPtr_ = jniEmitRowPtr;
}

void LmRoutineJavaObj::setRowLengths(int inputRowLen,
                                     int outputRowLen)
{
  inputRowLen_  = inputRowLen;
  outputRowLen_ = outputRowLen;
}

LmRoutineJavaObj::LmRoutineJavaObj(
     const char   *sqlName,
     const char   *externalName,
     const char   *librarySqlName,
     ComRoutineTransactionAttributes transactionAttrs,
     ComRoutineSQLAccess sqlAccessMode,
     ComRoutineExternalSecurity externalSecurity,
     Int32    routineOwnerId,
     const char   *serializedInvocationInfo,
     int           invocationInfoLen,
     const char   *serializedPlanInfo,
     int           planInfoLen,
     LmLanguageManagerJava *lm,
     jobject       udrObject,
     LmContainer  *container,
     ComDiagsArea *diagsArea) : LmRoutineJava(sqlName,
                                              externalName,
                                              librarySqlName,
                                              0,
                                              NULL,
                                              0,
                                              NULL,
                                              COM_STYLE_JAVA_OBJ,
                                              transactionAttrs,
                                              sqlAccessMode,
                                              externalSecurity,
                                              routineOwnerId,
                                              NULL,
                                              0,
                                              0,
                                              NULL,
                                              NULL,
                                              NULL,
                                              lm,
                                              (LmHandle) NULL,
                                              container,
                                              diagsArea),
                                udrObjectG_(NULL),
                                udrInvokeObjectG_(NULL),
                                returnedIIL_(NULL),
                                returnedPIL_(NULL),
                                iiLen_(0),
                                piLen_(0),
                                inputRowLen_(-1),
                                outputRowLen_(-1),
                                emitRowPtr_(NULL),
                                jniGetNextRowPtr_(NULL),
                                jniEmitRowPtr_(NULL)
{
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;
  jbyteArray jii = jni->NewByteArray((jint) invocationInfoLen);
  jbyteArray jpi = NULL;
  jobject udrInvokeObject = NULL;

  jni->SetByteArrayRegion(jii,
                          (jsize) 0,
                          (jsize) invocationInfoLen,
                          (const jbyte *) serializedInvocationInfo);

  if (planInfoLen > 0)
    {
      jpi = jni->NewByteArray((jint) planInfoLen);

      jni->SetByteArrayRegion(jpi,
                              (jsize) 0,
                              (jsize) planInfoLen,
                              (const jbyte *) serializedPlanInfo);
    }

  if (!jni->ExceptionOccurred())
    // Do a JNI call to allocate an LmUDRObjMethodInvoke object
    udrInvokeObject = jni->CallStaticObjectMethod(
         (jclass)    getLM()->lmObjMethodInvokeClass_,
         (jmethodID) getLM()->makeNewObjId_,
         udrObject,
         jii,
         jpi);

  jni->DeleteLocalRef(jii);
  if (planInfoLen > 0)
    jni->DeleteLocalRef(jpi);

  if (udrInvokeObject != NULL && !jni->ExceptionOccurred())
    {
      // create global references for these objects, they will
      // last as long as the LmRoutineJavaObj
      udrObjectG_ = jni->NewGlobalRef(udrObject);
      jni->DeleteLocalRef(udrObject);
      udrInvokeObjectG_ = jni->NewGlobalRef(udrInvokeObject);
      jni->DeleteLocalRef(udrInvokeObject);
    }

  if (udrObjectG_ == NULL || udrInvokeObjectG_ == NULL || jni->ExceptionOccurred())
    {
      getLM()->exceptionReporter_->insertDiags(
           diagsArea,
           -LME_INTERNAL_ERROR,
           ": Error in LmRoutineJavaObj::LmRoutineJavaObj()");
    }
}

LmRoutineJavaObj::~LmRoutineJavaObj()
{
  JNIEnv *jni = (JNIEnv*)getLM()->jniEnv_;

  if (udrObjectG_ != NULL)
    jni->DeleteGlobalRef(udrObjectG_);
  if (udrInvokeObjectG_ != NULL)
    jni->DeleteGlobalRef(udrInvokeObjectG_);
  if (returnedIIL_)
    jni->DeleteLocalRef(returnedIIL_);
  if (returnedPIL_)
    jni->DeleteLocalRef(returnedPIL_);
}

ComBoolean LmRoutineJavaObj::isValid() const
{
  return udrObjectG_ != NULL && udrInvokeObjectG_ != NULL;
}