/**********************************************************************
// @@@ 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:         Formatter.C
 * RCS:          $Id: Formatter.cpp,v 1.18 1998/08/10 15:33:54  Exp $
 * Description:  
 *
 * Created:      4/15/95
 * Modified:     $ $Date: 1998/08/10 15:33:54 $ (GMT)
 * Language:     C++
 * Status:       $State: Exp $
 *
 *
 *
 *
 *****************************************************************************
 */

#include "NAWinNT.h"

#ifndef NDEBUG
#include <assert.h>
#endif

#include <ctype.h>
#include <iostream>
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <string.h>

#include "Debug.h"
#include "dfs2rec.h"
#include "exp_bignum.h"
#include "exp_clause.h"
#include "exp_clause_derived.h"
#include "exp_interval.h"
#include "exp_datetime.h"
#include "DatetimeType.h"
#include "Formatter.h"
#include "Int64.h"
#include "IntervalType.h"
#include "SQLCLIdev.h"
#include "str.h"

#include "SqlciCmd.h"
#include "NLSConversion.h"

short convDoItMxcs(char * source,
		   Lng32 sourceLen,
		   short sourceType,
		   Lng32 sourcePrecision,
		   Lng32 sourceScale,
		   char * target,
		   Lng32 targetLen,
		   short targetType,
		   Lng32 targetPrecision,
		   Lng32 targetScale,
		   Lng32 flags);

short convDoItMxcs(char * source,
		   Lng32 sourceLen,
		   short sourceType,
		   Lng32 sourcePrecision,
		   Lng32 sourceScale,
		   char * target,
		   Lng32 targetLen,
		   short targetType,
		   Lng32 targetPrecision,
		   Lng32 targetScale,
		   Lng32 flags);

Lng32 Formatter::display_length(Lng32 datatype,
                                Lng32 length,
                                Lng32 precision,
                                Lng32 scale,
                                Lng32 charsetEnum,
                                Lng32 heading_len,
                                SqlciEnv *sqlci_env,
                                Lng32 *output_buflen)
{
  Lng32 d_len;
  Lng32 d_buflen;

  Int32 scale_len = 0;
  if (scale > 0)
    scale_len = 1;
  
  switch (datatype)
    {
    case REC_BPINT_UNSIGNED: 
      // Can set the display size based on precision. For now treat it as
      // unsigned smallint
      d_len = d_buflen = SQL_USMALL_DISPLAY_SIZE;
      break;

    case REC_BIN8_SIGNED:
      d_len = d_buflen = SQL_TINY_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN8_UNSIGNED:
      d_len = d_buflen = SQL_UTINY_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN16_SIGNED:
      d_len = d_buflen = SQL_SMALL_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN16_UNSIGNED:
      d_len = d_buflen = SQL_USMALL_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN32_SIGNED:
      d_len = d_buflen = SQL_INT_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN32_UNSIGNED:
      d_len = d_buflen = SQL_UINT_DISPLAY_SIZE + scale_len;
      break;

    case REC_BIN64_SIGNED:
      d_len = d_buflen = SQL_LARGE_DISPLAY_SIZE + scale_len;
      break;
       
    case REC_BIN64_UNSIGNED:
      d_len = d_buflen = SQL_ULARGE_DISPLAY_SIZE + scale_len;
      break;
       
    case REC_BYTE_F_ASCII:
// 12/9/97: added for Unicode case
    case REC_NCHAR_F_UNICODE:
    case REC_NCHAR_V_UNICODE:
    case REC_BYTE_V_ASCII:
    case REC_BYTE_V_ASCII_LONG:
      d_len = length;
      // We usually use 2 ASCII char width for UCS2 characters.
      // We could replace this with the new logic used for UTF-8
      // columns that is character-based, not length-based.
      if ((datatype == REC_NCHAR_F_UNICODE ||
           datatype == REC_NCHAR_V_UNICODE) &&
          sqlci_env->getTerminalCharset() == CharInfo::UTF8)
        d_len /= 2;
      d_buflen = CharInfo::getMaxConvertedLenInBytes((CharInfo::CharSet) charsetEnum,
                                                     length,
                                                     sqlci_env->getTerminalCharset());
      // we can't have fewer bytes in the buffer than characters in the display
      // (note that we artificially inflate the display len for Unicode when
      // the terminal charset is not UTF-8)
      d_buflen = MAXOF(d_buflen, d_len);
      break;

    case REC_DECIMAL_UNSIGNED:
      d_len = d_buflen = length + scale_len;
      break;
      
    case REC_DECIMAL_LSE:
      d_len = d_buflen = length + 1 + scale_len;
      break;
      
    case REC_NUM_BIG_SIGNED:
      {
	BigNum tmp(length, precision, (short) scale, 0);
	d_len = d_buflen = tmp.getDisplayLength();
      }
      break;

    case REC_NUM_BIG_UNSIGNED:
      {
	BigNum tmp(length, precision, (short) scale, -1);
	d_len = d_buflen = tmp.getDisplayLength();
      }
      break;
      
    case REC_FLOAT32:
      d_len = d_buflen = SQL_REAL_DISPLAY_SIZE;
      break;
      
    case REC_FLOAT64:
      d_len = d_buflen = SQL_DOUBLE_PRECISION_DISPLAY_SIZE;
      break;

    case REC_INT_YEAR:
    case REC_INT_MONTH:
    case REC_INT_YEAR_MONTH:
    case REC_INT_DAY:
    case REC_INT_HOUR:
    case REC_INT_DAY_HOUR:
    case REC_INT_MINUTE:
    case REC_INT_HOUR_MINUTE:
    case REC_INT_DAY_MINUTE:
    case REC_INT_SECOND:
    case REC_INT_MINUTE_SECOND:
    case REC_INT_HOUR_SECOND:
    case REC_INT_DAY_SECOND: 
      {
	d_len = d_buflen = ExpInterval::getDisplaySize(datatype, 
                                                       (short)precision, (short)scale);
      }
    break;

    case REC_DATETIME:
      {
	d_len = d_buflen = ExpDatetime::getDisplaySize((short)precision, (short)scale);
      }
    break;

    case REC_BOOLEAN:
      d_len = d_buflen = SQL_BOOLEAN_DISPLAY_SIZE;
      break;

    default:
      d_len = d_buflen = length;
      break;
    }
  
  d_len = MAXOF(d_len, heading_len);
  d_buflen = MAXOF(d_buflen, heading_len);

  if (output_buflen)
    *output_buflen = d_buflen;

  return d_len;
}
			     
Int32 Formatter::buffer_it(SqlciEnv * sqlci_env, char *data,
			 Int32 datatype,
			 Lng32 length, Lng32 precision, Lng32 scale,
			 char *ind_data,
			 Int32 display_length,
			 Int32 display_buf_length,
			 Int32 null_flag,
			 char *buf, Lng32 *curpos,
			 NABoolean separatorNeeded,
			 NABoolean checkShowNonPrinting)
{
  CharInfo::CharSet tcs = sqlci_env->getTerminalCharset();
  Int32 tcsDataType = CharInfo::getFSTypeFixedChar(tcs);

  // don't support UCS2 as terminal charset, or change code below
  assert(tcsDataType == REC_BYTE_F_ASCII);

  str_pad(buf, display_buf_length, ' ');	// blank pad the buffer

  if (null_flag && ind_data  && ind_data[0] == (char)-1)
  {
    // null value is displayed right justified for numerics and
    // left justified for everything else.
    if ((datatype >= REC_MIN_NUMERIC) &&
	(datatype <= REC_MAX_NUMERIC))
      buf[display_length-1] = '?';
    else
      buf[0] = '?';
  }
  else
  {

  NABoolean ascii = FALSE, varchar = FALSE;

  if (
      (datatype == REC_BYTE_V_ASCII) ||
      (datatype == REC_BYTE_V_ASCII_LONG) ||
      (datatype == REC_BYTE_V_ANSI) ||
      (datatype == REC_NCHAR_V_UNICODE) ||	// 12/9/97
      (datatype == REC_NCHAR_V_ANSI_UNICODE) ||	// 6/26/98
      (datatype == REC_BLOB) ||
      (datatype == REC_CLOB)
     ) 
  {
    varchar = TRUE;
    // Depending on value of length, first 2 or 4 bytes of data indicate
    // the actual length -- adjust data and length
    if (length & 0xFFFF8000)
    {
      Int32 VCLen;
      str_cpy_all((char *)&VCLen, data, sizeof(Int32));
      length = (Lng32)VCLen;
      data = &data[sizeof(Int32)];
    }
    else
    {
      short VCLen;
      str_cpy_all((char *)&VCLen, data, sizeof(short));
      length = (Lng32)VCLen;
      data = &data[sizeof(short)];
    }

    #ifndef NDEBUG
      static UInt32 asserted = 0;
      if (!asserted++) {
	assert(SQL_VARCHAR_HDR_SIZE == sizeof(short));
      }
    #endif
  };

  ULng32 convFlags = CONV_LEFT_PAD;

  switch (datatype) {
  case REC_BYTE_F_ASCII:
  case REC_BYTE_V_ASCII:
  case REC_BYTE_V_ASCII_LONG: 
  case REC_BYTE_V_ANSI:
  case REC_BLOB:
  case REC_CLOB:
  {
    ascii = TRUE;
    convFlags = CONV_ALLOW_INVALID_CODE_VALUE;
  }
  // fall through to the next case

  case REC_BPINT_UNSIGNED:
  case REC_BIN64_SIGNED:
  case REC_BIN64_UNSIGNED:
  case REC_BIN32_SIGNED:
  case REC_BIN32_UNSIGNED:
  case REC_BIN16_SIGNED:
  case REC_BIN16_UNSIGNED:
  case REC_BIN8_SIGNED:
  case REC_BIN8_UNSIGNED:
  case REC_DECIMAL_UNSIGNED:
  case REC_DECIMAL_LS:
  case REC_DECIMAL_LSE:
  case REC_FLOAT32:
  case REC_FLOAT64: 
  case REC_DATETIME: 
  case REC_BOOLEAN:
  {
    short retcode = convDoIt(data,
			     length,
			     datatype,
			     precision,
			     scale,
			     buf,
			     display_buf_length,
			     tcsDataType,
			     0,    // targetPrecision
			     tcs,  // target charset
			     NULL, // varCharLen
			     0,    // varCharLenSize
			     0,    // heap
			     0,    // diagsArea
			     CONV_UNKNOWN,
			     0,
			     convFlags);

    if (ascii && tcs == CharInfo::UTF8)
      {
        // we want to display only display_length UTF-8
        // characters, remove any trailing blanks beyond that
        display_length = lightValidateUTF8Str(buf,
                                              display_buf_length,
                                              display_length,
                                              0);
      }
  }
  break;

  case REC_INT_YEAR:
  case REC_INT_MONTH:
  case REC_INT_YEAR_MONTH:
  case REC_INT_DAY:
  case REC_INT_HOUR:
  case REC_INT_DAY_HOUR:
  case REC_INT_MINUTE:
  case REC_INT_HOUR_MINUTE:
  case REC_INT_DAY_MINUTE:
  case REC_INT_SECOND:
  case REC_INT_MINUTE_SECOND:
  case REC_INT_HOUR_SECOND:
  case REC_INT_DAY_SECOND: 
  case REC_NUM_BIG_SIGNED:
  case REC_NUM_BIG_UNSIGNED:
  {
    convFlags |= CONV_LEFT_PAD;
    short retcode = convDoItMxcs(data,
				 length,
				 datatype,
				 precision,
				 scale,
				 buf,
				 display_length,
				 tcsDataType,
				 0,  // targetPrecision
				 tcs,
				 convFlags);
  }
  break;

  case REC_NCHAR_F_UNICODE: // 12/9/97: added for Unicode case
  case REC_NCHAR_V_UNICODE:
  case REC_NCHAR_V_ANSI_UNICODE:
  {
    Int32 localeInfo = CharInfo::getTargetCharTypeFromLocale();
    ascii = (localeInfo == REC_SBYTE_LOCALE_F);
    short retcode;
    CharInfo::CharSet TCS = sqlci_env->getTerminalCharset();

    if(TCS != CharInfo::UNICODE)
      {
        charBuf cbuf((unsigned char*)data, length);
        NAWcharBuf* wcbuf = 0;
        Int32 errorcode	= 0;
        wcbuf = csetToUnicode(cbuf, 0, wcbuf, CharInfo::UNICODE, errorcode);
        NAString* tempstr;
        if (errorcode != 0){
          tempstr = new NAString(" "); 
        }
        else {				
          tempstr = unicodeToChar(wcbuf->data(),wcbuf->getStrLen(), TCS, NULL, TRUE);
          TrimNAStringSpace(*tempstr, FALSE, TRUE);  // trim trailing blanks
        }
        length = tempstr->length();
        if (display_buf_length > length) 
          {	
	    str_cpy_all(buf, tempstr->data(), length);
	    /* blank pad target */
	    str_pad(&buf[length], display_buf_length - length, ' ');	  
          }
        else 
          {
            str_cpy_all(buf, tempstr->data(), display_buf_length);
            if (display_buf_length < length) 
              {
                errorcode = 1; 
                retcode = ex_expr::EXPR_ERROR;        
              }
          }
        if (TCS == CharInfo::UTF8)
          {
            // we want to display only display_length UTF-8
            // characters, remove any trailing blanks beyond that
            display_length = lightValidateUTF8Str(buf,
                                                  display_buf_length,
                                                  display_length,
                                                  0);
          }
        if (errorcode == 0) retcode = ex_expr::EXPR_OK;
      } // if TCS != CharInfo::UNICODE
    else
	  retcode = convDoIt(data,
                             length,
                             datatype,
                             precision,
                             scale,
                             buf,
                             display_buf_length,
                             localeInfo,
                             display_length,  // targetPrecision (max. num chars)
                             0,
                             NULL, // varCharLen
                             0,    // varCharLenSize
                             NULL, // heap
                             NULL, // diags area
                             CONV_UNKNOWN,
                             NULL, // conversion error flag
                             CONV_ALLOW_INVALID_CODE_VALUE);   
  }
  break;

  default:
    break;
  }

  if (ascii && checkShowNonPrinting) {
    buf[display_length] = '\0';
    display_length += showNonprinting(buf, display_length+1, varchar);
  }

  }	// !(null_flag && ...), i.e. actual data

  *curpos += display_length;
  if (separatorNeeded) {	// add blanks to separate each output field
    str_pad(&buf[display_length], BLANK_SEP_WIDTH, ' ');
    *curpos += BLANK_SEP_WIDTH;
  }
  
  return 0;
}


// If env var SQL_MXCI_SHOW_NONPRINTING is reset, or unset, or simply not set,
// or if it's set to the empty string or to '0',
//    no replacement is done -- the standard, default sqlci behavior.
//
// SET DEFINE SQL_MXCI_SHOW_NONPRINTING;  or  export SQL_MXCI_SHOW_NONPRINTING=1
//    we replace each nonprinting char (as defined in the ascii locale)
//    with a 8-bit char you're unlikely to see in other sqlci output,
//    an 8-bit char hardcoded here, specially chosen to be highly visible.
//
// If SQL_MXCI_SHOW_NONPRINTING is set to any non-digit character, say 'X',
//    we replace each nonprinting char with that specified X.
//
// If SQL_MXCI_SHOW_NONPRINTING is set to any other digit
// (other than '0' == no replacement, '1' == highly visible replacement),
//    we replace each nonprinting char with a 3-character hex escape sequence,
//    "\xx".  We return a special value of 9, HEX_EXPANSION_ON,
//    to indicate this setting.
//
//    Caller must provide a large-enough buffer
//    (up to 3 times, i.e. HEX_BUFSIZ_MULTIPLIER times, the nominal size)
//    for this setting to work!
//
// If the second character of what SQL_MXCI_SHOW_NONPRINTING is set to
// is the digit '8' -- e.g.,
//	export SQL_MXCI_SHOW_NONPRINTING=18
//	export SQL_MXCI_SHOW_NONPRINTING='#8'
//    we replace 8-bit chars as well.  The default obviously is to display
//    8-bit chars "as-is" (since they're generally printable/visible).
//
// This is useful when an embedded app inserts fixed CHAR data containing
// embedded NUL characters (or other nonprinting ones) and you want to see
// the data in SQLCI.  For an example, see the embedded regression test
// INS1.sql, function checkKanji().

NABoolean Formatter::replace8bit_ = FALSE;

char Formatter::getShowNonprintingReplacementChar(NABoolean reeval)
{
  static NABoolean eval = TRUE;
  static char replacementChar;

  if (reeval) eval = TRUE;
  if (eval) {
    eval = FALSE;
    replacementChar = '\0';
    replace8bit_ = FALSE;
    const char *env = getenv("SQL_MXCI_SHOW_NONPRINTING");
    if (env && *env && *env != '0') {
      if (isdigit(*env)) {
	if (*env == '1') {
	    replacementChar = '\xDD';
	}
	else
	  replacementChar = HEX_EXPANSION_ON;
      }
      else
        replacementChar = *env;

      if (*++env == '8')
        replace8bit_ = TRUE;
    }
  }

  return replacementChar;

}	// getShowNonprintingReplacementChar()

static inline NABoolean is8bit(Int32 c)
{ return c < 0 || c > SCHAR_MAX; }

static inline NABoolean isprint8bit(Int32 c)
{ return is8bit(c) && !Formatter::replace8bit_; }

static inline NABoolean replace(Int32 c)
{ return !(isprint(c) || isspace((unsigned char)c) || isprint8bit(c)); }  //  For VS2003

size_t Formatter::showNonprinting(char *s, size_t z, NABoolean varchar)
{
  const char r = getShowNonprintingReplacementChar();
  if (!r) return 0;

  if (z <= 1) {
    #ifndef NDEBUG
      if (z == 0 || !varchar)
	fprintf(stderr, "Error: z==" PFSZ ", varchar==%u\n", z,varchar);
    #endif
    if (z == 0) return 0;
  }
  if ((Int32)z < 0)	// SQL NULL indicator passed in as negative size...
    return 0;

  z--;					// convert from SIZE to OFFSET
  char c = s[z];			// should be the terminal nul byte
  if (c) {
    #ifndef NDEBUG
      if (varchar) {
	fprintf(stderr, "Error: nonzero terminating character: s[" PFSZ "]==%d", z,c);
	if (isprint(c)) fprintf(stderr, " (%c)", c);
	fprintf(stderr, "\n");
      }
    #endif
    s[z] = '\0';
  }

  // Replacement character of HEX_EXPANSION_ON is special
  size_t nonPrinting = 0;
  size_t zOrig = z;
  while (z--) {
    if (replace(s[z]))
      if (r != HEX_EXPANSION_ON)
	s[z] = r;
      else
	nonPrinting++;
  }
  if (r != HEX_EXPANSION_ON || !nonPrinting) return 0;

  #define HEXLEN     2				// byte as 2 hex digits, xx
  #define HEXFMT  "%02X"			// (the bslash will make it 3)
  char hex[HEXLEN+1];				// extra byte here for sprintf
    #ifndef NDEBUG
      if (HEXLEN+1 != HEX_BUFSIZ_MULTIPLIER)
	fprintf(stderr, "Error: HEXxxx %d %d\n", HEXLEN, HEX_BUFSIZ_MULTIPLIER);
    #endif

  z = zOrig;
  nonPrinting *= HEXLEN;
  size_t bz = z + nonPrinting;			// OFFSET of terminal nul byte

//if (bz >= zMaxbuf) {
//  #ifndef NDEBUG
//    fprintf(stderr, "Error, overflow: bz==%u, zAltBuf==%u\n", bz, zAltbuf);
//  #endif
//  bz = zAltbuf - 1;
//}

  char *altbuf = s;

  altbuf[bz--] = '\0';
  while (z--) {
    c = s[z];
    if (!replace(c))
      altbuf[bz--] = c;
    else {
      sprintf(hex, HEXFMT, c);
      for (size_t h=HEXLEN; h--; )
	altbuf[bz--] = hex[h];
      altbuf[bz--] = '\\';			// 3-char escape seq,  \xx
    }
  }
  #ifndef NDEBUG
    if (bz != z) fprintf(stderr, "Error: bz==" PFSZ ", z==" PFSZ "\n", bz, z);
  #endif

  return nonPrinting;			// the count of EXTRA chars we output

}	// showNonprinting()