/*

* Copyright (c) 2000 - 2001 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#include "nwx_defs.h"

#include "CHtmlpParser.h"

#include "nw_htmlp_to_wbxml.h"

#include "nw_htmlp_dict.h"

#include "nw_xhtml_xhtml_1_0_tokens.h"

#include "nwx_statuscodeconvert.h"

#include "BrsrStatusCodes.h"

#include "nw_wml1x_wml_1_3_tokens.h"

#include "nwx_logger.h"

#include "nwx_http_defs.h"

//lint -save -esym(1401, TSignal::iStatus) not initialized by constructor

#include <flogger.h>

//lint -restore

/* When encoding is UCS-2, the parser has changed the byte order to

native, however, the WBXML should be written in network (i.e., big

endian) order.  The way this is done is to change the byte order

in-place to network order, write the WBXML, and then put the byte

order back to native in-place. */

static

void

NW_HTMLP_WbxmlEncoder_Ucs2NativeToNetworkByteOrder(NW_Uint32 byteCount,

                                                   NW_Uint8* pBuf)

{

  NW_Uint32 i;

  NW_Uint16 c_ucs2 = 1;

  if (((NW_Uint8*)&c_ucs2)[0] == 1) { /* test for little endian host */

    for (i = 0; i < byteCount; i += 2) {

      (void)NW_Mem_memcpy(&c_ucs2, pBuf + i, sizeof(NW_Uint16));

      pBuf[i] = (NW_Uint8)((c_ucs2 >> 8) & 0xff);

      pBuf[i+1] = (NW_Uint8)(c_ucs2 & 0xff);

    }

  }

}

static

void

NW_HTMLP_WbxmlEncoder_Ucs2NetworkToNativeByteOrder(NW_Uint32 byteCount,

                                                   NW_Uint8* pBuf)

{

  NW_Uint32 i;

  NW_Uint16 c_ucs2 = 1;

  if ((byteCount & 1) == 1)

    byteCount--;

  if (((NW_Uint8*)&c_ucs2)[0] == 1) { /* test for little endian host */

    for (i = 0; i < byteCount; i += 2) {

      /* this is a clever trick: pick up bytes in big endian order,

         force the result to memory via taking address of result which

         will put the 16-bits into native byte order, then copy the

         result over the original bytes */

      c_ucs2 = (NW_Uint16)((pBuf[i] << 8) | pBuf[i+1]);

      (void)NW_Mem_memcpy(pBuf + i, &c_ucs2, sizeof(NW_Uint16));

    }

  }

}

/* end of line normalization replaces DOS or Mac style end of line

with Unix style end of line.  If no normalization is needed, then on

return *ppTextOut == pTextIn (i.e., no malloc was done), otherwise you

need to call NW_Mem_Free(*ppTextOut) when you are done with the output

NOTE: only works for native byte order!

*/

static

TBrowserStatusCode

NW_HTMLP_WbxmlEncoder_EndOfLineNormalization(NW_Uint32 encoding,

                                             NW_Uint32* pCharCount,

                                             NW_Uint32* pByteCount,

                                             const NW_Uint8* pTextIn,

                                             NW_Uint8** ppTextOut)

{

  NW_Uint32 i;

  NW_Uint32 j;

  NW_Uint32 elideCharCount;

  NW_Uint32 elideByteCount;

  NW_Int32 byteCount;

  NW_Ucs2 cUCS2;

  NW_Uint8 crHit;

  NW_Uint8 needsNormalization = 0;

  /* the output is the input unless it must be normalized */

  *ppTextOut = (NW_Uint8*)pTextIn;

  /* scan to count #xD's that need translating */

  elideCharCount = 0;

  elideByteCount = 0;

  crHit = 0;

  for (i = 0; i < *pByteCount; i += byteCount) {

    byteCount = NW_String_readChar((NW_Uint8*)&(pTextIn[i]), &cUCS2, encoding);

    if (byteCount < 0) {

      return KBrsrFailure;

    }

    /* catch DOS 0xd 0xa eol */

    if (crHit && (cUCS2 == 0xa)) {

      elideCharCount++;

      elideByteCount += byteCount;

    }

    if (cUCS2 == 0xd) {

      needsNormalization = 1;

      crHit = 1;

    } else {

      crHit = 0;

    }

  }

  if (needsNormalization) {

    /* alloc a new string */

    *ppTextOut = (NW_Uint8*)NW_Mem_Malloc(*pByteCount - elideByteCount);

    if (*ppTextOut == NULL) {

      *ppTextOut = (NW_Uint8*)pTextIn;

      return KBrsrOutOfMemory;

    }

    /* make a normalized copy of input */

    crHit = 0;

    j = 0;

    for (i = 0; i < *pByteCount; i += byteCount) {

      byteCount = NW_String_readChar((NW_Uint8*)&(pTextIn[i]), &cUCS2, encoding);

      if (byteCount < 0) {

        NW_Mem_Free(*ppTextOut);

        *ppTextOut = (NW_Uint8*)pTextIn;

        return KBrsrFailure;

      }

      /* check that readChar isn't trying to read off end of buffer */

      NW_ASSERT((i + byteCount - 1) < *pByteCount);

      if (cUCS2 == 0xd) {

        crHit = 1;

        if (byteCount == 1) {

          (*ppTextOut)[j++] = 0xa;

        } else if (byteCount == 2) {

          /* this looks odd but takes into account either endianess */

          if (pTextIn[i] == 0xd) {

            (*ppTextOut)[j++] = (NW_Uint8)0xa;

            (*ppTextOut)[j++] = 0;

          } else {

            (*ppTextOut)[j++] = 0;

            (*ppTextOut)[j++] = (NW_Uint8)0xa;

          }

        } else {

          NW_ASSERT(byteCount <= 2); /* code bug, force debug stop here */

          NW_Mem_Free(*ppTextOut);

          *ppTextOut = (NW_Uint8*)pTextIn;

          return KBrsrFailure;

        }

      } else {

        if (!(crHit && (cUCS2 == 0xa))) {

          (void)NW_Mem_memcpy(&((*ppTextOut)[j]), &(pTextIn[i]), byteCount);

          j += byteCount;

        }

        crHit = 0;

      }

    }

    *pByteCount -= elideByteCount;

    *pCharCount -= elideCharCount;

  }

  return KBrsrSuccess;

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_New(NW_Uint32 publicID,

                                      NW_Uint32 encoding, void** ppV)

{

  NW_WBXML_Dictionary_t* pDictionary;

  NW_HTMLP_WbxmlEncoder_t** ppTE = (NW_HTMLP_WbxmlEncoder_t**)ppV;

  *ppTE = (NW_HTMLP_WbxmlEncoder_t*)NW_Mem_Malloc(sizeof(NW_HTMLP_WbxmlEncoder_t));

  if (*ppTE == NULL) {

    return KBrsrOutOfMemory;

  }

  (*ppTE)->lastTagTokenIndex = 0;

  (*ppTE)->publicID = publicID;

  (*ppTE)->encoding = encoding;

  (*ppTE)->pE = (NW_WBXML_Writer_t *)NW_Mem_Malloc(sizeof(NW_WBXML_Writer_t));

  if ((*ppTE)->pE == NULL) {

    NW_Mem_Free(*ppTE);

    *ppTE = NULL;

    return KBrsrOutOfMemory;

  }

  /* Note that we only have access to one dictionary and we

  should really have two: one for tags and one for attributes. */

  pDictionary = NW_WBXML_Dictionary_getByPublicId((*ppTE)->publicID);

  NW_WBXML_Writer_Initialize((*ppTE)->pE,

                             0 /* byte count */,

                             NULL, NULL, /* no mem needed for sizing */

                             pDictionary, pDictionary,

                             NULL, NULL, NULL, NULL, NULL,

                             NW_TRUE /* do sizing only */);

    return KBrsrSuccess;

}

static

void NW_HTMLP_WbxmlEncoder_SetToWrite(

  NW_HTMLP_WbxmlEncoder_t* pTE,

  NW_Uint32 byteLength, NW_Uint8* pBuf,

  NW_WBXML_Writer_GrowBuf_t growBufCallback)

{

  if( (pTE->publicID == NW_xhtml_1_0_PublicId) && 

      ( CXML_Additional_Feature_Supprted() & CXML_DTD_SUPPORT_ON) )

  {

   NW_Encoder_StringTable_t* strTable = NW_Encoder_StringTable_new();

   NW_WBXML_Writer_Initialize(pTE->pE,

                             byteLength, pBuf,

                             growBufCallback,

                             pTE->pE->pTagDictionary,

							 pTE->pE->pAttributeDictionary,

                             NW_Encoder_StringTable_getStringTableOffset,

							 NW_Encoder_StringTable_addToStringTable,

                             strTable, 

							 NW_Encoder_StringTable_StringTableIterateInit,

							 NW_Encoder_StringTable_StringTableIterateNext,

                             NW_FALSE /* do sizing only */);

  }

  else

  {

   NW_WBXML_Writer_Initialize(pTE->pE,

                             byteLength, pBuf,

                             growBufCallback,

                             pTE->pE->pTagDictionary,

                             pTE->pE->pAttributeDictionary,

                             NULL, NULL, NULL, NULL, NULL,

                             NW_FALSE /* don't do sizing, write */);

}

}

static

void NW_HTMLP_WbxmlEncoder_Delete(void* pV)

{

  if (pV)

  {

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  NW_Mem_Free(pE); /* note that this doesn't free WBXML buf and string table*/

  NW_Mem_Free(pTE);

}

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_BeginDocumentCB(NW_HTMLP_Lexer_t* pL,

                                                  void* pV)

{

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  NW_REQUIRED_PARAM(pL);

  /* Note: We do not build a string table because it isn't clear if

  it is worthwhile. */

  return StatusCodeConvert(NW_WBXML_Writer_Header(pE, 3 /* wbxml version */,

                                pTE->publicID, pTE->encoding,

                                0 /* string table byte count */));

}

// The function writes the start of tag for elements name in the dictionary

// as well as non DTD elements. If the element is in the HTML dictionary then

// ASCII encoding is passed and corresponding token is written the WBXML buffer.

// If it is non dictionary element name then actual encoding is passed and WBXML 

// encoder takes care of this. Note, inside the HTML parser coding is always 

// UCs-2 so it is safe to assume charcount = bytecount/2. 

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_StartTagCB(

  NW_Uint8 byteCount,

  const NW_Uint8* pBuf,

  void* pV, NW_Bool isLiteral)

{

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  TBrowserStatusCode s;

  if(isLiteral == NW_FALSE)

  {

  s = StatusCodeConvert(NW_WBXML_Writer_TagString(pE, HTTP_us_ascii, byteCount,

                                byteCount, (NW_Uint8*)pBuf,

                                &(pTE->lastTagTokenIndex)));

  }

  else

  {

   //

   //For handling the literals or non dictionary elements.

   //

   s = StatusCodeConvert(NW_WBXML_Writer_TagString(pE, HTTP_iso_10646_ucs_2, 

                                                   byteCount/2, byteCount, (NW_Uint8*)pBuf,

                                                   &(pTE->lastTagTokenIndex)));

  }

  if (BRSR_STAT_IS_FAILURE(s)) {

    return s;

  }

  /* default to content but erase if see empty tag end */

  return StatusCodeConvert(NW_WBXML_Writer_TagSetContentFlag(pE, pTE->lastTagTokenIndex));

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_AttributeStartCB(void* pV)

{

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  return StatusCodeConvert(NW_WBXML_Writer_TagSetAttributesFlag(pE, pTE->lastTagTokenIndex));

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_AttributeNameAndValueCB(

  NW_HTMLP_Lexer_t* pL,

  const NW_HTMLP_Interval_t* pI_name,

  NW_Bool missingValue,

  const NW_HTMLP_Interval_t* pI_value,

  void* pV,

  NW_Uint32* cp_cnt)

{

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  NW_Uint32 length;

  NW_Uint32 nameLength;

  NW_Uint8* pName;

  NW_Uint32 valueByteLength;

  NW_Uint32 valueCharCount;

  NW_Uint8* pValue;

  NW_Uint8* pValueCopy = NULL;

  NW_Uint32 i;

  NW_Int32 bytesRead;

  NW_Ucs2 c_ucs2;

  TBrowserStatusCode s;

  if (!NW_HTMLP_Interval_IsWellFormed(pI_name)) {

    return KBrsrFailure;

  }

  /* var name setup */

  length = NW_HTMLP_Interval_ByteCount(pI_name);

  nameLength = length; /* byte count */

  s = NW_HTMLP_Lexer_DataAddressFromBuffer(pL, pI_name->start,

                                           &nameLength, &pName);

  if (BRSR_STAT_IS_FAILURE(s)) {

    return s;

  }

  if (nameLength != length) {

    return KBrsrFailure;

  }

  nameLength = NW_HTMLP_Interval_CharCount(pI_name); /* char count */

  /* force attribute name to lower case for A-Z only,

  this alters the doc in-place */

  /* FUTURE: unfortunately, there is no writeChar to go with the readChar

  so the work around until there is better encoding support is to only

  work with ASCII, 8859-1, UTF-8 and UCS-2.  In these encodings we can

  handle writing because only UCS-2 uses two bytes for an ASCII char. */

  NW_ASSERT((pL->encoding == HTTP_us_ascii)

            || (pL->encoding == HTTP_iso_8859_1)

            || (pL->encoding == HTTP_utf_8)

            || (pL->encoding == HTTP_iso_10646_ucs_2));

  if (!((pL->encoding == HTTP_us_ascii)

        || (pL->encoding == HTTP_iso_8859_1)

        || (pL->encoding == HTTP_utf_8)

        || (pL->encoding == HTTP_iso_10646_ucs_2))) {

    return KBrsrFailure;

  }

  for (i = 0; i < length;) {

    bytesRead = NW_String_readChar(&(pName[i]), &c_ucs2, pL->encoding);

    if (bytesRead == -1) {

      return KBrsrFailure;

    }

    /* force doc ascii uppercase to lowercase */

    if ((c_ucs2 >= (NW_Ucs2)'A') && (c_ucs2 <= (NW_Ucs2)'Z')) {

      c_ucs2 += 0x20; /* offset in ascii from upper to lower */

    }

    if (pL->encoding == HTTP_iso_10646_ucs_2) {

      NW_ASSERT(bytesRead == 2);

      /* accomodate either endianness */

      if (pName[i] == 0) {

        pName[i+1] = (NW_Uint8)c_ucs2;

      } else {

        pName[i] = (NW_Uint8)c_ucs2;

      }

    } else {

      NW_ASSERT(bytesRead == 1);

      NW_ASSERT((pL->encoding == HTTP_us_ascii)

                || (pL->encoding == HTTP_iso_8859_1)

                || (pL->encoding == HTTP_utf_8));

      pName[i] = (NW_Uint8)c_ucs2;

    }

    i += bytesRead;

  }

  /* value setup */

  if (missingValue == NW_TRUE) {

    /* assume this attribute is a boolean and force the value

    to be the same as the attribute name */

    pI_value = pI_name;

  }

  length = NW_HTMLP_Interval_ByteCount(pI_value);

  valueByteLength = length;

  s = NW_HTMLP_Lexer_DataAddressFromBuffer(pL, pI_value->start,

                                           &valueByteLength, &pValue);

  if (BRSR_STAT_IS_FAILURE(s)) {

    return s;

  }

  if (valueByteLength != length) {

    return KBrsrFailure;

  }

  valueCharCount = NW_HTMLP_Interval_CharCount(pI_value);

  if (pL->encoding == HTTP_iso_10646_ucs_2) {

    // in the case that name and value are same thing (e.g "noshade")

    // we have to make an extra copy of pValue, since only pValue needs to 

    // be converted to big endian

    if (pValue == pName)

    {

      pValueCopy = (NW_Byte*)NW_Mem_Malloc(valueByteLength);

      if (pValueCopy == NULL)

        return KBrsrOutOfMemory;

      (void)NW_Mem_memcpy(pValueCopy, pValue, valueByteLength);

      pValue = pValueCopy;

    }

    NW_HTMLP_WbxmlEncoder_Ucs2NativeToNetworkByteOrder(valueByteLength,

                                                       pValue);

  }

  // !!! Note, pValue is epected to be UCS2 and big endian!!!

  //

  // The rest of the code you see around here that checks the encoding is code

  // that has not been cleaned up properly since the conversion to always use

  // UCS2.

  //

  // Make a copy of the value, if it's not already a copy, and remove

  // extraneous CRs and LFs.

  if (!pValueCopy) {

    pValueCopy = (NW_Byte*)NW_Mem_Malloc(valueByteLength);

    if (pValueCopy == NULL)

      return KBrsrOutOfMemory;

    (void)NW_Mem_memcpy(pValueCopy, pValue, valueByteLength);

    pValue = pValueCopy;

  }

  NW_Ucs2* pSrc = (NW_Ucs2*)pValue;

  NW_Ucs2* pDst = pSrc;

  NW_Uint32 newCharCount = 0;

  for (i = 0; i < valueCharCount; i++) {

    c_ucs2 = *pSrc;

    // Check for big endian CRs and LFs.

    if ((c_ucs2 != 0x0d00) && (c_ucs2 != 0x0a00)) {

      *pDst++ = c_ucs2;

      newCharCount++;

    }

    pSrc++;

  }

  valueCharCount = newCharCount;

  // Byte count is always twice the char count since chars are always UCS2.

  valueByteLength = valueCharCount << 1;

  // !!! Note, here we expect pName to be little Endian and pValue to be big endian!!!

  s = StatusCodeConvert(NW_WBXML_Writer_AttributeAndValue2(pE, pTE->encoding, nameLength,

                                        pName, valueCharCount,

                                        valueByteLength, pValue, cp_cnt));

  if (BRSR_STAT_IS_FAILURE(s)) {

    goto finish_attrNameVal;

  }

  if (pL->encoding == HTTP_iso_10646_ucs_2) {

    NW_HTMLP_WbxmlEncoder_Ucs2NetworkToNativeByteOrder(valueByteLength,

                                                       pValue);

  }

  s = KBrsrSuccess;

finish_attrNameVal:

  if (pValueCopy != 0)

    NW_Mem_Free(pValueCopy);

  return s;

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_AttributesEndCB(NW_Uint32 attributeCount,

                                                  void* pV)

{

  NW_HTMLP_WbxmlEncoder_t* pTE = (NW_HTMLP_WbxmlEncoder_t*)pV;

  NW_WBXML_Writer_t* pE = pTE->pE;

  TBrowserStatusCode s = KBrsrSuccess;

  /* if there were any attributes, then must write end token */

  if (attributeCount) {

    s = StatusCodeConvert(NW_WBXML_Writer_End(pE));

    if (BRSR_STAT_IS_FAILURE(s)) {

      return s;

    }

  }

  return s;

}

static

TBrowserStatusCode NW_HTMLP_WbxmlEncoder_CoreTextHandler(NW_Uint32 encoding,

                                                  NW_Uint32 charCount,

                                                  NW_Uint32 byteLength,

                                                  NW_Uint8* pText,

                                                  NW_WBXML_Writer_t* pE)

{

  NW_Uint8* pNormalizedText;

  TBrowserStatusCode s;

  s = NW_HTMLP_WbxmlEncoder_EndOfLineNormalization(encoding,

                                                   &charCount,

                                                   &byteLength,

                                                   pText,

                                                   &pNormalizedText);

  if (BRSR_STAT_IS_FAILURE(s)) {

    return s;

  }

  if (encoding == HTTP_iso_10646_ucs_2) {

    NW_HTMLP_WbxmlEncoder_Ucs2NativeToNetworkByteOrder(byteLength,

                                                       pNormalizedText);