/**********************************************************************
// @@@ 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 @@@
**********************************************************************/
/* -*-C++-*-
******************************************************************************
*
* File:         LmJavaSignature.cpp
* Description:  Java Signature
*
* Created:      06/17/2003
* Language:     C++
*
*
******************************************************************************
*/

#include "LmParameter.h"
#include "LmJavaType.h"
#include "LmJavaSignature.h"
#include "LmJavaSignatureHelpers.h"

//
// Constructor
//
// This class uses the heap parameter if provided. Other wise
// uses global heap to allocate memory. This is to facilitate
// DDOL code calls into this class. DDOL code does not use any
// classes from /common directory.
//
LmJavaSignature::LmJavaSignature(const char* encodedSignature, void* heap)
 : heap_(NULL),
   encodedSignature_(NULL),
   unpackedSignatureSize_(-1),
   numParams_(-1)
{
  if (heap != NULL)
    heap_ = (NAMemory *) heap;

  if (encodedSignature == NULL)
  {
    encodedSignature_ = NULL;
  }
  else
  {
    UInt32 siglen = strlen(encodedSignature);

    if (heap_ == NULL)
      encodedSignature_ = new char[siglen + 1];
    else
      encodedSignature_ = new (heap_) char[siglen + 1];

    strcpy(encodedSignature_, encodedSignature);

    // Compute the numParams_ value
    ::getUnpackedSignatureSize(encodedSignature_, &numParams_);
  }
}


// Destructor
LmJavaSignature::~LmJavaSignature()
{
  if (encodedSignature_ != NULL)
  {
    if (heap_)
      NADELETEBASIC(encodedSignature_, heap_);
    else
      delete encodedSignature_;
  }
}

//
// createSig() : Creates a Java signature for the specifed SQL attributes.
// If optionalSig is specified, it contains the string entered in the
// EXTERNAL NAME field of the CREATE PROCEDURE command, and is validated
// in this function. The returned signature is built in the sigBuf parameter.
//
// Returns:  LM_OK   on success
//           LM_ERR  on failure
//
LmResult
LmJavaSignature::createSig(ComFSDataType paramType[],
                           ComUInt32     paramSubType[],
                           ComColumnDirection direction[],
                           ComUInt32     numParam,
                           ComFSDataType resultType,
                           ComUInt32     resultSubType,
                           ComUInt32     numResultSets,
                           const char    *optionalSig,
                           ComBoolean    isUdrForJavaMain,
                           char          *sigBuf,
                           ComUInt32     sigLen,
                           ComDiagsArea  *da)
{
  static const char *resultSet = "[Ljava/sql/ResultSet;";
  static const Int32 resultSetLen = str_len(resultSet);

  ComUInt32 len = 0;
  ComUInt32 idx = 0;
  ComBoolean lookForTrailingParams = FALSE;
  const char *type;
  char *optc = NULL, *optsig = NULL, *optype = NULL;

  if (optionalSig != NULL)
  {
    len = (ComUInt32) str_len(optionalSig);
    optype = optsig = new (heap_) char[len+1];

    str_cpy_all(optsig, optionalSig, (Lng32) len);
    optsig[len] = '\0';

    if (*optype != '(')
    {
      // Error: Missing parentheses.
      *da << DgSqlCode(-LME_SIGNATURE_INVALID1);
      if (optsig) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }
    optype++;
  } //if (optionalSig...)

  //
  // Build the Java signature in the sig buffer.
  // Start of method's parameter list.
  //
  // In this method we check for space in sigBuf everytime
  // we write something into it.
  //
  if (idx + 1 > sigLen)
  {
    *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
    if (optsig) NADELETEBASIC(optsig, heap_);
    return LM_ERR;
  }

  sigBuf[idx++] = '(';

  //
  // Special treatment for UDR-MAIN
  //
  // Check if optional signature is java.lang.String[]
  // Then write "[Ljava/lang/String;" to sigBuf
  //
  if (isUdrForJavaMain)
  {
    if (optionalSig != NULL)
    {
      char * endOfOptSig= strchr(optype, ')');
      if (endOfOptSig == NULL)
      {
        // Error: Missing parantheses
        *da << DgSqlCode(-LME_SIGNATURE_INVALID1);
        if (optsig) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
      }

      *endOfOptSig = '\0';
      optype = strip_spaces(optype);

      len = (ComUInt32) str_len(optype);
      if (len >= 2)
      {
        if (optype[len-2] != '[' || optype[len-1] != ']')
        {
          *da << DgSqlCode(-LME_SIGNATURE_INVALID8);
          if (optsig) NADELETEBASIC(optsig, heap_);
          return LM_ERR;
        }
        else
        {
          optype[len-2] = '\0';
          optype = strip_spaces(optype);
        }
      }

      if (str_cmp_ne(optype, "java.lang.String") != 0)
      {
        *da << DgSqlCode(-LME_SIGNATURE_INVALID8);
        if (optsig) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
      }

      // Move optype to point to next of ')' in optional signature
      optype = endOfOptSig + 1;
    }

    if (idx + 19 > sigLen)
    {
      *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
      if (optsig) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }

    str_cpy_all(&sigBuf[idx], "[Ljava/lang/String;", 19);
    idx += 19;
  }
  else if (((Int32)numParam == 0) && optype && (numResultSets > 0))
  {
    lookForTrailingParams = true;
  }
  else if (((Int32)numParam == 0) && optype && (numResultSets == 0))
  {
    //
    // Case: numParam is 0. '()', '(void)' in optsig are valid
    //
    optc = strchr(optype, ')');
    if (optc == NULL)
    {
      // Error: Missing parantheses
      *da << DgSqlCode(-LME_SIGNATURE_INVALID1);
      if (optsig) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }
    *optc = '\0';
    optype = strip_spaces(optype);

    if ((!* optype) || (str_cmp_ne(optype, "void") == 0))
      optype = optc + 1;
    else
    {
      // Case: Params specified in opt sig are more than expected
      *da << DgSqlCode(-LME_SIGNATURE_INVALID2)
          << DgInt0((Lng32) numParam);
      if (optsig) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }
  } // if ((int)numParam...)

   //
  // Travel through the parameters. The following steps are performed
  // in the 'for' loop.
  // 1. For UDr-MAIN, check all types are CHAR/VARCHAR and mode is IN
  // 2. Get the type from the optional signature if there is one.
  // 3. Enfore '[]' for OUT/INOUT types in optional signature.
  // 4. Call getJavaTypeName() to get java name of the type.
  // 5. Write the type name into sigBuf
  //
  for (Int32 i = 1; i <= (Int32)numParam; i++)
  {
    //
    // Special treatment for UDR-MAIN
    //
    // All the parameters should be IN.
    //
    // We don't need to check here if the correct type is
    // specified in the optional signature. This is already
    // done above.
    //
    // Just check if the parameter is String type. We allow
    // only String types to main method.
    //
    // We don't need to write the type name to sigBuf. We can
    // directly write ')' after this 'for' loop
    //
    if (isUdrForJavaMain)
    {
      if (direction[i-1] != COM_INPUT_COLUMN)
      {
        *da << DgSqlCode(-LME_SIGNATURE_INVALID9);
        if (optsig) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
      }

      LmParameter lmParam((paramType[i-1]), (short) paramSubType[i-1]);
      LmJavaType jType(&lmParam);
      type = jType.getJavaTypeName(len);
      if (str_cmp_ne(type, "Ljava/lang/String;") != 0)
      {
        *da << DgSqlCode(-LME_SIGNATURE_INVALID10);
        if (optsig) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
      }

      continue;
    }
    if (optionalSig)
    {
      optc = strchr(optype, ',');
      if (optc != NULL)
      {
        *optc = '\0';
        optype = strip_spaces(optype);
        if ((i == (Int32)numParam) && (numResultSets == 0))
        {
          // Case: Params specified in opt sig are more than expected
          *da << DgSqlCode(-LME_SIGNATURE_INVALID2)
              << DgInt0((Lng32) numParam);
          if (optsig) NADELETEBASIC(optsig, heap_);
          return LM_ERR;
        }
        lookForTrailingParams = true;
      }
      else // first if (optc != NULL)
      {
        optc = strchr(optype, ')');
        if (optc != NULL)
        {
          *optc = '\0';
          optype = strip_spaces(optype);
          if ((i < (Int32)numParam) || ((numParam ==1)&& !(*optype)))
          {
            // Case: Params specified in opt sig are less than expected
            // Case: sig is () but numParam is 1
            *da << DgSqlCode(-LME_SIGNATURE_INVALID2)
                << DgInt0((Lng32) numParam);
            if (optsig) NADELETEBASIC(optsig, heap_);
            return LM_ERR;
          }
          lookForTrailingParams = FALSE;
        }
        else // second if (optc != NULL)
        {
          // Error: Missing parentheses.
          *da << DgSqlCode(-LME_SIGNATURE_INVALID1);
          if (optsig) NADELETEBASIC(optsig, heap_);
          return LM_ERR;
        }
      } // first if (optc != NULL)
    } // if (optionalSig)

    // For OUT/INOUT params, [] in optional signature is mandatory.
    if (optype)
    {
      ComUInt32 optlen = (ComUInt32) str_len(optype);
      if (direction[i-1] == COM_INOUT_COLUMN ||
          direction[i-1] == COM_OUTPUT_COLUMN)
      {
        if (optlen > 2 && optype[optlen-2] == '[' && optype[optlen-1] == ']')
        {
          optype[optlen-2] = '\0';
          optype = strip_spaces(optype); // Allow spaces btw TYPE and []
        }
        else
        {
          // Error: Missing [] for OUT/INOUT param
          *da << DgSqlCode(-LME_SIGNATURE_INVALID3)
              << DgInt0(i);
          if (optsig) NADELETEBASIC(optsig, heap_);
          return LM_ERR;
        }
      }
    }

    //
    // Get the Java type for the param's SQL <type,subtype>
    // First check if the type is base type. Next check if it
    // is Object type. For object types optional type should
    // be there.
    //
    LmParameter lmParam(paramType[i-1], (short) paramSubType[i-1]);
    LmJavaType baseType(&lmParam);
    LmJavaType::TypeElement *e = baseType.getTypeElement();

    if (e != NULL)
    {
      type = e->javaTypeName;
      len = e->javaTypeNameLen;
    }

    if (e == NULL || (optype && (str_cmp_ne(e->javaText, optype) != 0)))
    {
      // User wants the object type. So look for Object type
      // in type table only if optional signature is specified
      if (optype)
      {
        lmParam.setObjMapping();
        LmJavaType objType(&lmParam);
        if ((e = objType.getTypeElement()) != NULL)
        {
          type = e->javaTypeName;
          len = e->javaTypeNameLen;
        }
      }
    }

    if (e == NULL || (optype && (str_cmp_ne(e->javaText, optype) != 0)))
    {
      // Error: Unknown parameter type used.
      *da << DgSqlCode(-LME_SIGNATURE_INVALID4)
          << DgInt0(i);
      if (optsig) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }

    // Out mode params are specified using an array for the given type.
    if (direction[i-1] == COM_INOUT_COLUMN ||
        direction[i-1] == COM_OUTPUT_COLUMN)
    {
      if ((idx + 1) > sigLen)
      {
        *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
        if (optsig != NULL) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
      }

      sigBuf[idx++] = '[';
    }

    if ((idx + len) > sigLen)
    {
      *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
      if (optsig != NULL) NADELETEBASIC(optsig, heap_);
      return LM_ERR;
    }

    // Add the Java type to the sig buffer.
    str_cpy_all(&sigBuf[idx], type, (Lng32) len);
    idx += len;

    // move optype to point to next type in optional sig
    if (optype) optype = optc + 1;

  } // for()

  if(lookForTrailingParams)
  {
    Int32 numTrailingParams = 0;

    while(true)
    {
      numTrailingParams++;
      optc = strchr(optype, ',');
      if (optc != NULL)
      {
        *optc = '\0';
        optype = strip_spaces(optype); // Allow spaces btw TYPE and comma
        ComUInt32 optlen = (ComUInt32) str_len(optype);
        if (optlen > 2 && optype[optlen-2] == '[' && optype[optlen-1] == ']')
        {
          optype[optlen-2] = '\0';
          optype = strip_spaces(optype); // Allow spaces btw TYPE and []

          if (str_cmp_ne(optype, "java.sql.ResultSet") == 0)
          {
            // Ensure buffer accomodates ResultSet
            if (idx + resultSetLen > sigLen)
            {
              *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
              if (optsig) NADELETEBASIC(optsig, heap_);
                return LM_ERR;
            }
            str_cpy_all(&sigBuf[idx], resultSet, resultSetLen);
            idx += resultSetLen;	    
            // move optype to point to next type in optional sig
            if (optype) optype = optc + 1;
          }
          else
          {
            //Error: Not a java.sql.ResultSet[]
            *da << DgSqlCode(-LME_SIGNATURE_INVALID11)
                << DgInt0((Lng32)numParam + numTrailingParams);
            if (optsig) NADELETEBASIC(optsig, heap_);
              return LM_ERR;
          }
        }
        else
        {
          // Error: Not a java.sql.ResultSet[]
          *da << DgSqlCode(-LME_SIGNATURE_INVALID11)
              << DgInt0((Lng32)numParam + numTrailingParams);
          if (optsig) NADELETEBASIC(optsig, heap_);
          return LM_ERR;
        } 
      }
      else  
      {
        optc = strchr(optype, ')');
        if (optc != NULL)
        {
          *optc = '\0';
          optype = strip_spaces(optype); // Allow spaces btw TYPE and comma
          ComUInt32 optlen = (ComUInt32) str_len(optype);
          if (optlen > 2 && optype[optlen-2] == '[' && optype[optlen-1] == ']')
          {
            optype[optlen-2] = '\0';
            optype = strip_spaces(optype); // Allow spaces btw TYPE and []

            if (str_cmp_ne(optype, "java.sql.ResultSet") == 0)
            {
              // Ensure buffer accomodates ResultSet
              if (idx + resultSetLen > sigLen)
              {
                *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
                if (optsig) NADELETEBASIC(optsig, heap_);
                  return LM_ERR;
              }
              str_cpy_all(&sigBuf[idx], resultSet, resultSetLen);
              idx += resultSetLen;	    
              // move optype to point to next type in optional sig
              if (optype) optype = optc + 1;
                break;
            }
            else
            {
              //Error: not a java.sql.ResultSet[]
              *da << DgSqlCode(-LME_SIGNATURE_INVALID11)
                  << DgInt0((Lng32)numParam + numTrailingParams);
              if (optsig) NADELETEBASIC(optsig, heap_);
                return LM_ERR;
            }
          }
          else
          {
            // Error: not a java.sql.ResultSet[]
            *da << DgSqlCode(-LME_SIGNATURE_INVALID11)
                << DgInt0((Lng32)numParam + numTrailingParams);
            if (optsig) NADELETEBASIC(optsig, heap_);
            return LM_ERR;
          } 
        }
        else  
        {
          // Error: Missing parentheses.
          *da << DgSqlCode(-LME_SIGNATURE_INVALID1);
          if (optsig) NADELETEBASIC(optsig, heap_);
            return LM_ERR;
        }
      }//end else
    }//end while
  }//end if lookForTrailingPrams

  if ((idx + 1) > sigLen)
  {
    *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
    if (optsig != NULL) NADELETEBASIC(optsig, heap_);
    return LM_ERR;
  }
  for(int i = 0; i < numResultSets; i++) 
  {
    if (idx + resultSetLen > sigLen)
    {
        *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
        if (optsig) NADELETEBASIC(optsig, heap_);
        return LM_ERR;
    }
    str_cpy_all(&sigBuf[idx], resultSet, resultSetLen);
    idx += resultSetLen;
  }

  // End of method's parameter list.
  sigBuf[idx++] = ')';

  //
  // Now write the signature element for Return type
  //

  // If optional sig, ensure no return type is specified.
  if ((optsig != NULL) && (*optype))
  {
    *da << DgSqlCode(-LME_SIGNATURE_INVALID6);
    if (optsig) NADELETEBASIC(optsig, heap_);
    return LM_ERR;
  }

  // Get the Java type for the return type's SQL <type,subtype>.
  LmParameter lmParam(resultType, (short) resultSubType);
  LmJavaType jType(&lmParam);
  type = jType.getJavaTypeName(len);
  if (type == NULL)
  {
    // Error: Unknown or unsupported type used as a return type.
    *da << DgSqlCode(-LME_SIGNATURE_INVALID7);
    if (optsig) NADELETEBASIC(optsig, heap_);
    return LM_ERR;
  }

  // Ensure buffer accomodates return type and '\0'.
  if ((idx + len + 1) > sigLen)
  {
    *da << DgSqlCode(-LME_SIGNATURE_INVALID5);
    if (optsig) NADELETEBASIC(optsig, heap_);
    return LM_ERR;
  }

  // Add the method's return type to the sig Buffer.
  str_cpy_all(&sigBuf[idx], type, (Lng32) len);
  sigBuf[idx+len] = '\0';

  if (optsig) NADELETEBASIC(optsig, heap_);

  return LM_OK;
}

//
// unpackSignature():  Unpacks a Java signature.
// Callers has to call getUnpackedSignatureSize() first and then allocate
// so many bytes before calling unpackSignature().
//
// Example: For procedure proc(IN int, IN NUMERIC (9,3), INOUT char(50)),
// packed signature is (ILjava/math/BigDecimal;[Ljava/lang/String;)V
// unpacked signature is (int,java.math.BigDecimal,java.lang.String[])
//
// Note: This method does not do extensive error checking. For example,
// there is no checks for improper placement of '(', '[' etc. We assume
// that this method is called with proper unpackedSignature, that was
// generated by us.
//
Int32
LmJavaSignature::unpackSignature(char *unpackedSignature)
{
  return ::unpackSignature(encodedSignature_, unpackedSignature);
}

//
// getUnpackedSignatureSize() : Calculates the bytes required if
// the given (Java) signture is unpacked.
// returns size of unpacked signature string
//         -1 if unrecognized type is in signature
//
Int32
LmJavaSignature::getUnpackedSignatureSize()
{
  if (unpackedSignatureSize_ == -1)
    unpackedSignatureSize_ = ::getUnpackedSignatureSize(encodedSignature_);

  return unpackedSignatureSize_;
}