/*

* 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_dom_node.h>

#include <xml/cxml/nw_dom_document.h>

#include <xml/cxml/nw_dom_element.h>

#include <xml/cxml/nw_tinytree.h>

#include <xml/cxml/nw_encoder_wbxmlwriter.h>

#include <xml/cxml/nw_xmlp_xmlp2wbxml.h>

#include <xml/cxml/nw_tinydom_utils.h>

/*#include "nw_parser.h"*/

/************************

* DOCUMENT - NODE Methods

*************************/

EXPORT_C void

NW_DOM_DocumentNode_Delete(NW_DOM_DocumentNode_t* docNode){

  NW_WBXML_Parser_t *wbxmlParser;

  NW_TinyDom_Tree_t *tinyDomTree;

  NW_WBXML_Document_t *document;

  NW_TinyTree_t *tinyTree;

if (docNode == NULL) {

    return;

  }

  tinyTree = NW_TinyTree_Node_findTree(docNode);

  if(tinyTree != NULL){

    document = NW_TinyDom_getDocHeader(tinyTree);

    tinyDomTree = NW_TinyDom_getTree(tinyTree);

    wbxmlParser = tinyDomTree->parser;

    if(wbxmlParser != NULL){

      NW_WBXML_Parser_delete(wbxmlParser);

    }

    if(tinyDomTree != NULL){

      NW_TinyDom_Tree_destruct(tinyDomTree);

    }

    if(document != NULL){

      NW_WBXML_Document_destruct(document);

    }

  }

}

  /* ???? Does the writer need any cleanup ? */

static void

NW_TinyDom_Handle_Initialize(NW_TinyDom_Handle_t *h, 

                             NW_Uint32 default_public_id,

                             NW_Bool extTNotStringTable)

{  

  NW_ASSERT(h != NULL);

  (void) NW_Mem_memset(h, 0, sizeof(*h));

  NW_WBXML_Parser_newInPlace (&(h->wbxmlParser));

  h->wbxmlParser.ext_t_not_table_index =(NW_Uint8)((extTNotStringTable == NW_FALSE)?

                                          CXML_FALSE : CXML_TRUE);

  NW_WBXML_Document_construct(&(h->document), default_public_id);

  NW_TinyDom_Tree_construct (&(h->tinyDOMTree), 

                             &(h->wbxmlParser), 

                             &(h->document), 

                             &(h->writer));

  NW_TinyDom_Parser_construct (&(h->tinyParser), &(h->tinyDOMTree));

}

/* ************************************************************************/

/*

 * Create and populate a dom tree by parsing a buffer, returning the

 * document node.

 */

EXPORT_C

NW_DOM_DocumentNode_t * 

NW_DOM_DocumentNode_BuildWBXMLTree(NW_TinyDom_Handle_t *h, 

                                   NW_Byte *buffer,

                                   NW_Int32 length,

                                   NW_Bool freeBuff,

                                   NW_Bool extTNotStringTable)

{

  NW_Status_t status;

  NW_ASSERT(h != NULL);

  NW_TinyDom_Handle_Initialize(h, 0, extTNotStringTable);

  status = NW_TinyDom_Parser_buildTree (&(h->tinyParser), 

                                        (char *)buffer, 

                                        (NW_Uint32)length,

                                        freeBuff);

  if (status == NW_STAT_SUCCESS) {

    return  h->tinyDOMTree.root_node;

  }

  return NULL;

}

/*

 * This function is same at that of NW_DOM_DocumentNode_BuildWBXMLTree(..)

 * but returns the error code.

 */

static

NW_DOM_DocumentNode_t * 

CXML_DOM_DocumentNode_BuildWBXMLTree(NW_TinyDom_Handle_t *h, 

                                   NW_Byte *buffer,

                                   NW_Int32 length,

                                   NW_Bool freeBuff,

                                   NW_Bool extTNotStringTable,

                                   NW_Status_t* errorStatus)

{

  NW_Status_t status;

  NW_ASSERT(h != NULL);

  NW_TinyDom_Handle_Initialize(h, 0, extTNotStringTable);

  status = NW_TinyDom_Parser_buildTree (&(h->tinyParser), 

                                        (char *)buffer, 

                                        (NW_Uint32)length,

                                        freeBuff);

  if (status == NW_STAT_SUCCESS) 

  {

    *errorStatus = status;

    return  h->tinyDOMTree.root_node;

  }

  *errorStatus = status;

  return NULL;

}

/* Function to copy the string table extension values from the 

 * WBXML encoder to WBXML parser

 */

static NW_Status_t

NW_DOM_Write_WBXML_StrTbl(NW_TinyDom_Handle_t *p, void* WBXMLEncStrTbl)

{

     NW_Status_t status = NW_STAT_SUCCESS;

     NW_Status_t s = NW_STAT_WBXML_ITERATE_DONE;

     NW_Uint32 stringTableByteCount = 0;

     NW_Encoder_StringTableIterator_t strTableIterator;

     NW_Uint8* pLiteralBuf;

     NW_String_t pLiteralStr;

     NW_Uint32 docTableIndex;

     NW_Encoder_StringTable_t* strTable = NULL;

     NW_WBXML_Document_t* doc = &(p->document);

     strTable = (NW_Encoder_StringTable_t*) WBXMLEncStrTbl;

     stringTableByteCount = NW_Encoder_StringTable_getTotalBytes(strTable);

     if(stringTableByteCount > 0)

     {

        /*The following function always return success so why bother to check? */

        NW_Encoder_StringTable_StringTableIterateInit(WBXMLEncStrTbl,&strTableIterator);

        s =  NW_Encoder_StringTable_StringTableIterateNext

                    (&strTableIterator,&stringTableByteCount,&pLiteralBuf);

        while(s == NW_STAT_WBXML_ITERATE_MORE)

        {

         pLiteralStr.length = stringTableByteCount;

         pLiteralStr.storage = pLiteralBuf;

         status =  NW_WBXML_Document_putTableString(doc,&pLiteralStr,&docTableIndex) ;

         if(status != NW_STAT_SUCCESS)

         {

          break;

         }

           s =  NW_Encoder_StringTable_StringTableIterateNext

                    (&strTableIterator,&stringTableByteCount,&pLiteralBuf) ;

        }/*end while */

     }/*end if(stringTableByteCount > 0)*/

     //Delete the tree

     NW_Encoder_StringTable_delete(WBXMLEncStrTbl);

     WBXMLEncStrTbl = NULL;

 return status;

}/*end NW_DOM_Write_WBXML_StrTbl()*/

static

NW_DOM_DocumentNode_t*

NW_DOM_DocumentNode_BuildXMLTree(NW_TinyDom_Handle_t *h, 

                                 NW_Byte *buffer,

                                 NW_Int32 length,

                                 NW_Uint32 publicID,

                                 NW_Bool extTNotStringTable)

{

  NW_Buffer_t inBuff;

  NW_Buffer_t *outBuff = NULL;

  NW_Uint32 encoding;

  NW_Endianness_t endianness;

  NW_DOM_DocumentNode_t* docNode;

  NW_Status_t status;

  NW_Uint32 line;

  void* WBXMLEncStrTbl;

  inBuff.length = length;

  inBuff.data = buffer;

  status = NW_XML_ComputeEncoding(length, 

                                  buffer,

                                  &encoding, 

                                  &endianness);

  if(status != NW_STAT_SUCCESS){

    return NULL;

  }

/*

 * If applications want to use HTML Parser they can call the exported

 * NW_HTMLP_HtmlToWbxml() and then call NW_DOM_DocumentNode_BuildWBXMLTree()

 */

  status = NW_XML_XmlToWbxml(&inBuff, encoding, &outBuff, &line, publicID,&WBXMLEncStrTbl); 

  if(status != NW_STAT_SUCCESS){

    if(outBuff != NULL){

      NW_Mem_Free(outBuff);

    }

    return NULL;

  }

  docNode = NW_DOM_DocumentNode_BuildWBXMLTree(h, 

                                              outBuff->data,

                                              outBuff->length,

                                              NW_TRUE,

                                              extTNotStringTable);

  /* Write extension string table related information to the WBXML encoder. */

  if( docNode && WBXMLEncStrTbl)

    {

     status = NW_DOM_Write_WBXML_StrTbl(h,WBXMLEncStrTbl);

     if(status != NW_STAT_SUCCESS)

     {

       if(outBuff != NULL)

       {

         NW_Mem_Free(outBuff);

       }

     }

    }/* end if(WBXMLEncStrTbl)*/

  NW_Mem_Free(outBuff);

  return docNode;

}

static

NW_DOM_DocumentNode_t*

CXML_DOM_DocumentNode_BuildXMLTree(NW_TinyDom_Handle_t *h, 

                                 NW_Byte *buffer,

                                 NW_Int32 length,

                                 NW_Uint32 publicID,

                                 NW_Bool extTNotStringTable,

                                 NW_Status_t* errorStatus)

{

  NW_Buffer_t inBuff;

  NW_Buffer_t *outBuff = NULL;

  NW_Uint32 encoding;

  NW_Endianness_t endianness;

  NW_DOM_DocumentNode_t* docNode;

  NW_Status_t status;

  NW_Uint32 line;

  void* WBXMLEncStrTbl;

  inBuff.length = length;

  inBuff.data = buffer;

  status = NW_XML_ComputeEncoding(length, 

                                  buffer,

                                  &encoding, 

                                  &endianness);

  if(status != NW_STAT_SUCCESS)

  {

    *errorStatus = status;

    return NULL;

  }

/*

 * If applications want to use HTML Parser they can call the exported

 * NW_HTMLP_HtmlToWbxml() and then call NW_DOM_DocumentNode_BuildWBXMLTree()

 */

  status = NW_XML_XmlToWbxml(&inBuff, encoding, &outBuff, &line, publicID,&WBXMLEncStrTbl); 

  if(status != NW_STAT_SUCCESS){

    if(outBuff != NULL){

      NW_Mem_Free(outBuff);

    }

    *errorStatus = status;

    return NULL;

  }

  docNode = CXML_DOM_DocumentNode_BuildWBXMLTree(h, 

                                              outBuff->data,

                                              outBuff->length,

                                              NW_TRUE,

                                              extTNotStringTable,

                                              errorStatus);

  /* Write extension string table related information to the WBXML encoder. */

  if( docNode && WBXMLEncStrTbl)

    {

     status = NW_DOM_Write_WBXML_StrTbl(h,WBXMLEncStrTbl);

     if(status != NW_STAT_SUCCESS)

     {

       if(outBuff != NULL)

       {

         NW_Mem_Free(outBuff);

       }

       *errorStatus = status;

     }

    }/* end if(WBXMLEncStrTbl)*/

  NW_Mem_Free(outBuff);

  return docNode;

}/*CXML_DOM_DocumentNode_BuildXMLTree() */

EXPORT_C NW_DOM_DocumentNode_t*

NW_DOM_DocumentNode_BuildTree(NW_TinyDom_Handle_t *h, 

                                   NW_Byte *buffer,

                                   NW_Int32 length,

                                   NW_Bool encoded,

                                   NW_Uint32 publicID,																	 

                                   NW_Bool extTNotStringTable)

{

  if(encoded == NW_TRUE){

    return  NW_DOM_DocumentNode_BuildWBXMLTree(h, 

                                               buffer,

                                               length,

                                               NW_FALSE,

                                               extTNotStringTable);

  }

  return NW_DOM_DocumentNode_BuildXMLTree(h,buffer, length, publicID, extTNotStringTable);

}

/*

 * Returns publicId of the document (WBXML Specific)

 * otherwise 0

 */

EXPORT_C NW_Uint32 

NW_DOM_DocumentNode_getPublicIdAsNumber(NW_DOM_DocumentNode_t *doc)

{

  NW_WBXML_Document_t *header;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(doc != NULL);

  if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

    return 0;

  }

  tiny_tree = NW_TinyTree_Node_findTree(doc);

  header = NW_TinyDom_getDocHeader(tiny_tree);

  NW_ASSERT(header != NULL);

  return header->publicid;

}

/*

 * Gets the publicid as string

 * Returns

 *    NW_STAT_DOM_NODE_TYPE_ERR

 *    NW_STAT_SUCCESS

 * MODIFIED - docType

 */

EXPORT_C NW_Status_t

NW_DOM_DocumentNode_getPublicId(NW_DOM_DocumentNode_t *doc, 

                                NW_String_t *docType)

{

  NW_WBXML_Document_t *header;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(doc != NULL);

  NW_ASSERT(docType != NULL);

  if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE)

    return NW_STAT_DOM_NODE_TYPE_ERR;

  tiny_tree = NW_TinyTree_Node_findTree(doc);

  header = NW_TinyDom_getDocHeader(tiny_tree);

  NW_ASSERT(header != NULL);

  NW_String_shallowCopy(docType, header->doc_type);

  return NW_STAT_SUCCESS;

}

/*

 * Returns the version of the document, 

 * 0 in case of invalid operation (e.g. NULL doc)

 */

EXPORT_C NW_Uint8 

NW_DOM_DocumentNode_getVersion(NW_DOM_DocumentNode_t *doc)

{

  NW_WBXML_Document_t *header;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(doc != NULL); 

  if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

    return 0;

  }

  tiny_tree = NW_TinyTree_Node_findTree(doc);

  header = NW_TinyDom_getDocHeader(tiny_tree);

  NW_ASSERT(header != NULL);

  return header->version;

}

/*

 * Returns the supported encoding of the document

 * or 0 for invalid document

 */

EXPORT_C NW_Uint32 

NW_DOM_DocumentNode_getCharacterEncoding(NW_DOM_DocumentNode_t *doc)

{

  NW_WBXML_Document_t *header;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(doc != NULL); 

  if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE)

    return 0;

  tiny_tree = NW_TinyTree_Node_findTree(doc);

  header = NW_TinyDom_getDocHeader(tiny_tree);

  NW_ASSERT(header != NULL);

  return header->charset;

}

/*

 * Returns child node that is the root of this document

 */

EXPORT_C NW_DOM_ElementNode_t * 

NW_DOM_DocumentNode_getDocumentElement(NW_DOM_DocumentNode_t *doc)

{

  NW_DOM_Node_t *docChild;

  NW_Uint16 type;

  NW_ASSERT(doc != NULL); 

  if (NW_DOM_Node_getNodeType(doc) != NW_DOM_DOCUMENT_NODE){

    return NULL;

  }

  /*

   * Get the first child of the document node

   * (can be a PI node)

   */

  docChild = NW_DOM_Node_getFirstChild(doc);

  type = NW_DOM_Node_getNodeType(docChild);    

  if (type == 0){

    return NULL;

  }

  while (type != NW_DOM_ELEMENT_NODE){

    docChild = NW_DOM_Node_getNextSibling(docChild);

    type = NW_DOM_Node_getNodeType(docChild);

  }

  return docChild;

}

/*

 * Gets the dictionary

 */

EXPORT_C NW_WBXML_Dictionary_t *

NW_DOM_DocumentNode_getDictionary(NW_DOM_DocumentNode_t *doc)

{

  NW_Uint32 publicid = 0;

  NW_Uint32 encoding;

  NW_WBXML_Dictionary_t *dictionary = NULL;

  NW_Status_t status;

  NW_ASSERT(doc != NULL);

  encoding = NW_DOM_DocumentNode_getCharacterEncoding(doc);

  publicid = NW_DOM_DocumentNode_getPublicIdAsNumber(doc);

  if (publicid != 0){