// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Node functions implementation

//

#include <stdlib.h>

#include <xml/dom/xmlengelement.h>

#include <xml/dom/xmlengdocument.h>

#include <xml/dom/xmlengnamespace.h>

#include <xml/dom/xmlengtext.h>

#include <xml/dom/xmlenguserdata.h>

#include <xml/dom/xmlengnodelist.h>

#include <stdapis/libxml2/libxml2_parser.h>

#include <stdapis/libxml2/libxml2_globals.h>

#include <stdapis/libxml2/libxml2_xmlio.h>

#include "libxml2_xmlsave_private.h"

#include "libxml2_tree_private.h"

#include "xmlengdomdefs.h"

#include <xml/dom/xmlengerrors.h>

#include <xml/utils/xmlengmem.h>

#include <xml/utils/xmlengxestrings.h>

// ---------------------------------------------------------------------------------------------

// Unlinks the internal libxml2's node from double-linked list.

// Relinks neighbour nodes.The node stays virtually linked to its old neighbours! Use with care!!

//

// No checks are made; nor parent's, nor node's properties updated

// ---------------------------------------------------------------------------------------------

//

void TXmlEngNode::DoUnlinkNode()

    {

    xmlNodePtr& next = LIBXML_NODE->next;

    xmlNodePtr& prev = LIBXML_NODE->prev;

    // Unlink this node; relink neighbors

    if (prev)

        {

        prev->next = next;

        }

    else

        {

        // Unlinked node is the first in the list

        // 'children' or 'properties' property of the parent node

        // must be updated (depending on the type of the node: content node or attribute) 

        xmlNodePtr& parent = LIBXML_NODE->parent;

        // Ugly, but works :)

        xmlNodePtr* first = ((LIBXML_NODE->type ==  XML_ATTRIBUTE_NODE) 

                              ? reinterpret_cast<xmlNodePtr*>(&(parent->properties)) 

                              : &(parent->children));

        *first = next;

        }

    if (next)

        {

        next->prev = prev;

        }

    else

        {

        // Unlinked node is the last in the list (of elements or attributes) 

        // 'last' property of the parent element must be updated  (for content nodes only)

        if(LIBXML_NODE->type != XML_ATTRIBUTE_NODE)

            {

            LIBXML_NODE->parent->last = prev;

            }

        }

    }

// ---------------------------------------------------------------------------------------------

// Inserts the node in a double-linked list of nodes before specified node.

//

// No checks are made; nor parent's, nor node's properties updated (except prev/next)

// ---------------------------------------------------------------------------------------------

//

void TXmlEngNode::LinkBefore(TXmlEngNode aTargetNode)

    {

    xmlNodePtr node = INTERNAL_NODEPTR(aTargetNode);

    xmlNodePtr& prev = node->prev;

    LIBXML_NODE->next = node;

    LIBXML_NODE->prev = prev;

    prev->next = LIBXML_NODE;

    node->prev = LIBXML_NODE;

    }

// ---------------------------------------------------------------------------------------------

// Get innerXML string. This method return all content of the node.

// Output text does not include node markup.

//

// @note Returned TString should be freed

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TInt TXmlEngNode::InnerXmlL(RBuf8& aBuffer)

    {

    if(aBuffer.Length())

        {

        aBuffer.Close();

        }

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	} 

    if(NodeType() == TXmlEngNode::EDocument)

        {

        return OwnerDocument().SaveL(aBuffer, OwnerDocument(), NULL);

        }

    aBuffer.FillZ();

    RXmlEngNodeList<TXmlEngNode> nodeList;

    RBuf8 tmpStr;

    GetChildNodes(nodeList);

    TXmlEngNode tmpNode;

    while(nodeList.HasNext())

        {

        tmpNode = nodeList.Next();

        tmpNode.OuterXmlL(tmpStr);

        CleanupClosePushL(tmpStr);

        if((aBuffer.MaxSize() - aBuffer.Size()) < tmpStr.Size()) 

            {

            aBuffer.ReAllocL(aBuffer.MaxSize() + tmpStr.Size() + 1);

            }

        aBuffer.Append(tmpStr);

        CleanupStack::PopAndDestroy();

        }

    tmpStr.Close();

    return aBuffer.Size();

    }

// ---------------------------------------------------------------------------------------------

// Get outerXML string. This method return all content of the node.

// Output text includes node markup.

//

// @note Returned TString should be freed

//

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TInt TXmlEngNode::OuterXmlL(RBuf8& aBuffer)

    {

    TInt size = -1;

    if(aBuffer.Length())

        {

        aBuffer.Close();

        }

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	} 

    if(NodeType() == TXmlEngNode::EDocument)

        {

        return OwnerDocument().SaveL(aBuffer, OwnerDocument(), NULL);

        }

    xmlSaveCtxt ctxt;

    xmlOutputBufferPtr buf;

    /* 

     * save the content to a temp buffer.

     */

    buf = xmlAllocOutputBuffer(NULL);

    OOM_IF_NULL(buf);

    memset(&ctxt, 0, sizeof(ctxt));

    ctxt.doc = LIBXML_NODE->doc;

    ctxt.buf = buf;

    ctxt.level = 0;

    ctxt.format = 0; 

    xmlSaveCtxtInit(&ctxt);

    xmlNodeDumpOutputInternal(&ctxt, LIBXML_NODE);

    if(xmlOOMFlag())

        {

        xmlOutputBufferClose(buf);

        OOM_HAPPENED;

        }

    size = buf->buffer->use;

    if(size > 0)

        {

        // frees any previous contents of aBuffer argument

        aBuffer.Assign(buf->buffer->content,size,size);

        // To prevent it from freeing

        buf->buffer->content = NULL; 

        }

    xmlOutputBufferClose(buf);

    // Leaves with KErrNoMemory

    TEST_OOM_FLAG; 

    if (size < 0)

        {

        XmlEngLeaveL(KXmlEngErrNegativeOutputSize);

        }        

    return size;

    }

// ---------------------------------------------------------------------------------------------

// Moves the node to become the first in the list of its siblings

// Node is expected to have a parent.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::SetAsFirstSibling()

    {

    if (LIBXML_NODE->type == XML_NAMESPACE_DECL)

        {

        return;

        }

    xmlNodePtr& prev = LIBXML_NODE->prev;

    if (prev)

        {

        DoUnlinkNode();

        // Insert as first

        prev = NULL;

        xmlNodePtr& parent = LIBXML_NODE->parent;

        // Ugly, but works :)

        xmlNodePtr* first = ((LIBXML_NODE->type == XML_ATTRIBUTE_NODE)

                              ? reinterpret_cast<xmlNodePtr*>(&(parent->properties))

                              : &(parent->children));

        (*first)->prev = LIBXML_NODE;

        LIBXML_NODE->next = *first;

        *first = LIBXML_NODE;

        // NOTE: it is possible to cope without having parent defined,

        //       it will need to iterate through sibling list to find the first one

        }

    }

// ---------------------------------------------------------------------------------------------

// Moves the node to become the last in the list of its siblings

// Node is expected to have a parent.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::SetAsLastSibling()

    {

    if (LIBXML_NODE->type == XML_NAMESPACE_DECL)

        {

        return;

        }

    xmlNodePtr& next = LIBXML_NODE->next;

    if (next)

        {

        DoUnlinkNode(); 

        xmlNodePtr& parent = LIBXML_NODE->parent;

        xmlNodePtr& prev = LIBXML_NODE->prev;

        if (LIBXML_NODE->type != XML_ATTRIBUTE_NODE)

            {

            if (!prev)

                parent->children = next;

            prev = parent->last;

            parent->last->next = LIBXML_NODE;

            parent->last = LIBXML_NODE;

            }

        else

            {

            if (!prev)

                parent->properties = (xmlAttrPtr)next;

            prev = next; // NOTE: 'next' is always different than NULL

            while (prev->next)

                prev = prev->next;

            prev->next = LIBXML_NODE;

            }

        next = NULL;

        }

    }

// ---------------------------------------------------------------------------------------------

// Moves the node in the list of sibling nodes before another node

// Node is expected to have a parent.

// Do nothing if aSiblingNode is not one of node's siblings

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::MoveBeforeSibling(

    TXmlEngNode aSiblingNode )

    {

    if (LIBXML_NODE->type == XML_NAMESPACE_DECL)

        {

        return;

        }

    xmlNodePtr node = INTERNAL_NODEPTR(aSiblingNode);

    if (!node->prev)

        {

        SetAsFirstSibling();

        }

    else

        {

        DoUnlinkNode();

        LinkBefore(aSiblingNode);

        }

    }

// ---------------------------------------------------------------------------------------------

// Moves the node in the list of sibling nodes after another node

// Node is expected to have a parent.

// Do nothing if aSiblingNode is not one of the node's siblings

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::MoveAfterSibling(

    TXmlEngNode aSiblingNode)

    {

    if (LIBXML_NODE->type == XML_NAMESPACE_DECL)

        {

        return;

        }

    xmlNodePtr node = INTERNAL_NODEPTR(aSiblingNode);

    if (!node->next)

        {

        SetAsLastSibling();

        }

    else

        {

        DoUnlinkNode();

        LinkBefore(aSiblingNode.NextSibling());

        }   

    }

// ---------------------------------------------------------------------------------------------

// Retrieves a "handle" for namespace declaration that applies to the node's namespace

// Note: DOM specs do not consider namespace declarations as a kind of nodes

// This API adds TXmlEngNamespace type of nodes, which is derived from TXmlEngNode.

//

// @return    Object that represents namespace declaration and prefix binding that

//            act on the node; returns NULL object (check using TXmlEngNamespace.IsNull()

//            or TXmlEngNamespace.NotNull()) if no namespace associated

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TXmlEngNamespace TXmlEngNode::NamespaceDeclaration() const

    {

    //

    switch(LIBXML_NODE->type)

        {

        case XML_ELEMENT_NODE:

        case XML_ATTRIBUTE_NODE:

            return TXmlEngNamespace(LIBXML_NODE->ns);

        default:

            return NULL;

        }

    }

// ---------------------------------------------------------------------------------------------

// Clones the node completely: all attributes and namespace declarations (for TXmlEngElement nodes),

// values and children nodes are copied as well.

// 

// Document nodes cannot be copied with this method: RXmlEngDocument::CloneDocumentL() must be used.

//

// @return Complete copy of a node or leaves.

// @note    The node should not be NULL!

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TXmlEngNode TXmlEngNode::CopyL() const

    {

    if ( !LIBXML_NODE )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    // Copying of RXmlEngDocument should be made with RXmlEngDocument::CloneDocumentL()

    if(NodeType() == TXmlEngNode::EDocument)

        return NULL;

    //

    xmlNodePtr copy = xmlStaticCopyNode(

                            LIBXML_NODE, 

                            NULL /* doc */, 

                            NULL /* parent */, 

                            1);

    //

    if (xmlOOMFlag())

        {

        if(copy)

            xmlFreeNode(copy); // it may be a partial copy

        OOM_HAPPENED;

        }

    TXmlEngNode ncopy(copy);

    OwnerDocument().TakeOwnership(ncopy);

    return ncopy;

    }

// ---------------------------------------------------------------------------------------------

// Creates a deep copy of the node and appends the subtree as a new child

// to the provided parent node.

//

// @return Created copy of the node after linking it into the target document tree.

// @note Document nodes cannot be copied with this method; use RXmlEngDocument::CloneDocumentL()

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TXmlEngNode TXmlEngNode::CopyToL(

    TXmlEngNode aParent ) const

    {

    if ( !LIBXML_NODE )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    if ( LIBXML_NODE->type == XML_DOCUMENT_NODE )

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

   if ( aParent.IsNull() )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    //

    TXmlEngNode ncopy = CopyL();

    return aParent.AppendChildL(ncopy);

    }

// ---------------------------------------------------------------------------------------------

// Detaches a node from document tree

//

// @return This node, which is already not a part of any document

// @note    Remember to use ReconcileNamespacesL() later, if extracted node (subtree)

//         contains references to namespace declarations outside of the subtree.

// @see     ReconcileNamespacesL()

// @note    The document, from which the node is being unlinked, becomes an owner of the node

//         until it is linked elsewhere.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C TXmlEngNode TXmlEngNode::Unlink()

    {   

    //

    if(LIBXML_NODE && ParentNode().NotNull())

        {

        RXmlEngDocument tmpDoc = OwnerDocument();

        xmlUnlinkNode(LIBXML_NODE);

        tmpDoc.TakeOwnership(*this);

        }

    return *this;

    }

// ---------------------------------------------------------------------------------------------

// Unlinks the node and destroys it; all child nodes are destroyed as well and all memory is freed

//

// @note  Document nodes cannot be "removed" with this method, uses RXmlEngDocument-specific methods.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::Remove()

    {

    //

    if (!LIBXML_NODE || LIBXML_NODE->type == XML_DOCUMENT_NODE)

        {

        return;

        }

    if(ParentNode().NotNull())

        {

        xmlUnlinkNode(LIBXML_NODE);

        }

    else

        {

        OwnerDocument().RemoveOwnership(*this);

        }

    if (LIBXML_NODE->type != XML_ATTRIBUTE_NODE)

        {

     xmlFreeNode(LIBXML_NODE);

        }

	else

		{

		xmlFreeProp(INTERNAL_ATTRPTR(iInternal));

		}

    iInternal = 0;

    }

// ---------------------------------------------------------------------------------------------

// Ensures that namespaces referred to in the node and its descendants are

// in the scope the node.

//

// * This method checks that all the namespaces declared within the given

// * tree are properly declared. This is needed for example after Copy or Unlink

// * and then Append operations. The subtree may still hold pointers to

// * namespace declarations outside the subtree or they may be invalid/masked. As much

// * as possible the function try to reuse the existing namespaces found in

// * the new environment. If not possible, the new namespaces are redeclared

// * on the top of the subtree.

//

// This method should be used after unlinking nodes and inserting to another

// document tree or to a another part of the original tree, if some nodes of the subtree

// are remove from the scope of a namespace declaration they refer to.

//

// When node is unlinked, it may still refer to namespace declarations from the previous location.

// It is important to reconcile subtree's namespaces if previous parent tree is to be destroyed.

// On the other hand, if the parent tree is not changed before pasting its unlinked part into another

// tree, then reconciliation is needed only after paste operation.

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::ReconcileNamespacesL()

    {

    xmlReconciliateNs(LIBXML_NODE->doc, LIBXML_NODE);

    TEST_OOM_FLAG;

    }

// ---------------------------------------------------------------------------------------------

// Current node is replaced with another node (subtree).

//

// The replacement node is linked into document tree instead of this node.

// The replaced node is destroyed.

//

// @see SubstituteForL(TXmlEngNode)

//

// In both cases the argument node is unlinked from its previous location

// (which can be NONE, i.e. not linked; SAME or ANOTHER document tree).

//

// @note Replacement of a node with NULL TXmlEngNode is legal and equivalent to removing the node.

// @note Not applicable to document nodes

// ---------------------------------------------------------------------------------------------

//

EXPORT_C void TXmlEngNode::ReplaceWithL(TXmlEngNode aNode)

    {

    if ( !LIBXML_NODE )

    	{

    	User::Leave(KXmlEngErrNullNode);

    	}

    if ( LIBXML_NODE->type == XML_DOCUMENT_NODE )

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    if(aNode.ParentNode().IsNull())

        {

    	// new node is unlinked, so owned by some (maybe other than this) document