/*

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

#include <xml/cxml/nw_dom_attribute.h>

#include <xml/cxml/nw_dom_document.h>

#include <xml/cxml/nw_wbxml_dictionary.h>

/* 

 * Returns

 *  NW_STAT_DOM_NODE_TYPE_ERR - if it is not an Element Node

 *  NW_STAT_OUT_OF_MEMORY

 *  NW_STAT_DOM_NO_STRING_RETURNED

 *  NW_STAT_SUCCESS  

 *

 * MODIFIED name (of the element)

 */

EXPORT_C NW_Status_t

NW_DOM_ElementNode_getTagName(NW_DOM_ElementNode_t *elem, 

                              NW_String_t *name)

{

  NW_DOM_DocumentNode_t *docNode;

  NW_Uint32 encoding;

  NW_Status_t status;

  NW_Uint32 token;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(elem != NULL);

  NW_ASSERT(name != NULL);

  if (NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE){

    return NW_STAT_DOM_NODE_TYPE_ERR;

  }

  /*

   * Following method will return name if the node is XML type

   * or it is a literal tag

   */

  tiny_tree = NW_TinyTree_Node_findTree(elem);

  status = NW_TinyDom_getTagName(NW_TinyDom_getParser(tiny_tree), elem, name);

  if (status == NW_STAT_SUCCESS){

    return NW_STAT_SUCCESS;

  }

  /* No string returned means that getTagName succeeded but

   * didn't find a literal name . . .

   */

  if (status != NW_STAT_WBXML_NO_NAME){

    return NW_STAT_DOM_NO_STRING_RETURNED;

  }

  /* . . . so we try to get a name from dictionary */

  docNode = NW_DOM_Node_getOwnerDocument(elem);

  encoding = NW_DOM_DocumentNode_getCharacterEncoding(docNode);  

  token = NW_TinyDom_getTagToken(NW_TinyDom_getParser(tiny_tree), elem);

  return NW_String_tokenToString(token, name, encoding);

}

/*

 * Returns the fully qualified token for the node

 */

EXPORT_C NW_Uint16 

NW_DOM_ElementNode_getTagToken(NW_DOM_ElementNode_t *elem)

{

  NW_Uint16 type;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(elem != NULL);

  type = NW_TinyDom_Node_getType(elem);

  if (type != NW_DOM_ELEMENT_NODE){

    return 0;

  }

  tiny_tree = NW_TinyTree_Node_findTree(elem);  

  if (elem->token == 0)

  {

      elem->token = 

        (NW_Uint16)NW_TinyDom_getTagToken(NW_TinyDom_getParser(tiny_tree), elem);

    /*  if (NW_DOM_Node_hasChildNodes(elem)){

        token |= NW_WBXML_FLAGS_CONTENT;

      }

      if (NW_DOM_ElementNode_hasAttributes(elem)){

        token |= NW_WBXML_FLAGS_ATTRIBUTES;

      }

      elem->token = token;*/

  }

  return (NW_Uint16)(elem->token & 0xff3f);

}

/* 

 * Returns

 *  NW_STAT_DOM_NODE_TYPE_ERR

 *  NW_STAT_NOT_FOUND - if attribute is not found

 *  NW_STAT_DOM_NO_STRING_RETURNED

 *  NW_STAT_SUCCESS

 *

 * This method returns attribute value as string

 * IN - attributeName - name of attribute

 * MODIFIED - attributeValue 

Note: The passed in argument "attributeName" must be given as aligned,

native byte order, null terminated, UCS-2.  The reason is that clients

wish to process documents in various encodings but they don't want to

have to convert element and attribute names which are program constants

into whatever charset the document appears in.

 */

EXPORT_C NW_Status_t

NW_DOM_ElementNode_getAttribute(

  NW_DOM_ElementNode_t *elem, 

  NW_String_t *attributeName, 

  NW_String_t *attributeValue)

{

  NW_DOM_AttributeHandle_t attributeHandle;

  NW_Status_t status;

  NW_ASSERT(elem != NULL);

  NW_ASSERT(attributeName != NULL);

  NW_ASSERT(attributeValue != NULL);

  if ((NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE)

      && (NW_DOM_Node_getNodeType(elem) != NW_DOM_PROCESSING_INSTRUCTION_NODE)) {

    return NW_STAT_DOM_NODE_TYPE_ERR;

  }

  status = NW_DOM_ElementNode_getAttributeHandleByName(elem, 

                                                       attributeName, 

                                                       &attributeHandle);

  if (status != NW_STAT_SUCCESS){ 

    return status;

  }

  return NW_DOM_AttributeHandle_getValue(&attributeHandle, attributeValue);

}

/*

 * Returns NW_TRUE if element has attributes, otherwise NW_FALSE

 */

EXPORT_C NW_Bool

NW_DOM_ElementNode_hasAttributes(NW_DOM_ElementNode_t *elem)

{

  NW_DOM_Node_t *child;

  NW_ASSERT(elem != NULL);

  if ((NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE)

      && (NW_DOM_Node_getNodeType(elem) != NW_DOM_PROCESSING_INSTRUCTION_NODE))

  {

    return NW_FALSE;

  }

  child = NW_TinyTree_findFirstChild(elem);

  while(child){

    if (NW_TinyDom_Node_getType(child) == T_DOM_NODE_ATTR){

      return NW_TRUE;

    }

    child = NW_TinyTree_findNextSibling(child);

  }

  return NW_FALSE;

}

/*

 * Returns

 *         NW_STAT_DOM_NODE_TYPE_ERR

 *         NW_STAT_SUCCESS

 * MODIFIED iterator

 * WAP-adapted DOM extension

 */

EXPORT_C NW_Status_t 

NW_DOM_ElementNode_getAttributeListIterator(NW_DOM_Node_t *node, 

                                            NW_DOM_AttributeListIterator_t 

                                            *iterator)

{

  NW_DOM_Node_t *child;

  NW_TinyTree_t *tiny_tree;

  NW_ASSERT(node != NULL);

  NW_ASSERT(iterator != NULL);

  if ((NW_DOM_Node_getNodeType(node) != NW_DOM_ELEMENT_NODE)

      && (NW_DOM_Node_getNodeType(node) != NW_DOM_PROCESSING_INSTRUCTION_NODE))

  {

    return NW_STAT_DOM_NODE_TYPE_ERR;

  }

  tiny_tree = NW_TinyTree_Node_findTree(node);

  (void) NW_DOM_AttributeListIterator_initialize(iterator);

  child = NW_TinyTree_findFirstChild(node);

  iterator->node = child;

  if(child){

    if (NW_TinyDom_Node_getType(child) == T_DOM_NODE_ATTR){

      NW_TinyDom_AttrListHandle_init(&iterator->attrListHandle, 

                                     NW_TinyDom_getParser(tiny_tree), 

                                     child);

      return NW_STAT_SUCCESS;

    }

    child = NW_TinyTree_findNextSibling(child);

    while (child){

      if (NW_TinyDom_Node_getType(child) == T_DOM_NODE_ATTR){

        NW_TinyDom_AttrListHandle_init(&iterator->attrListHandle, 

                                     NW_TinyDom_getParser(tiny_tree), 

                                     child);

        return NW_STAT_SUCCESS;

      }

      child = NW_TinyTree_findNextSibling(child);

    }

  }

  return NW_STAT_NOT_FOUND;

}

/* 

 * Returns

 *  NW_STAT_DOM_NODE_TYPE_ERR

 *  NW_STAT_NOT_FOUND - if attribute is not found

 *  NW_STAT_SUCCESS

 *

 * IN - attributeName

 * MODIFIED - handle

 */

EXPORT_C NW_Status_t

NW_DOM_ElementNode_getAttributeHandleByName(NW_DOM_ElementNode_t *elem,

                                            NW_String_t *attributeName,

                                            NW_DOM_AttributeHandle_t

                                            *attributeHandle)

{

  NW_Status_t nwStatus;

  NW_Status_t status;

  NW_DOM_AttributeListIterator_t attrListIterator;

  NW_Bool attributeFound = NW_FALSE;

  NW_String_t currentName;

  NW_Uint32 docEncoding;

  NW_Int32 charCount;

  NW_Uint32 byteCount = 0;

  NW_Int32 cmpResult;

  NW_ASSERT(elem != NULL);

  NW_ASSERT(attributeHandle != NULL);

  NW_ASSERT(attributeName != NULL);

  if ((NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE)

      && (NW_DOM_Node_getNodeType(elem) != NW_DOM_PROCESSING_INSTRUCTION_NODE))

  {

    return NW_STAT_DOM_NODE_TYPE_ERR;

  }

  if (!NW_DOM_ElementNode_hasAttributes(elem)){

    return NW_STAT_NOT_FOUND;

  }

  /* Initialize the handle */

  status =

  NW_DOM_ElementNode_getAttributeListIterator(elem, &attrListIterator);

  if (status != NW_STAT_SUCCESS){

    return status;

  }

  while (!attributeFound){

    if (NW_DOM_AttributeListIterator_getNextAttribute(&attrListIterator,

                                                      attributeHandle)

        == NW_STAT_WBXML_ITERATE_DONE){

      return NW_STAT_NOT_FOUND;

    }

    status = NW_DOM_AttributeHandle_getName(attributeHandle, &currentName);

    if (status != NW_STAT_SUCCESS){

      continue;

    }

    docEncoding = NW_DOM_AttributeHandle_getEncoding (attributeHandle);

    charCount = NW_String_charBuffGetLength(currentName.storage, docEncoding,

                                            &byteCount);

    if (charCount < 0) {

      return NW_STAT_FAILURE;

    }

    nwStatus = NW_String_CmpToNativeAlignedUCS2(docEncoding, (NW_Uint32) charCount,

                                                currentName.storage,

                                                (NW_Uint16*)(attributeName->storage),

                                                &cmpResult);

    NW_String_deleteStorage(&currentName);

    if (NW_STAT_IS_FAILURE(nwStatus)){

      continue;

    }

    if (cmpResult == 0){

      attributeFound = NW_TRUE;

    }

  }

  /* Proceed: Attribute Found */

  /* If attributeHandle->node != NULL, that means that the attribute has an

  independent node to itself, and is not a part of list node */

  if (attributeHandle->node != NULL){

    NW_Bool nextAttrWithSameNameFound = NW_FALSE;

    NW_DOM_AttributeHandle_t h;

    h.node = NULL;

    while (!nextAttrWithSameNameFound){

      if (NW_DOM_AttributeListIterator_getNextAttribute(&attrListIterator, &h)

          == NW_STAT_WBXML_ITERATE_DONE){

        break;

      }

      status = NW_DOM_AttributeHandle_getName(&h, &currentName);

      if (status != NW_STAT_SUCCESS){

        break;

      }

      docEncoding = NW_DOM_AttributeHandle_getEncoding(attributeHandle);

      charCount = NW_String_charBuffGetLength(currentName.storage, docEncoding,

                                              &byteCount);

      if (charCount < 0) {

        return NW_STAT_FAILURE;

      }

      nwStatus = NW_String_CmpToNativeAlignedUCS2(docEncoding, (NW_Uint32)charCount,

                                                  currentName.storage,

                                                  (NW_Uint16*)(attributeName->storage),

                                                  &cmpResult);

      NW_String_deleteStorage(&currentName);

      if (NW_STAT_IS_FAILURE(nwStatus)){

        continue;

      }

      if (cmpResult == 0){

        nextAttrWithSameNameFound = NW_TRUE;

      }

    }

    if (nextAttrWithSameNameFound){

      NW_TinyDom_Parser_t *parser =

      attrListIterator.attrListHandle.tiny_parser;

      NW_DOM_AttributeHandle_initWithNode(attributeHandle, parser, h.node);

    }

  }

  return NW_STAT_SUCCESS;

}

/**

 * The following 2 methods use token to return attributes

 */

/* 

 * Returns

 *  NW_STAT_DOM_NODE_TYPE_ERR

 *  NW_STAT_NOT_FOUND - if attribute is not found

 *  NW_STAT_SUCCESS

 *

 * IN - token 

 * MODIFIED - handle

 */

EXPORT_C NW_Status_t

NW_DOM_ElementNode_getAttributeHandleByToken(NW_DOM_ElementNode_t *elem, 

                                             NW_Uint16 token, 

                                             NW_DOM_AttributeHandle_t *handle)

{

  NW_DOM_AttributeListIterator_t attributeListIterator;

  NW_Bool attributeFound = NW_FALSE;

  NW_Uint16 currentToken = 0;

  NW_Status_t status;

  NW_TinyDom_Parser_t *parser;

  NW_ASSERT(token != 0);

  NW_ASSERT(elem != NULL);

  NW_ASSERT(handle != NULL);

  if ((NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE)

    && (NW_DOM_Node_getNodeType(elem) != NW_DOM_PROCESSING_INSTRUCTION_NODE)){

    return NW_STAT_DOM_NODE_TYPE_ERR;

  }

  if (!NW_DOM_ElementNode_hasAttributes(elem)){

    return NW_STAT_NOT_FOUND;

  }

  status = 

    NW_DOM_ElementNode_getAttributeListIterator(elem, &attributeListIterator);

  if (status != NW_STAT_SUCCESS){

    return status;

  }

  while (!attributeFound){

    if (NW_DOM_AttributeListIterator_getNextAttribute(&attributeListIterator, 

                                                      handle) 

        == NW_STAT_WBXML_ITERATE_DONE){

      return NW_STAT_NOT_FOUND;

    }

    currentToken = NW_DOM_AttributeHandle_getToken(handle);

    if (currentToken == token){

      attributeFound = NW_TRUE;

    }

  }

  /* if we arrive here, attributeFound must be NW_TRUE */

  if (handle->node != NULL)

  {

    NW_Bool nextAttrWithSameNameFound = NW_FALSE;

    NW_DOM_AttributeHandle_t h;

    h.node = NULL;

    while (!nextAttrWithSameNameFound){

      if (NW_DOM_AttributeListIterator_getNextAttribute(&attributeListIterator,

                                                        &h) 

          == NW_STAT_WBXML_ITERATE_DONE){

        return NW_STAT_BAD_INPUT_PARAM;

      }

      currentToken = NW_DOM_AttributeHandle_getToken(&h);

      if (currentToken == token)

        nextAttrWithSameNameFound = NW_TRUE;

    }

    parser = attributeListIterator.attrListHandle.tiny_parser;

      NW_DOM_AttributeHandle_initWithNode(handle, parser, h.node);

    }

  return NW_STAT_SUCCESS;

}

/* 

 * Returns

 *  NW_STAT_NOT_FOUND - if attribute is not found

 *  NW_STAT_DOM_NODE_TYPE_ERR

 *  NW_STAT_DOM_NO_STRING_RETURNED

 *  NW_STAT_SUCCESS

 *

 * This method returns attribute value as string

 * IN - token of attribute

 * MODIFIED - attributeValue 

 */

NW_Status_t

NW_DOM_ElementNode_getAttributeValueStringByToken(NW_DOM_ElementNode_t *elem, 

                                                  NW_Uint16 token, 

                                                  NW_String_t *attributeValue)

{

  NW_DOM_AttributeHandle_t attributeHandle;

  NW_Status_t status;

  NW_ASSERT(elem != NULL);

  NW_ASSERT(attributeValue != NULL);

  if ((NW_DOM_Node_getNodeType(elem) != NW_DOM_ELEMENT_NODE)

      && (NW_DOM_Node_getNodeType(elem) != NW_DOM_PROCESSING_INSTRUCTION_NODE)) 

   {

    return NW_STAT_DOM_NODE_TYPE_ERR;

   }

  status = 

    NW_DOM_ElementNode_getAttributeHandleByToken(elem, 

                                                 token, 

                                                 &attributeHandle);

  if (status != NW_STAT_SUCCESS){

    return status;

  }

  return NW_DOM_AttributeHandle_getValue(&attributeHandle, attributeValue);

}

/* 

 * IN - name - of element

 */

NW_Status_t

NW_DOM_ElementNode_getElementIteratorByTagName(NW_DOM_ElementNode_t *elem, 

                                               NW_String_t* name,

                                               NW_DOM_NodeIterator_t *handle)

{

  NW_DOM_DocumentNode_t *doc; 

  NW_WBXML_Dictionary_t *dict = NULL;

  NW_String_UCS2Buff_t *buff = NULL;

  NW_Uint32 encoding; 

  NW_Int16 token = 0;

  NW_ASSERT(elem != NULL);

  NW_ASSERT(name != NULL);

  NW_ASSERT(handle != NULL);

  doc  = NW_DOM_Node_getOwnerDocument(elem);

  if (doc == NULL) {

    return NW_STAT_FAILURE;

  }

  encoding = NW_DOM_DocumentNode_getCharacterEncoding(doc);

  dict = NW_DOM_DocumentNode_getDictionary(doc);

  buff = NW_String_stringToUCS2Buff(name, encoding);

  if((dict == NULL) || (buff == NULL)){

    NW_Mem_Free(buff);

    return NW_STAT_FAILURE;

  }

  token = NW_WBXML_Dictionary_getTagToken(dict, buff, NW_TRUE);

  NW_Mem_Free(buff);

  if (token < 0) {

    return NW_STAT_FAILURE;

  }