/*

* 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 "cxml_internal.h"

#include <xml/cxml/nw_wbxml_token.h>

#include <xml/cxml/nw_encoder_wbxmlwriter.h>

#include <xml/cxml/nw_wbxml_parse.h>

#include "cxml_mem.h"

// WLIU_DEBUG: #include "flogger.h"

  /* a reserved name used for encoding tags and attributes that

otherwise aren't in the dictionaries. zzzunknown must be in the

dictionary for both tag names and attribute names */

#define zzzunknownCharCount 10

static const NW_Uint8 zzzunknown[] = {'z','z','z','u','n','k','n','o','w','n','\0'};

#define zzzunknownEncoding HTTP_utf_8

static

NW_Status_t

NW_WBXML_Writer_Memcpy(NW_WBXML_Writer_t* pW, const NW_Uint8* pBytes,

                       NW_Uint32 writeLength)

{

  NW_Status_t s = NW_STAT_SUCCESS;

  if (writeLength == 0) {

    return NW_STAT_FAILURE;

  }

  if (!pW->sizing) {

    if (((pW->index + writeLength - 1) >= pW->byteCount)

        && (pW->growBufCallback != NULL)) {

      /* try to grow buf */

      s = (*pW->growBufCallback)(pW, writeLength);

      if (NW_STAT_IS_FAILURE(s)) {

        return s;

      }

    }

    if ((pW->index + writeLength - 1) >= pW->byteCount) {

      /* grow buf unavailable or didn't alloc enough */

      return NW_STAT_OUT_OF_MEMORY;

    }

    NW_Mem_memcpy(pW->pBuf + pW->index, pBytes, writeLength);

  }

  pW->index += writeLength;

  return s;

}

typedef struct NW_WBXML_Multibyte_s {

  NW_Uint8 length; /* encoded length in bytes from 1..5 */

  NW_Uint8 buf[5];

} NW_WBXML_Multibyte_t;

/* see the WBXML specification for the definition of this function */

static

void

NW_WBXML_EncodeMultibyte(NW_Uint32 x, NW_WBXML_Multibyte_t* pM)

{

  NW_Uint8 i;

  NW_Uint8 littleEndian[5];

  littleEndian[0] = (NW_Uint8)(x & 0x7f);

  for (i = 1; i < 5; i++) {

    x >>= 7; /* unsigned x, no sign extension */

    littleEndian[i] = (NW_Uint8)(x & 0x7f);

    if (!x) {

      break;

    }

  }

  pM->length = i;

  for (i = 0; i < pM->length; i++) {

    pM->buf[i] = littleEndian[pM->length - 1 - i];

    if ((i + 1) < pM->length) {

      pM->buf[i] |= 0x80;

    }

  }

}

static

NW_Status_t

NW_WBXML_Writer_Multibyte(NW_WBXML_Writer_t* pW, NW_Uint32 x)

{

  NW_WBXML_Multibyte_t multibyte;

  NW_WBXML_EncodeMultibyte(x, &multibyte);

  return NW_WBXML_Writer_Memcpy(pW, multibyte.buf,

                                multibyte.length);

}

typedef enum {

    NW_WBXML_TAG,

    NW_WBXML_ATTRIBUTE

} NW_WBXML_Writer_ItemType;

static

NW_Status_t

NW_WBXML_Writer_MaybeSwitchPage(NW_WBXML_Writer_t* pW, NW_Uint8 page,

                                NW_WBXML_Writer_ItemType itemType,

                                NW_Bool* switched)

{

  NW_Status_t s = NW_STAT_SUCCESS;

  NW_Uint8 token = NW_WBXML_SWITCH_PAGE; /* global so on all code pages */

  NW_Bool changePage = 0;

  *switched = NW_FALSE;

  switch (itemType) {

  case NW_WBXML_TAG:

    changePage = (NW_Bool)(page != pW->tagCodePage);

    if (changePage) {

      pW->tagCodePage = page;

      // WLIU_DEBUG: pW->cp_count++;

    }

    break;

  case NW_WBXML_ATTRIBUTE:

    changePage = (NW_Bool)(page != pW->attributeCodePage);

    if (changePage) {

      pW->attributeCodePage = page;

      // WLIU_DEBUG: pW->cp_count++;

    }

    break;

  default:

    s = NW_STAT_FAILURE;

    break;

  }

  if (changePage) { 

    s = NW_WBXML_Writer_Memcpy(pW, &token, 1);

    // WLIU_DEBUG: RFileLogger::WriteFormat(_L("Browser"), _L("cp_count.txt"), EFileLoggingModeAppend, _L("=== cp_count: %x, pW->index: %x \n"), pW->cp_count, pW->index);

    if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

    s = NW_WBXML_Writer_Memcpy(pW, &page, 1);

        if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

    *switched = NW_TRUE;

  }

  return s;

}

EXPORT_C

NW_Status_t

NW_WBXML_Writer_Header(NW_WBXML_Writer_t* pW, NW_Uint8 WBXMLVersion,

                       NW_Uint32 publicIdentifier, NW_Uint32 charsetMIBEnum,

                       NW_Uint32 stringTableByteCount)

{

  NW_Status_t s;

  NW_Uint32 byteCount;

  NW_Uint8* pBuf;

  NW_Encoder_StringTableIterator_t strTableIterator;

  /* header = version publicid charset stringtable */

  s = NW_WBXML_Writer_Memcpy(pW, &WBXMLVersion, 1);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  s = NW_WBXML_Writer_Multibyte(pW, publicIdentifier);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  s = NW_WBXML_Writer_Multibyte(pW, charsetMIBEnum);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  s = NW_WBXML_Writer_Multibyte(pW, stringTableByteCount);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  if (stringTableByteCount) {

    NW_ASSERT(pW->stringTableIterateInit);

    NW_ASSERT(pW->stringTableIterateNext);

    s = (*(pW->stringTableIterateInit))(pW->pStringTableObject,

                                        &strTableIterator);

    if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

    s = (*(pW->stringTableIterateNext))(&strTableIterator,

                                        &byteCount, &pBuf);

    while (s == NW_STAT_WBXML_ITERATE_MORE){

      s = NW_WBXML_Writer_Memcpy(pW, pBuf, byteCount);

      if (s != NW_STAT_SUCCESS){

        return s;

      }

      s = (*(pW->stringTableIterateNext))(&strTableIterator,

                                          &byteCount, &pBuf);

    }

    if (s != NW_STAT_WBXML_ITERATE_DONE){

      return NW_STAT_FAILURE;

    }

  }

  return NW_STAT_SUCCESS;

}

/* if boolean "set" is 1 then "or" with mask, else "and" with ~mask */

static

NW_Status_t

NW_WBXML_Writer_TagFlagOp(NW_WBXML_Writer_t* pW, NW_Uint32 index,

                          NW_Uint8 mask, NW_Bool set)

{

  NW_Status_t s = NW_STAT_SUCCESS;

  if (!pW->sizing) {

    if (index < pW->byteCount) {

      if (set) {

        (pW->pBuf)[index] |= mask;

      } else {

        (pW->pBuf)[index] &= ~mask;

      }

    } else {

      s = NW_STAT_FAILURE;

    }

  }

  return s;

}

EXPORT_C

NW_Status_t

NW_WBXML_Writer_TagSetContentFlag(NW_WBXML_Writer_t* pW, NW_Uint32 index)

{

  return NW_WBXML_Writer_TagFlagOp(pW, index, NW_WBXML_FLAGS_CONTENT, 1);

}

EXPORT_C

NW_Status_t

NW_WBXML_Writer_TagClearContentFlag(NW_WBXML_Writer_t* pW, NW_Uint32 index)

{

  return NW_WBXML_Writer_TagFlagOp(pW, index, NW_WBXML_FLAGS_CONTENT, 0);

}

EXPORT_C

NW_Status_t

NW_WBXML_Writer_TagSetAttributesFlag(NW_WBXML_Writer_t* pW, NW_Uint32 index)

{

  return NW_WBXML_Writer_TagFlagOp(pW, index, NW_WBXML_FLAGS_ATTRIBUTES, 1);

}

NW_Status_t

NW_WBXML_Writer_TagClearAttributesFlag(NW_WBXML_Writer_t* pW, NW_Uint32 index)

{

  return NW_WBXML_Writer_TagFlagOp(pW, index, NW_WBXML_FLAGS_ATTRIBUTES, 0);

}

NW_Status_t

NW_WBXML_Writer_TagToken(NW_WBXML_Writer_t* pW, NW_Uint16 fqToken,

                    NW_Uint32* pTagIndex)

{

  NW_Status_t s;

  NW_Uint8 token;

  NW_Uint8 page;

  NW_Bool  switched = NW_FALSE;

  token = NW_WBXML_Dictionary_extractToken(fqToken);

  page =  NW_WBXML_Dictionary_extractPage(fqToken);

  s = NW_WBXML_Writer_MaybeSwitchPage(pW, page, NW_WBXML_TAG, &switched);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  *pTagIndex = pW->index;

  return NW_WBXML_Writer_Memcpy(pW, &token, 1); /* tag token */

  }

static

NW_Status_t

NW_WBXML_Writer_Literal(NW_WBXML_Writer_t* pW, NW_Uint32 stringTableIndex)

  {

  NW_Status_t s;

  /* global in WBXML spec, so on all code pages */

  static const NW_Uint8 literalToken = NW_WBXML_LITERAL;

  s = NW_WBXML_Writer_Memcpy(pW, &literalToken, 1);

    if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

  return NW_WBXML_Writer_Multibyte(pW, stringTableIndex);

  }

/* This function will write to the extension string Table. The buffer

 * "pBuf" is not NULL terminated. This can handle any type of encoding.

 */

static

NW_Status_t

NW_WBXML_Writer_StringTableLiteral2(NW_WBXML_Writer_t* pW,

                                   NW_Uint32 charCount,

                                   const NW_Uint8* pBuf,

                                   NW_Uint32 encoding)

{

 NW_Uint32 byteCount = 0;

 NW_Uint32 totalByteCount = 0;

 NW_Ucs2 c;

 NW_Uint32 numbytes;

 NW_Uint8* literalName = NULL;

 NW_Status_t s = NW_STAT_SUCCESS;

 NW_Uint32 i =0;

 NW_Uint32 tableIndex = 0;

 if(pBuf == NULL)

 {

  return NW_STAT_BAD_INPUT_PARAM;

 }

 if (pW->addToStringTable != NULL) 

   {

   /*

    * pBuf is not NULL terminated. So, need to use the following method.

    */

    numbytes = NW_String_readChar( (NW_Byte*) pBuf,&c,encoding);

   /* Calculate the length of string. Also add the number of characters 

    * required for the NULL termination.

    */

    byteCount = (numbytes * charCount) ;

    totalByteCount = byteCount + numbytes;

    literalName = (NW_Uint8*) NW_Mem_Malloc(totalByteCount);

    if (literalName != NULL) 

     {

      (void)NW_Mem_memcpy(literalName, pBuf, byteCount );

       for(i=0; i < numbytes; i++)

       {

        literalName[byteCount+i] = '\0';

       }

       /* During the PASS -1, the Literal is also added to the string table

        * so the correct index of Literal can be found. The index of the literal

        * is written in the WBXML buffer. The index is UINT 32 so (index = 01) and

        * (index == 0x80) is encoded differently in the WBXML integer encoding. So, 

        * string table function calculates the correct index. So, the calling function

        * should free the string table after PASS-1. Currently, PASS-1 and PASS-2 is 

        * used in the XML parser only.

        */

       s = (*pW->addToStringTable)(pW->pStringTableObject,

                                    totalByteCount, literalName,

                                    &tableIndex);

      if (NW_STAT_IS_SUCCESS(s))

      {

       s = NW_WBXML_Writer_Literal(pW,tableIndex);

       if(literalName != NULL)

       {

        NW_Mem_Free(literalName);

       }

      }

     }/*end if (literalName != NULL) */

     else

     {

      s = NW_STAT_OUT_OF_MEMORY;

     }

 } /*end if(pW->addToStringTable != NULL)*/

return s;

}/* NW_WBXML_Writer_StringTableLiteral2(..) */

/* Examine the out parameter *pFound to see if the string was found in

the string table.  If it wasn't found, then it can't be written as a literal

in WBXML.  A failure return code means something else went wrong. The key

part of this function is that it just queries the string table and doesn't

try to force the string to be added to the string table. */

static

NW_Status_t

NW_WBXML_Writer_StringTableLiteral(NW_WBXML_Writer_t* pW,

                                   NW_Uint32 byteCount,

                                   const NW_Uint8* pBuf,

                                   NW_Bool* pFound)

{

  NW_Status_t s;

  NW_Uint32 tableIndex = 0;

  *pFound = 0;

  if (pW->getStringTableOffset) {

    s = (*pW->getStringTableOffset)(pW->pStringTableObject,

                                    byteCount, pBuf,

                                    pFound, &tableIndex);

    if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

  }

  if (*pFound) {

    /* global, so on all code pages */

    static const NW_Uint8 tableRefToken = NW_WBXML_STR_T;

    s = NW_WBXML_Writer_Memcpy(pW, &tableRefToken, 1);

    if (NW_STAT_IS_FAILURE(s)) {

      return s;

    }

    return NW_WBXML_Writer_Multibyte(pW, tableIndex);

  }

  /* *pFound indicates whether the string table entry was found so

     we return success */

  return NW_STAT_SUCCESS;

}

/* charCount should not include null termination character if any exists */

EXPORT_C

NW_Status_t

NW_WBXML_Writer_TagString(NW_WBXML_Writer_t* pW, NW_Uint32 encoding,

                          NW_Uint32 charCount, NW_Uint32 byteCount,

                          NW_Uint8* pBuf, NW_Uint32* pTagIndex)

{

  NW_Status_t s;

  NW_Uint16 fqToken;

  (void) byteCount;

  /* try token */

  s = NW_WBXML_Dictionary_getTagToken2(pW->pTagDictionary, encoding,

                                       charCount, pBuf, &fqToken);

  if (NW_STAT_IS_SUCCESS(s)) {

    return NW_WBXML_Writer_TagToken(pW, fqToken, pTagIndex);

  }

  /* try string table reference */

  if (pW->addToStringTable != NULL)

  {

    *pTagIndex = pW->index;

    s = NW_WBXML_Writer_StringTableLiteral2(pW, charCount, pBuf, encoding);

    // Return on success or failure (out of memory, etc.) except

    // NW_STAT_STR_TBL_OVERFLOW.

    if (s != NW_STAT_STR_TBL_OVERFLOW)

    {

      return s;

    }

  }

  /* no token, not in string table...try to encode as the unknown tag */

  s = NW_WBXML_Dictionary_getTagToken2(pW->pTagDictionary, zzzunknownEncoding,

                                       zzzunknownCharCount,

                                       (NW_Uint8*)&zzzunknown[0],

                                       &fqToken);

  if (NW_STAT_IS_SUCCESS(s)) 

  {

   return NW_WBXML_Writer_TagToken(pW, fqToken, pTagIndex);

  }

  /* getting here means no token, no string table entry

  and the reserved unknown tag is missing from the dictionary */

  NW_ASSERT(s == NW_STAT_SUCCESS); /* force error to be caught here */

  return s;

}

static

NW_Status_t

NW_WBXML_Writer_InlineString(NW_WBXML_Writer_t* pW,

                             NW_Uint32 encoding,

                             NW_Uint32 byteCount,

                             const NW_Uint8* pTextIn)

{

  NW_Uint8* pTextOut = (NW_Uint8*)pTextIn; /* default */

  NW_Status_t s;

  NW_Bool nullTerminated;

  NW_Uint8 token = NW_WBXML_STR_I; /* global so on all code pages */

  nullTerminated = NW_FALSE;

  s = NW_WBXML_Writer_Memcpy(pW, &token, 1);

  if (NW_STAT_IS_FAILURE(s)) {

    if (pTextOut != pTextIn) {

      NW_Mem_Free(pTextOut);

    }

    return s;

  }

  s = NW_WBXML_Writer_Memcpy(pW, pTextOut, byteCount);

  if (NW_STAT_IS_FAILURE(s)) {

    if (pTextOut != pTextIn) {

      NW_Mem_Free(pTextOut);

    }

    return s;

  }

  if (pTextOut != pTextIn) {

    NW_Mem_Free(pTextOut);

  }

  /* test string to see if written bytes are already null terminated */

  /* FUTURE MISSING UTILITY SUPPORT

  this char encoding API isn't implemented yet

  NW_Char_SimpleString_t n;

  s = NW_CharEncoding_nullTermination(encoding, &n);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  test if null termination already written and if not...

  s = NW_WBXML_Writer_Memcpy(pW, n.buf, n.byteCount);

  if (NW_STAT_IS_FAILURE(s)) {

    return s;

  }

  */

  /* BUG HACK BEGIN

  Should not assume null termination missing but this works

  with the XMLP client.  Remove this when char encoding

  null termination utility support is available */

  if (encoding == HTTP_iso_10646_ucs_2){

    /* just look for any 1 bits in the UCS2 char */

    NW_Uint8 lastChar = (pTextIn + byteCount)[-1];

    lastChar |= (pTextIn + byteCount)[-2];

    if (lastChar == 0){

      nullTerminated = NW_TRUE;

    }

  }

  else if ((encoding == HTTP_iso_8859_1) ||

            (encoding == HTTP_utf_8) ||

            (encoding == HTTP_us_ascii))

  {