/**********************************************************************
// @@@ 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:         conversionISO88591.h
 * RCS:          $Id: 
 * Description:  The implementation of ISO88591 related conversion routins
 *               
 *               
 * Created:      7/8/98
 * Modified:     $ $Date: 1998/08/10 16:00:29 $ (GMT)
 * Language:     C++
 * Status:       $State: Exp $
 *
 *
 *
 *
 *****************************************************************************
 */


// define MODULE_DEBUG when the module is to be debugged separately.
// #define  MODULE_DEBUG

#include "NLSConversion.h"
#include "str.h"
#include "csconvert.h"
#include "charinfo.h"
#include "nawstring.h"
#ifdef MODULE_DEBUG
#include "NLSConversion.cpp"
#endif

// 
// Conversions between ISO88591 and Unicode. 
// 
// The Unicode mapping available at http://www.unicode.org/Public/MAPPINGS/
// ISO8859/8859-1.TXT or described in the Unicode Standard Version 3.0 is
// used to construct the two routines. 
//
// Note the Microsoft Windows code page 1252 is a super set of ISO88591.
//

NAWcharBuf* ISO88591ToUnicode(const charBuf& input, 
	CollHeap *heap, NAWcharBuf*& unicodeString, NABoolean addNullAtEnd)
{
   NAWcharBuf* output = checkSpace(heap, input.getStrLen(), unicodeString, addNullAtEnd);

   if ( output == 0 ) return 0;

   NAWchar* target = output->data();

   Int32 i;
   for ( i=0; i<input.getStrLen(); i++ ) {
      target[i] = (NAWchar)(input.data()[i]);
   }

   if ( addNullAtEnd )
      target[i] = 0;

   output->setStrLen(input.getStrLen());
   return output;

}

charBuf* unicodeToISO88591(const NAWcharBuf& input, 
	CollHeap *heap, charBuf*& iso88591String, 
        NABoolean addNullAtEnd, NABoolean allowInvalidCodePoint)
{
   charBuf* output = checkSpace(heap, input.getStrLen(), iso88591String, addNullAtEnd);

   if ( output == 0 ) return 0;

   unsigned char* target = output->data();

   Int32 i;
   for ( i=0; i<input.getStrLen(); i++ ) {
      if ( input.data()[i] > 0xFF ) {
         if ( allowInvalidCodePoint )
           target[i] = '?';
         else {
           if ( iso88591String == NULL ) {
              if (heap)  
                NADELETE(output, charBuf, heap);
              else 
                delete output;
           }
           return NULL;
         }
      }  else
         target[i] = (unsigned char)(input.data()[i]);
   }

   if ( addNullAtEnd )
      target[i] = 0;

   output -> setStrLen(input.getStrLen());
   return output;
}

// 
// Conversions between cset and Unicode.   (wrapper for new calls)
// 
extern cnv_charset convertCharsetEnum (Int32 inset);
NAWcharBuf* csetToUnicode(const charBuf& input, 
	CollHeap *heap, NAWcharBuf*& unicodeString, Int32 cset, Int32 &errorcode,
        NABoolean addNullAtEnd, Int32 *charCount, Int32 *errorByteOff)
{
    char * err_ptr = NULL;
    UInt32 byteCount = 0, lv_charCount = 0, computedMaxBufSizeInNAWchars = 0;
    NABoolean outputBufferAllocatedByThisRoutine = (unicodeString == NULL) ? TRUE : FALSE;
    enum cnv_charset cnvSet = convertCharsetEnum (cset);

    computedMaxBufSizeInNAWchars = (input.getStrLen()+1)*2; // in NAWchar elements for the worst case
      
    NAWcharBuf* output = checkSpace(heap, computedMaxBufSizeInNAWchars, unicodeString, addNullAtEnd);

    if ( output == NULL ) {errorcode = CNV_ERR_BUFFER_OVERRUN; return NULL;}

    NAWchar* target = output->data();

    errorcode = LocaleToUTF16(
         cnv_version1,
         (const char *)input.data(), input.getStrLen(),
         (const char *)target, output->getBufSize()*BYTES_PER_NAWCHAR /* in bytes */,
         cnvSet,
         err_ptr,
         &byteCount,
         0,
         addNullAtEnd,
         &lv_charCount);
    if (errorcode == CNV_ERR_NOINPUT) errorcode=0;  // empty string is OK
    if (errorByteOff) *errorByteOff = err_ptr - (char *)input.data();
    if (charCount)    *charCount    = (Int32)lv_charCount;
    // If errorcode != 0, LocaleToUTF16 will not add the NULL terminator
    if (errorcode == 0 && addNullAtEnd && byteCount > 0)
       {
         // Exclude the size (in bytes) of the NULL terminator from the byte count.
         if (byteCount > BYTES_PER_NAWCHAR)
           byteCount -= BYTES_PER_NAWCHAR;
         else
           byteCount = 0;
       }
        
    output->setStrLen/*in_NAWchar_s*/(byteCount/BYTES_PER_NAWCHAR); // excluding the NULL terminator

    return output;

}

charBuf* unicodeTocset(const NAWcharBuf& input, 
	CollHeap *heap, charBuf*& csetString, Int32 cset, Int32 &errorcode,
        NABoolean addNullAtEnd, NABoolean allowInvalidCodePoint,
        Int32 *charCount, Int32 *errorByteOff)
{
   char * err_ptr;
   UInt32 byteCount, lvCharCount;
   enum cnv_charset cnvSet = convertCharsetEnum (cset);
   Int32 cwidth = CharInfo::maxBytesPerChar((CharInfo::CharSet)cset);
   charBuf* output = NULL;
   if ( input.data() != NULL && input.getStrLen() > 0)
   {
     Int32 cSetTargetBufferSizeInBytes = input.getStrLen/*in_NAWchars*/()*cwidth+16; // memory is cheap
     UInt32 cSetTargetStrLenInBytes = 0;
     char *pTempTargetBuf = new(heap) char[cSetTargetBufferSizeInBytes];
     errorcode = UTF16ToLocale ( cnv_version1
                               , (const char *)input.data()           // source string
                               , input.getStrLen()*BYTES_PER_NAWCHAR  // source string length in bytes
                               , (const char *)pTempTargetBuf         // buffer for the converted string
                               , cSetTargetBufferSizeInBytes          // target buffer size in bytes
                               , cnvSet                               // convert from UTF16 to cnvSet
                               , err_ptr
                               , &cSetTargetStrLenInBytes // out - length in bytes of the converted string
                               , 0
                               , addNullAtEnd
                               , allowInvalidCodePoint
                               );
     NADELETEBASICARRAY(pTempTargetBuf, heap); pTempTargetBuf = NULL;
     if (errorcode == 0 && cSetTargetStrLenInBytes > 0)
       output = checkSpace(heap, cSetTargetStrLenInBytes, csetString, addNullAtEnd);
     else // invoke the old code (i.e., keep the old behavior)
       output = checkSpace(heap, input.getStrLen()*cwidth, csetString, addNullAtEnd);
   }
   else // invoke the old code (i.e., keep the old behavior)
     output = checkSpace(heap, input.getStrLen()*cwidth, csetString, addNullAtEnd);

   if ( output == 0 ) {errorcode = CNV_ERR_BUFFER_OVERRUN; return 0;}

   unsigned char* target = output->data();

   errorcode =   UTF16ToLocale( cnv_version1,
                    (const char *)input.data(), input.getStrLen()*BYTES_PER_NAWCHAR,
                    (const char *)target, output->getBufSize(),
                    cnvSet ,
                    err_ptr,
                    &byteCount ,
		    0,
		    addNullAtEnd,
                    allowInvalidCodePoint,
                    &lvCharCount);
   if (errorcode == CNV_ERR_NOINPUT)
     errorcode=0;  // empty string is OK
   if (errorByteOff)
     *errorByteOff = err_ptr - (char *)input.data();
   if (charCount)
     *charCount    = (Int32)lvCharCount;

   // If errorcode != 0, LocaleToUTF16 will not add the NULL terminator
   if (errorcode == 0 && addNullAtEnd && byteCount > 0)
     {
       // Exclude the size (in bytes) of the NULL terminator from the byte count.
       UInt32 nullLen = CharInfo::minBytesPerChar((CharInfo::CharSet) cset);

       if (byteCount > nullLen)
         byteCount -= nullLen;
       else
         byteCount = 0;
     }

   output -> setStrLen(byteCount/*in_bytes*/); // excluding the null terminator from the count
   return output;
}


#ifdef MODULE_DEBUG
Int32 main(Int32 argc, char** argv)
{
      charBuf* latin1 = 0;

      NAWchar wbuf[1];
      NAWcharBuf uni(wbuf, 1);

      for ( NAWchar i=0; i<0xff; i++ ) {
         wbuf[0] = i;
         latin1 = unicodeToISO88591(uni, 0, latin1);
         if ( latin1 && latin1->data()[0] != i ) {
               printf("u2l1 test failed\n");
               return 1;
         }
      }

      unsigned char buf[1];
      charBuf ascii(buf, 1);
      NAWcharBuf* unicode = 0;

      for ( unsigned char j=0; j<0xff; j++ ) {
         buf[0] = j;
         unicode = ISO88591ToUnicode(ascii, 0, unicode);

         if ( unicode && unicode->data()[0] != j ) {
               printf("l12u test failed\n");
               return 1;
            }
      }

      wbuf[0] = 0xC0F3; // negative test
      latin1 = unicodeToISO88591(uni, 0, latin1);
      if ( latin1 ) 
         printf("negative u2l1 test failed\n");

      printf("test pass\n");
  
     return 0;
}

#endif