/**********************************************************************
// @@@ 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:         conversionHex.cpp
* Description:  hexa string conversion routines
*
* Created:      5/14/03
* Language:     C++
*
*
*
******************************************************************************
*/

#include "conversionHex.h"
#include "NAString.h"
#include "nawstring.h"
#include "ComASSERT.h"
#include "SQLTypeDefs.h"
#include "str.h"
#include "csconvert.h"

// a helper function converting a hexdecimal digit to its value
static
unsigned short getHexDigitValue(NAWchar wc)
{
   if ( isDigit8859_1(wc) )
      return (unsigned short)wc - '0';
   else {
      if ( 'A' <= wc AND wc <= 'F' )
         return (unsigned short)wc - 'A' + 10;
      else
         return (unsigned short)wc - 'a' + 10;
   }
}

// JQ
// spaces are allowed in hexadecimal format string literals
// these spaces have to be removed
//
static NAWString *removeWSpaces(const NAWchar *s, Int32& len, NAWchar quote, CollHeap *heap)
{
  NAWString *r = new (heap) NAWString(heap);
  Int32 tmpLen = 0;
  if (!s || len <= 0) return r;

  for (Int32 x = 0; x < len; x++)
    {
      if (s[x] == quote)
        {
        // prematurely end the process
          break;
        }
      if (s[x] != L' ') {
        ++tmpLen;
        r->append(s[x]);
      }
    }
  len = tmpLen;
  return r;
}

// a helper function converting a hexdecimal digit to a single-byte string
static NAString * 
convHexToChar(const NAWchar *s, Int32 inputLen, CharInfo::CharSet cs, CollHeap* heap)
{
  ComASSERT((inputLen % SQL_DBCHAR_SIZE) == 0);
  NAString *r = new (heap) NAString(heap);
  if (!s || inputLen <= 0) return r;

  unsigned char upper4Bits;
  unsigned char lower4Bits;

  for (Int32 i = 0; i < inputLen; i=i+2) {
    if (isHexDigit8859_1(s[i]) AND isHexDigit8859_1(s[i+1])) {

      upper4Bits = getHexDigitValue(s[i]);
      lower4Bits = getHexDigitValue(s[i+1]);

      char c = (upper4Bits << 4) | lower4Bits;
      r->append(c);
    } else { 
      NADELETE(r, NAString, heap);
      return NULL;
    }
  }
  return r;
}

// a helper function converting a hexdecimal digit to a double-byte string
static NAWString * 
convHexToWChar(const NAWchar *s, Int32 inputLen, CharInfo::CharSet cs, CollHeap* heap)
{
  if ( cs == CharInfo::UNICODE )
  {
    NAWString *r = new (heap) NAWString(heap);
    if (!s || inputLen <= 0) return r;

    assert((inputLen % 4) == 0);
  
    for (Int32 i = 0; i < inputLen; i=i+4) {
      if ( isHexDigit8859_1(s[i])   AND isHexDigit8859_1(s[i+1]) AND
           isHexDigit8859_1(s[i+2]) AND isHexDigit8859_1(s[i+3]) )
      {
        unsigned short first4Bits  = getHexDigitValue(s[i]);
  	unsigned short second4Bits = getHexDigitValue(s[i+1]);
  	unsigned short third4Bits  = getHexDigitValue(s[i+2]);
  	unsigned short fourth4Bits = getHexDigitValue(s[i+3]);
  
        NAWchar wc = (first4Bits << 12) | (second4Bits << 8) | (third4Bits << 4) | fourth4Bits;
        r->append(wc);
      }
      else {
        NADELETE(r, NAWString, heap);
        return NULL;
      }
    }
  
    if (! CharInfo::checkCodePoint(r->data(), r->length(), cs) ) {
      NADELETE(r, NAWString, heap);
      return NULL;
    }

    return r;
  }
  return NULL;
}

// verify whether a hexadecimal string is in valid format.
static NABoolean isValidHexFormat(const NAWchar *str, Int32 len, CharInfo::CharSet cs)
{
  // specified by  _charsetname'([0-9, a-f, A-F])*'

  // ISO88591:               hex digits per char = 2
  // UCS2/KSC5601/KANJI:     hex digits per char = 4
  Int32 hexPerChar = 2 * CharInfo::minBytesPerChar(cs);

  // The following while loop recognizes regular expression:
  // space* [non-space]\{hexPerChar\} space*
  // 
  // Examples of legal hexdecimal literals. 
  //       x' 98 FF  F0' (ISO88591)
  //       x' 98FF F0' (ISO88591)
  //       _ucs2 x' 98FF 3dF0' (UCS2)
  // 
  // Examples of illegal hexdecimal literals. 
  //       x' 98F F  F0' (ISO88591)
  //       _ucs2 x'9FF 3dF0' (UCS2)
  Int32 i = 0;
  while ( i<len ) {
     if ( str[i] != L' ' ) {
        // at least hexPerChar non-space chars should be present, starting at i
        for ( Int32 j=0; j<hexPerChar; j++ )
        {
          if ( i >= len || ! isHexDigit8859_1(str[i++]) ) {
             // invalid format
             return FALSE;
          } 
        }
     } else i++;
  }
  return TRUE;
}


hex_conversion_code verifyAndConvertHex(const NAWchar *str, Int32 len, NAWchar quote,
                   CharInfo::CharSet cs, CollHeap* heap, void*& result)
{
  if ( CharInfo::isHexFormatSupported(cs) == FALSE )
    return NOT_SUPPORTED;

  if ( isValidHexFormat(str, len, cs) == FALSE )
    return INVALID;

  if ( heap == 0 )
    return CONV_FAILED;

  NAWString *tmpStr = removeWSpaces(str, len, quote, heap);

  // convert to actual string literal
  hex_conversion_code ok = INVALID_CODEPOINTS;
  switch ( cs ) {
    case CharInfo::KANJI_MP:
    case CharInfo::KSC5601_MP:
    case CharInfo::ISO88591:
    case CharInfo::UTF8:
      {
        Int32   StrLength = (Int32)(tmpStr->length());
        result = convHexToChar(tmpStr->data(), StrLength, cs, heap);
        if (result ) {
           ok = SINGLE_BYTE; // Assume good data for now
           if (cs == CharInfo::UTF8) {
              // Verify UTF8 code point values are valid
              Int32   iii = 0;
              Int32   rtnv = 0;
              NAString* reslt = (NAString*)result;
              UInt32  UCS4 = 0;
              StrLength = StrLength/2;  // Orig StrLength was for hex-ASCII string
              while ( iii < StrLength )
              {
                 rtnv = LocaleCharToUCS4( &(reslt->data()[iii]), StrLength - iii,
                                          &UCS4, cnv_UTF8 );
                 if (rtnv == CNV_ERR_INVALID_CHAR)
                 {
                    ok = INVALID_CODEPOINTS; // Return error
                    break;
                 }
                 iii += rtnv;
              }
           }
        }
      }
      break;

    case CharInfo::UNICODE:
      {
        result = convHexToWChar(tmpStr->data(), (Int32)(tmpStr->length()), cs, heap);
        if (result) ok = DOUBLE_BYTE;
      }
      break;

    default:
      ok = INVALID;
      break;
  }
  return ok;
}