/**********************************************************************
// @@@ 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:         udrutil.cpp
* Description:  Generic utilities...
* Created:      01/01/2001
* Language:     C++
*
*****************************************************************************
*/
#include "Platform.h"


#include "sql_buffer.h"
#include "Int64.h" 
#include "udrutil.h"
#include "udrdefs.h"
#include "udrglobals.h"
#include "LmLangManager.h"
#include "LmParameter.h"
#include "spinfo.h"
#include "ComDiags.h"
#include <stdarg.h>
#include <ctype.h>
#include "ComRtUtils.h"


extern char *getDatatypeAsString(Int32 datatype, NABoolean extFormat = FALSE);

FILE *UdrTraceFile = stdout;

#define TF_STRING(x) ( (x) ? ("TRUE") : ("FALSE") )

void displaySqlBuffer(SqlBuffer *sbuf, Lng32 sbuflen, ostream &os)
{
  os << "Display an SQL Buffer:" << endl;
  os << "  Buffer Size          : " << sbuf->get_buffer_size() << endl;
  os << "  Used Size            : " << sbuf->get_used_size() << endl;
  os << "  Free Size            : "
     << (sbuf->get_buffer_size() - sbuf->get_used_size()) << endl;
  
  switch (sbuf->bufType())
  {
    case SqlBufferBase::NORMAL_:
      os << "  Buffer Type          : Normal" << endl;
      break;
    case SqlBufferBase::DENSE_:
      os << "  Buffer Type          : Dense" << endl;
      break;
    case SqlBufferBase::OLT_:
      os << "  Buffer Type          : OLT" << endl;
      break;
    default:
      os << "  Buffer Type          : Unknown ("
         << sbuf->bufType() << ")" << endl;
      break;
  }

  os << "  Packed?              : " << TF_STRING(sbuf->packed()) << endl;
  os << "  Empty?               : " << TF_STRING(sbuf->isFull()) << endl;
  os << "  Full?                : " << TF_STRING(sbuf->isEmpty()) << endl;
  os << "  Free?                : " << TF_STRING(sbuf->isFree()) << endl;
  
  Lng32 numtuppdescs = sbuf->getTotalTuppDescs();
  os << "  Total Tupp Descs     : " << numtuppdescs << endl;
  os << "  Processed Tupp Descs : " << sbuf->getProcessedTuppDescs() << endl;

#ifdef SQL_BUFFER_SIGNATURE
  char csig[100];
  convertInt64ToAscii(sbuf->getSignature(), csig);
  os << "  Signature        : " << csig << endl;
#endif
  
  tupp_descriptor *td;
  char *ctupp;
  ControlInfo *ci;
  
  for (Lng32 i = 1; i <= numtuppdescs; i++)
  {
    td = sbuf->getTuppDescriptor(i);
    if (td == NULL)
    {
      break;
    }
    
    ctupp = td->getTupleAddress();
    
    if (td->isDataTuple())
    {
      ServerDebug("");
      ServerDebug("Data Tuple:");
      os << "    Tupp(" << i << ") Ref Count     : "
         << td->getReferenceCount() << endl;
      os << "    Tupp(" << i << ") Allocated Size: "
         << td->getAllocatedSize() << endl;
      dumpBuffer((unsigned char *)ctupp, td->getAllocatedSize());
    }

    else if (td->isStatsTuple())
    {
      ServerDebug("");
      ServerDebug("Stats Tuple:");
      os << "    Tupp(" << i << ") Ref Count     : "
         << td->getReferenceCount() << endl;
      os << "    Tupp(" << i << ") Allocated Size: "
         << td->getAllocatedSize() << endl;
    }

    else if (td->isDiagsTuple())
    {
      ServerDebug("");
      ServerDebug("Diags Tuple:");
      os << "    Tupp(" << i << ") Ref Count     : "
         << td->getReferenceCount() << endl;
      os << "    Tupp(" << i << ") Allocated Size: "
         << td->getAllocatedSize() << endl;
    }
    
    else if (td->isControlTuple())
    {
      ServerDebug("");
      ServerDebug("Control Tuple:");
      os << "    Tupp(" << i << ") Ref Count     : "
         << td->getReferenceCount() << endl;
      os << "    Tupp(" << i << ") Allocated Size: "
         << td->getAllocatedSize() << endl;

      ci = (ControlInfo *)td->getTupleAddress();
      up_state us = ci->getUpState();
      down_state ds = ci->getDownState();
      
      os << "    Tupp(" << i << ")   UpState         : " << endl;
      os << "    Tupp(" << i << ")     Parent Index  : "
         << us.parentIndex << endl;
      os << "    Tupp(" << i << ")     Down Index    : "
         << us.downIndex << endl;

      switch (us.status)
      {
        case ex_queue::Q_NO_DATA:
        {
          os << "    Tupp(" << i << ")     Status        : Q_NO_DATA" << endl;
          break;
        }
        case ex_queue::Q_OK_MMORE:
        {
          os << "    Tupp(" << i << ")     Status        : Q_OK_MMORE" << endl;
          break;
        }
        case ex_queue::Q_SQLERROR:
        {
          os << "    Tupp(" << i << ")     Status        : Q_SQLERROR" << endl;
          break;
        }
        case ex_queue::Q_INVALID:
        {
          os << "    Tupp(" << i<< ")     Status        : Q_INVALID" << endl;
          break;
        }
        case ex_queue::Q_GET_DONE:
        {
          os << "    Tupp(" << i << ")     Status        : Q_GET_DONE" << endl;
          break;
        }
        default:
        {
          os << "    Tupp(" << i << ")     Request       : Unknown ("
             << us.status << ")" << endl;
          break;
        }
      }
      
      os << "    Tupp(" << i << ")     Match Nbr     : " << us.getMatchNo() << endl;
      os << "    Tupp(" << i << ")   DownState       : " << endl;
      
      switch (ds.request)
      {
        case ex_queue::GET_N:
        {
          os << "    Tupp(" << i << ")     Request       : GET_N" << endl;
          break;
        }
        case ex_queue::GET_ALL:
        {
          os << "    Tupp(" << i << ")     Request       : GET_ALL" << endl;
          break;
        }
        case ex_queue::GET_NOMORE:
        {
          os << "    Tupp(" << i << ")     Request       : GET_NOMORE" << endl;
          break;
        }
        case ex_queue::GET_EMPTY:
        {
          os << "    Tupp(" << i << ")     Request       : GET_EMPTY" << endl;
          break;
        }
        case ex_queue::GET_EOD:
        {
          os << "    Tupp(" << i << ")     Request       : GET_EOD" << endl;
          break;
        }
        case ex_queue::GET_NEXT_N:
        {
          os << "    Tupp(" << i << ")     Request       : GET_NEXT_N" << endl;
          break;
        }
        case ex_queue::GET_NEXT_N_MAYBE_WAIT:
        {
          os << "    Tupp(" << i
             << ")     Request       : GET_NEXT_N_MAYBE_WAIT" << endl;
          break;
        }
        case ex_queue::GET_NEXT_0_MAYBE_WAIT:
        {
          os << "    Tupp(" << i
             << ")     Request       : GET_NEXT_0_MAYBE_WAIT" << endl;
          break;
        }
        default:
        {
          os << "    Tupp(" << i << ")     Request       : Unknown ("
             << ds.request << ")" << endl;
          break;
        }
      }
      
      os << "    Tupp(" << i
         << ")     Request       : " << ds.request << endl;
      os << "    Tupp(" << i
         << ")     Request Value : " << ds.requestValue << endl;
      os << "    Tupp(" << i
         << ")     Nbr Get Nexts : " << ds.numGetNextsIssued << endl;
      os << "    Tupp(" << i
         << ")     Parent Index  : " << ds.parentIndex << endl;
      
      os << "    Tupp(" << i
         << ")   Buff Seq Nbr    : " << ci->getBufferSequenceNumber() << endl;
      
      os << "    Tupp(" << i << ")   Diags Area?     : "
         << TF_STRING(ci->getIsDiagsAreaPresent()) << endl;
      os << "    Tupp(" << i << ")   Ext Diags Area? : "
         << TF_STRING(ci->getIsExtDiagsAreaPresent()) << endl;
      os << "    Tupp(" << i << ")   Data Row?       : "
         << TF_STRING(ci->getIsDataRowPresent()) << endl;
      os << "    Tupp(" << i << ")   Stats Area?     : "
         << TF_STRING(ci->getIsStatsAreaPresent()) << endl;
      os << "    Tupp(" << i << ")   ExtStats Area?  : "
         << TF_STRING(ci->getIsExtStatsAreaPresent()) << endl;

    } // if (td->isControlTuple())

    else
    {
      // some other type of tuple...
      ServerDebug("");
      ServerDebug("Unknown Tuple:");
      os << "    Tupp(" << i << ") Ref Count     : "
         << td->getReferenceCount() << endl;
      os << "    Tupp(" << i << ") Allocated Size: "
         << td->getAllocatedSize() << endl;
    }

  } // for (long i = 1; i <= numtuppdescs; i++)
  
  os << endl;
  
} // displaySqlBuffer

// This method is not invoked from anywhere, need to determine if we should keep it, if so, we have to add
// a way to invoke it.
void displayStatement(SQLSTMT_ID s)
{
  cout << "  Statement ID           :" << endl;
  cout << "    Version              :" << s.version << endl;
  cout << "    Name Mode            :" << s.name_mode << endl;
  cout << "    Module               :" << endl;
  cout << "      Version            :" << s.module->version << endl;
  cout << "      Name               :" << s.module->module_name << endl;
  
#if defined( _MSC_VER )
  char ct[100];
  convertInt64ToAscii(s.module->creation_timestamp, ct);
  cout << "      Creation Timestamp :" << ct << endl;
#endif
  
  cout << "      Char Set           :" << s.module->charset << endl;
  cout << "      Name Length        :" << s.module->module_name_len << endl;
  cout << "    Identifier           :" << s.identifier << endl;
  cout << "    Handle               :" << s.handle << endl;
  cout << "    Char Set             :" << s.charset << endl;
  cout << "    Identifier Length    :" << s.identifier_len << endl;
} // displayStatement

void dumpLmParameter(LmParameter &p, Lng32 i, const char *prefix)
{
  if (prefix == NULL)
    prefix = "";
  
  ServerDebug("%s [%ld] Name [%s]", prefix, i,
              p.getParamName() ? p.getParamName() : "");
  ServerDebug("%s     FS type %s, prec %d, scale %d, charset %d", prefix,
              getDatatypeAsString(p.fsType()),
              (Int32) p.prec(), (Int32) p.scale(), (Int32) p.encodingCharSet());
  ServerDebug("%s     direction %s, collation %d, objMap %ld, resultSet %s",
              prefix, 
              getDirectionName(p.direction()), (Int32) p.collation(),
              (Int32) p.objMapping(), TF_STRING(p.resultSet()));
  ServerDebug("%s     IN  offset %d, len %d, null offset %d, null len %d",
              prefix, (Int32) p.inDataOffset(), (Int32) p.inSize(),
              (Int32) p.inNullIndOffset(), (Int32) p.inNullIndSize());
  ServerDebug("%s         vclen offset %d, vclen len %d", prefix,
              (Int32) p.inVCLenIndOffset(), (Int32) p.inVCLenIndSize());
  ServerDebug("%s     OUT offset %d, len %d, null offset %d, null len %d",
              prefix, (Int32) p.outDataOffset(), (Int32) p.outSize(),
              (Int32) p.outNullIndOffset(), (Int32) p.outNullIndSize());
  ServerDebug("%s         vclen offset %d, vclen len %d", prefix,
              (Int32) p.outVCLenIndOffset(), (Int32) p.outVCLenIndSize());

} // dumpLmParameter

void dumpBuffer(unsigned char *buffer)
{
  dumpBuffer(buffer, str_len((char *)buffer));
}

void dumpBuffer(unsigned char *buffer, size_t len)
{
  if (buffer == NULL)
  {
    return;
  }
  
  //
  // We will print the buffer 16 characters at a time. For each group
  // of 16 characters will we build two strings. One we call the "hex"
  // string and the other the "ascii" string. They will be formatted
  // as follows:
  //
  //  hex:   "<hex pair> <hex pair> ..."
  //  ascii: "<ascii value><ascii value>..."
  //
  // where each <hex pair> is a 4-character hex representation of
  // 2-bytes and each <ascii value> is 1 character.
  //
  const Int32 CHARS_PER_LINE = 16;
  const Int32 ASCII_BUF_LEN = CHARS_PER_LINE + 1;

  const Int32 HEX_BUF_LEN =
    (2 * CHARS_PER_LINE)     // 2 hex characters per byte of input
    + (CHARS_PER_LINE / 2)   // one space between each <hex pair>
    + 1;                     // null terminator

  //
  // The 100-byte pads in the following two buffers are only used as
  // safeguards to prevent corrupting the stack. The code should work
  // without the padding.
  //
  char hexBuf[HEX_BUF_LEN + 100];
  char asciiBuf[ASCII_BUF_LEN + 100];
  size_t i, j, hexOffset, asciiOffset;
  size_t startingOffset;
  Int32 nCharsWritten;

  //
  // This message will be used for buffer overflow assertion failures
  //  
  const char *msg = "Buffer overflow in dumpBuffer() routine";

  i = 0;
  while (i < len)
  {
    //
    // Initialize the two buffers with blank padding and null
    // terminators
    //
    memset(hexBuf,  ' ', HEX_BUF_LEN);
    memset(asciiBuf, ' ', ASCII_BUF_LEN);
    hexBuf[HEX_BUF_LEN - 1] = '\0';
    asciiBuf[ASCII_BUF_LEN - 1] = '\0';
    hexOffset = 0;
    asciiOffset = 0;
    startingOffset = i;

    //
    // Inside the following for loop hexOffset should be incremented
    // by 2 or 3 and asciiOffset incremented by 1.
    //
    for (j = 0; j < CHARS_PER_LINE && i < len; j++, i++)
    {
      //
      // Write a 2-character hex value to the hex buffer. The %X
      // format expects an int value.
      //
      nCharsWritten = sprintf(&hexBuf[hexOffset], "%02X",
                              (Int32) buffer[i]);
      UDR_ASSERT(nCharsWritten == 2, msg);
      hexOffset += 2;

      //
      // Add a space to the hex buffer following each pair of bytes
      //
      if (j % 2 == 1)
      {
        hexBuf[hexOffset++] = ' ';
      }

      //
      // Write one character to the ascii buffer
      //
      char c;
      if (!isprint(buffer[i]))
      {
        c = '.';
      }
      else
      {
        c = buffer[i];
      }
      asciiBuf[asciiOffset++] = c;

    } // for (j = 0; j < CHARSPERLINE && i < len; j++, i++)

    UDR_ASSERT(hexOffset < HEX_BUF_LEN, msg);
    UDR_ASSERT(asciiOffset < ASCII_BUF_LEN, msg);
    UDR_ASSERT(hexBuf[HEX_BUF_LEN - 1] == '\0', msg);
    UDR_ASSERT(asciiBuf[ASCII_BUF_LEN - 1] == '\0', msg);

    ServerDebug("%08X  %-*s |  %s", (Int32) startingOffset,
                (Int32) (HEX_BUF_LEN - 1), hexBuf, asciiBuf);

  } // while (i < len)

  ServerDebug("");
  
} // dumpBuffer

void dumpComCondition(ComCondition *cc, char *ind)
{
  //ServerDebug("%s  Class Origin        : %s",  ind, cc->getClassOrigin());
  //ServerDebug("%s  Sub Class Origin    : %s",  ind, cc->getSubClassOrigin());
  //ServerDebug("%s  Message             : %s",  ind, cc->getMessageText());
  //ServerDebug("%s  Message Length      : %ld", ind,
  //            (long) cc->getMessageLength());

  ServerDebug("%s  Condition Nbr       : %ld", ind,
              (Lng32) cc->getConditionNumber());
  ServerDebug("%s  SQL Code            : %ld", ind, (Lng32) cc->getSQLCODE());
  ServerDebug("%s  Server Name         : %s",  ind, cc->getServerName());
  ServerDebug("%s  Connection Name     : %s",  ind, cc->getConnectionName());
  ServerDebug("%s  Constraint Name     : %s",  ind, cc->getConstraintName());
  ServerDebug("%s  Constraint Catalog  : %s",  ind,
              cc->getConstraintCatalog());
  ServerDebug("%s  Constraint Schema   : %s",  ind, cc->getConstraintSchema());
  ServerDebug("%s  Catalog Name        : %s",  ind, cc->getCatalogName());
  ServerDebug("%s  Schema Name         : %s",  ind, cc->getSchemaName());
  ServerDebug("%s  Table Name          : %s",  ind, cc->getTableName());
  ServerDebug("%s  Column Name         : %s",  ind, cc->getColumnName());
  ServerDebug("%s  Cursor Name         : ",    ind, cc->getSqlID());
  ServerDebug("%s  Row Number          : %ld", ind, (Lng32) cc->getRowNumber());
  
  for (Int32 jj=0; jj<ComCondition::NumOptionalParms;jj++)
  {
    if (cc->getOptionalString(jj) != NULL)
    {
      ServerDebug("%s  OptionalString(%ld) : %s",
                  ind, (Lng32) jj, cc->getOptionalString(jj));
    }
    
    if (cc->getOptionalInteger(jj) != ComDiags_UnInitialized_Int)
    {
      ServerDebug("%s  OptionalInteger(%ld): %ld",
                  ind, (Lng32) jj, (Lng32) cc->getOptionalInteger(jj));
    }
  }

}  // dumpComCondition...

void dumpDiagnostics (ComDiagsArea *diags, Lng32 indent)
{
  ComCondition *cc;
  Lng32 ii;
  Lng32 nbrW, nbrE, nbrA;
  
  Lng32 indmax;
  if (indent > 99)
  {
    indmax = 99;
  }
  else
  {
    indmax = indent;
  }
  
  char ind[100];
  Lng32 indIdx = 0;
  for (indIdx = 0; indIdx < indmax; indIdx++)
    ind[indIdx] = ' ';
  ind[indIdx] = '\0';
  
  nbrW = diags->getNumber(DgSqlCode::WARNING_);
  nbrE = diags->getNumber(DgSqlCode::ERROR_);
  nbrA = diags->getNumber();  // errors followed by warnings...
  
  ServerDebug(" ");
  ServerDebug("%sContents of Diagnostics Area:", ind );
  ServerDebug("%s-----------------------------", ind );
  ServerDebug("%sMain Error              : %ld", ind,
              (Lng32) diags->mainSQLCODE());
  ServerDebug("%sNumber                  : %ld", ind,
              (Lng32) diags->getNumber());
  ServerDebug("%sAre More?               : %s",  ind,
              (diags->areMore() ? "TRUE" : "FALSE"));
  ServerDebug("%sRow Count               : %ld", ind,
              (Lng32) diags->getRowCount());
  ServerDebug("%sCost                    : %le", ind,
              (double) diags->getCost());
  ServerDebug("%sAvg Stream Wait Time    : %ld", ind,
              (Lng32) diags->getAvgStreamWaitTime());
  ServerDebug("%sLength Limit            : %ld", ind,
              (Lng32) diags->getLengthLimit());
  ServerDebug("%sSQL Function            : %ld", ind,
              (Lng32) diags->getFunction());
  ServerDebug("%sSQL Function Name       : %s",  ind,
              diags->getFunctionName());
  ServerDebug("%sNbr Warnings            : %ld", ind, (Lng32) nbrW);
  ServerDebug("%sNbr Errors              : %ld", ind, (Lng32) nbrE);
  
  for (ii=1; ii <= nbrW; ii++)
  {
    cc = diags->getWarningEntry(ii);
    ServerDebug("%sWarning(%ld)          :",     ind, (Lng32) ii);
    dumpComCondition(cc, ind);
  }
  
  for (ii=1; ii <= nbrE; ii++)
  {
    cc = diags->getErrorEntry(ii);
    ServerDebug("%sError(%ld)            :",  ind, (Lng32) ii);
    dumpComCondition(cc, ind);
  }
  
  ServerDebug(" ");
  return;
  
  // errors and warnings in order added
  for (ii=1; ii <= nbrA; ii++)
  {
    ServerDebug("%sErrors/Warnings(%ld)  :",     ind, (Lng32) ii);
    dumpComCondition(cc, ind);
  }

} // dumpDiagnostics

const char *getDirectionName(ComColumnDirection d)
{
  switch (d)
  {
    case COM_INPUT_COLUMN: return "IN";
    case COM_OUTPUT_COLUMN: return "OUT";
    case COM_INOUT_COLUMN: return "INOUT";
  }
  return ComRtGetUnknownString((Int32) d);
}

const char * getLmResultSetMode(const LmResultSetMode &rs)
{
  switch (rs)
  {
    case RS_NONE: return "RS_NONE";
    case RS_SET: return "RS_SET";
  }
  return ComRtGetUnknownString((Int32) rs);
}

void ServerDebug(const char *formatString, ...)
{
  static Int32 pid = getpid();
  fprintf(UdrTraceFile, "[%04d] ", pid);
  va_list args;
  va_start(args, formatString);
  vfprintf(UdrTraceFile, formatString, args);
  fprintf(UdrTraceFile, "\n");
  fflush(UdrTraceFile);
}

void doMessageBox(UdrGlobals *UdrGlob, Int32 trLevel,
                  NABoolean moduleType, const char * moduleName)
{
  if (UdrGlob && UdrGlob->traceLevel_ >= trLevel && moduleType)
  {
    MessageBox(NULL, moduleName ,
               UdrGlob->serverName_, MB_OK|MB_ICONINFORMATION);
  }
}

#ifdef _DEBUG
void sleepIfPropertySet(LmLanguageManager &lm,
	const char *property,
	ComDiagsArea *d)
{
  Lng32 delay = 0;
  if (getLmProperty(lm, property, delay, d) && delay > 0)
  {
    Sleep(delay * 1000);
  }
}

NABoolean getLmProperty(LmLanguageManager &lm,
                        const char *property,
                        Lng32 &result,
                        ComDiagsArea *diags)
{
  NABoolean ok = FALSE;
  char buf[100];
  NABoolean isSet = FALSE;
  LmResult r = lm.getSystemProperty(property, buf, 100, isSet, diags);
  if (r == LM_OK && isSet && buf[0] != 0)
  {
    result = atol(buf);
    ok = TRUE;
  }
  return ok;
}
#endif // _DEBUG

// This function is used by the signal/trap/exit handler code.
// It is moved from UdrFFDC.cpp file to avoid compilation errors.
// Inclusion of spinfo.h and TFDS header file cause some re-definitions.
void  getActiveRoutineInfo(UdrGlobals *UdrGlob, 
                           char *routineName,
                           char *routineType,
                           char *routineLanguage,
                           NABoolean &isRoutineActive)
{
  SPInfo *currSP = NULL;
  ComRoutineLanguage language;

  routineName[0] = '\0';
  routineType[0] = '\0';
  routineLanguage[0] = '\0';
  isRoutineActive = FALSE;

  currSP = (UdrGlob ? UdrGlob->getCurrSP() : NULL);
  if (currSP == NULL)
    return;
  
  strcpy (routineName,  currSP->getSqlName());

  language = currSP->getLanguage();

  switch (language)
  {
    case COM_LANGUAGE_JAVA:
      strcpy(routineLanguage, "JAVA");
      // following is a kluge until we propagate routine type from the plan
      strcpy(routineType, "Stored Procedure");
      break;

    case COM_LANGUAGE_C:
      strcpy(routineLanguage, "C");
      // following is a kluge until we propagate routine type from the plan
      strcpy(routineType, "UDF");
      break;

    case COM_LANGUAGE_CPP:
      strcpy(routineLanguage, "C++");
      // following is a kluge until we propagate routine type from the plan
      strcpy(routineType, "UDF");
      break;

    default:
      break;
  }

  LmLanguageManager *lm = (UdrGlob ? UdrGlob->getLM(language) : NULL);
  if (lm == NULL) 
    return;

  isRoutineActive = lm->isRoutineActive();
  
}