// 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:

// Document node functions

//

#include <stdlib.h>

#include <bafl/sysutil.h>

#include <xml/utils/xmlengmem.h>

#include <xml/dom/xmlengdocument.h>

#include "xmlengfileoutputstream.h"

#include <xml/dom/xmlengerrors.h>

#include "xmlengownednodescontainer.h"

#include "xmlengdomdefs.h"

#include <xml/dom/xmlengdatacontainer.h>

#include <xml/dom/xmlengbinarycontainer.h>

#include <xml/dom/xmlengchunkcontainer.h>

#include <xml/dom/xmlengfilecontainer.h>

#include <xml/dom/xmlengdataserializer.h>

#include <xml/dom/xmlengelement.h>

#include <xml/dom/xmlengcdatasection.h>

#include <xml/dom/xmlengprocessinginstruction.h>

#include <xml/dom/xmlengcomment.h>

#include <xml/dom/xmlengdocumentfragment.h>

#include <xml/dom/xmlengentityreference.h>

#include <xml/dom/xmlengoutputstream.h>

#include <xml/dom/xmlengdomimplementation.h>

#include <xml/utils/xmlengxestrings.h>

#include <stdapis/libxml2/libxml2_parser.h>

#include <stdapis/libxml2/libxml2_xmlio.h>

#include "libxml2_xmlsave_private.h"

#include "libxml2_tree_private.h"

#include "libxml2_globals_private.h"

#include <stdapis/libxml2/libxml2_parserinternals.h>

#include "libxml2_valid_private.h"

int XMLCALL NodeFilterCallback(void* aFilter, xmlNodePtr aNode);

void LibxmlDocumentCleanup(TAny* aAttrPtr);

void LibxmlNodeCleanup(TAny* aNodePtr);

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

// "Write" callback registered in libxml2 for using with custom output stream

// during serializing XML. 

// 

// This callback is invoked repeatedly during serialization; 

// when whole data is serialized the "Close" callback is called for a output stream.

//

// @param aContext  User data that was used during callback registration 

//                  XML Engine uses here a pointer to MXmlEngOutputStream provided by client app

// @param aBuffer   Buffer where the next part of serialized XML has just been written

// @param aLen      Number of bytes written to the buffer

// 

// The callback is prototyped by libxml2's type declaration:

// @code

//     typedef int (*xmlOutputWriteCallback) (void* context, const char* buffer, int len);

// @endcode

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

//

int XmlEngineIOWriteCallback(void* aContext, const char* aBuffer, int aLen)

    {

    MXmlEngOutputStream* stream = reinterpret_cast<MXmlEngOutputStream*>(aContext);

    return stream->Write(TPtrC8(reinterpret_cast<TUint8*>(const_cast<char*>(aBuffer)), aLen));

    }

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

// "Close" callback registered in libxml2 for using with custom output stream

// during serializing XML. 

// 

// This callback is invoked after the last "Write" callback.

// 

// @param aContext  User data that was used during callback registration 

//                  XML Engine uses here a pointer to MXmlEngOutputStream provided by client app

// 

// The callback is prototyped by libxml2's type declaration:

// @code

//     typedef int (*xmlOutputCloseCallback) (void* context);

// @endcode

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

//

int XmlEngineIOCloseCallback(void* aContext)

    {

    MXmlEngOutputStream* stream = reinterpret_cast<MXmlEngOutputStream*>(aContext);

    return stream->Close();

    }

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

// Data serialization callback registered in libxml2 for custom node data serialization.

// 

// This callback is invoked whenever EText node contains data of given length, for example

// binary data or data stored in a memory chunk.

// 

// @param aContext  Data serializer provided by client app

// @param aNode  Node that contains data to be serialized 

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

//

unsigned char* DataSerializationCallback(void* aContext, xmlNodePtr aNode, int* aWritten)

  	{

  	TPtrC8 ptr(KNullDesC8());

	MXmlEngDataSerializer* dataSerializer = reinterpret_cast<MXmlEngDataSerializer*>(aContext);	

	TRAPD(err, ptr.Set(dataSerializer->SerializeDataL(TXmlEngNode(aNode))));

	if(err)

	    {

	    *aWritten = err;

	    return NULL;

	    }

    *aWritten = ptr.Size();

    return (unsigned char*)ptr.Ptr();

	}

#define LIBXML_DOC (static_cast<xmlDocPtr>(iInternal))

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

// Closes the RXmlEngDocument object: the whole document tree is destroyed and all memory is released.

// 

// All owned by the document nodes (created by it or unlinked from the document and not linked elsewhere)

// are destroyed too.

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

//

EXPORT_C void RXmlEngDocument::Close()

    {

    if(LIBXML_DOC)

        {

        LibxmlDocumentCleanup(LIBXML_DOC);

        iInternal = NULL;

        }

    }

EXPORT_C void RXmlEngDocument::OpenL(RXmlEngDOMImplementation& aDOMImpl)

    {

    iImpl = &aDOMImpl;

    xmlDocPtr doc = xmlNewDoc(NULL);

    OOM_IF_NULL(doc);

    iInternal = doc;

    CleanupClosePushL(*this);

    InitOwnedNodeListL();

    CleanupStack::Pop();

    };

EXPORT_C void RXmlEngDocument::OpenL(RXmlEngDOMImplementation& aDOMImpl, void* aInternal)

    {

    iImpl = &aDOMImpl;

    iInternal = aInternal;

    CleanupStack::PushL(TCleanupItem(LibxmlDocumentCleanup,(TAny*)LIBXML_DOC));

    InitOwnedNodeListL();

    CleanupStack::Pop();

    };

EXPORT_C void RXmlEngDocument::OpenL(RXmlEngDOMImplementation& aDOMImpl, TXmlEngElement aRoot)

    {

    OpenL(aDOMImpl);

    xmlUnlinkNode(INTERNAL_NODEPTR(aRoot));

    xmlNodePtr node = xmlAddChild(LIBXML_NODE, INTERNAL_NODEPTR(aRoot));

    if(!node)

        {

        Close();

        OOM_HAPPENED;

        }

    };

EXPORT_C TXmlEngDocumentFragment RXmlEngDocument::CreateDocumentFragmentL()

    {

    xmlNodePtr dfNode = xmlNewDocFragment(LIBXML_DOC);

    OOM_IF_NULL(dfNode);

    TXmlEngNode df(dfNode);

    TakeOwnership(df);

    return df.AsDocumentFragment();

    }

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

// Serializes document tree into a file

//

// @param aFileName    A file name (with path)

// @return            Number of byte written

// @note

// Method may leave with KErrNoMemory or KErrGeneral codes.

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

//

EXPORT_C TInt RXmlEngDocument::SaveL( const TDesC& aFileName, 

							    TXmlEngNode aRoot,

							    const TXmlEngSerializationOptions& aSaveOptions ) const

    {

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

    if (!aFileName.Length())

        {

        WRONG_USE_OF_API;

        }    

    RFs fs;

    User::LeaveIfError(fs.Connect());

    CleanupClosePushL(fs);

    TInt size = SaveL(fs, aFileName, aRoot, aSaveOptions);

    CleanupStack::PopAndDestroy(&fs);

    return size;

    }

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

// Serializes node to a file

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

//

EXPORT_C TInt RXmlEngDocument::SaveL( RFs& aRFs,

    							const TDesC& aFileName, 

    							TXmlEngNode aRoot,

    							const TXmlEngSerializationOptions& aSaveOptions ) const

    {

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}    

    if (!aFileName.Length())

        {

        WRONG_USE_OF_API;

        }  

    TInt size = -1;        

    RFile outputFile;

    User::LeaveIfError(outputFile.Replace(aRFs,aFileName,EFileShareAny|EFileWrite));

    CleanupClosePushL(outputFile);

    TXmlEngFileOutputStream outputStream(outputFile,aRFs);

    RBuf8 buffer;

    // TString is null so it does not need to be closed

    size = SaveNodeL( INTERNAL_NODEPTR(aRoot), buffer, &outputStream, aSaveOptions);

    User::LeaveIfError(outputStream.CheckError());

    CleanupStack::PopAndDestroy(&outputFile);

    return size;   

    }

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

// Serializes a document tree into provided output stream, which supports

// progressive writing of data.

//

// @param aStream  An output stream to write serialized DOM tree

// @param aRoot Root node to be serialized

// @param aSaveOptions Options that control how serialization is performed

// @see MXmlEngOutputStream

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

//

EXPORT_C TInt RXmlEngDocument::SaveL( MXmlEngOutputStream& aStream,

								TXmlEngNode aRoot,

								const TXmlEngSerializationOptions& aSaveOptions ) const

    {

	RBuf8 placeHolder;

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}

	if(!&aStream)

		{

		User::Leave(KXmlEngErrWrongUseOfAPI);

		}

	return SaveNodeL( aRoot, placeHolder, &aStream, aSaveOptions );   

    }

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

// Serializes DOM subtree into memory buffer

// 

// @param  aBuffer  A buffer to write output data.

// @param  aRoot    Root note to serialize.

// @param  aSaveOptions Various options that control how serialization is performed

//

// @return Number of bytes in updated buffer

//

// Buffer contents is freed prior serialization

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

//

EXPORT_C TInt RXmlEngDocument::SaveL( RBuf8& aBuffer, 

    							TXmlEngNode aRoot, 

    							const TXmlEngSerializationOptions& aSaveOptions ) const

    {

    if(IsNull())

    	{

    	User::Leave(KXmlEngErrWrongUseOfAPI);

    	}  

    return SaveNodeL(aRoot, aBuffer, NULL, aSaveOptions);

    }

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

// Creates complete copy of the document

//

// @return Complete copy of the document tree

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

//

EXPORT_C RXmlEngDocument RXmlEngDocument::CloneDocumentL() const

    {

    xmlDocPtr doc = NULL;

    if (iInternal)

        {

        doc = xmlCopyDoc(LIBXML_DOC, 1);

        OOM_IF_NULL(doc); 

        }

    RXmlEngDocument retDoc(doc);

    CleanupStack::PushL(TCleanupItem(LibxmlDocumentCleanup,(TAny*)doc));

    retDoc.InitOwnedNodeListL();

    CleanupStack::Pop();

    return retDoc;

    }

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

// Creates new element from specific namespace to be a root of the document tree.

//

// Any existing document element of the document is destroyed

//@return A new root element

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

//

EXPORT_C TXmlEngElement RXmlEngDocument::CreateDocumentElementL( const TDesC8& aName, 

												     const TDesC8& aNamespaceUri, 

												     const TDesC8& aPrefix )

    {

    TXmlEngElement newE = CreateElementL(aName, aNamespaceUri, aPrefix);

    SetDocumentElement(newE);

    return newE;

    }

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

// Replaces (and closes) document element with another one

//

// New document element is added as the last child to the document node

// @param aNewDocElement New document tree

// @note Use TXmlEngElement::ReconcileNamespacesL() on the new document element

//      if it or its descendants can contain references to namespace declarations

//      out of the element

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

//

EXPORT_C void RXmlEngDocument::SetDocumentElement( TXmlEngElement aNewDocElement )

    {

    TXmlEngElement oldE = DocumentElement();

    if (oldE.NotNull())

        {

        oldE.Remove();

        }

    if(aNewDocElement.ParentNode().IsNull())

        aNewDocElement.OwnerDocument().RemoveOwnership(aNewDocElement);

    //

    xmlNodePtr child =  xmlAddChild(LIBXML_NODE, INTERNAL_NODEPTR(aNewDocElement));

    }

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

// @return A document element - the top-most element in the document tree

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

//

EXPORT_C TXmlEngElement RXmlEngDocument::DocumentElement() const

    {

    return TXmlEngElement(xmlDocGetRootElement(LIBXML_DOC));

    }

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

// @return Encoding of the source XML data.

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

//

EXPORT_C TPtrC8 RXmlEngDocument::XmlEncoding() const

    {

    return ((TXmlEngConstString)CAST_XMLCHAR_TO_DOMSTRING(LIBXML_DOC->encoding)).PtrC8();

    }

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

// @return Whether standalone="true" was specified in XML declaration in the source XML file.

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

//

EXPORT_C TBool RXmlEngDocument::IsStandalone() const

    {

    return LIBXML_DOC->standalone != 0;

    }

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

// Sets 'standalone' attribute of XML declaration for a document

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

//

EXPORT_C void RXmlEngDocument::SetStandalone( TBool aStandalone )

    {

    LIBXML_DOC->standalone = aStandalone;

    }

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

// @return Version number of XML taken from XML declaration

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

//

EXPORT_C TPtrC8 RXmlEngDocument::XmlVersion() const

    {

    return ((TXmlEngConstString)CAST_XMLCHAR_TO_DOMSTRING(LIBXML_DOC->version)).PtrC8();

    }

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

// Sets XML version number to be shown in XML declaration when document is serialized.

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

//

EXPORT_C void RXmlEngDocument::SetXmlVersionL( const TDesC8& aVersion )

    {

    if(aVersion.Length())

        {

        xmlChar* ver = xmlCharFromDesC8L(aVersion);

        xmlFree((void*)LIBXML_DOC->version);

        LIBXML_DOC->version = ver;

        }

    }

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

// Retrieves base URI (if defined) of the document or NULL

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

//

EXPORT_C TPtrC8 RXmlEngDocument::DocumentUri() const

    {

    return ((TXmlEngConstString)CAST_XMLCHAR_TO_DOMSTRING(LIBXML_DOC->URL)).PtrC8();

    }

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

// Sets location of the document.

//

// Document's URI is used as top-level base URI definition.

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

//

EXPORT_C void RXmlEngDocument::SetDocumentUriL( const TDesC8& aUri )

    {

    xmlChar* uri = xmlCharFromDesC8L(aUri);

    if(LIBXML_DOC->URL)

        xmlFree((void*)LIBXML_DOC->URL);

    LIBXML_DOC->URL = uri;

    }

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

// @return Object that represents current DOM implementation

// @note There is no practical use of implementation object in this version

//      of API other than for creating new RXmlEngDocument instances, but

//      it will change in the future, when an implementation object 

//      is used for changing configuration settings at run-time.

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

//

EXPORT_C RXmlEngDOMImplementation RXmlEngDocument::Implementation() const

    {

    return *iImpl;

    }

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

// Creates new text node and copies the content string into it.

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

//

EXPORT_C TXmlEngTextNode RXmlEngDocument::CreateTextNodeL( const TDesC8& aCharacters )

    {

    xmlChar* con = xmlCharFromDesC8L(aCharacters);

    xmlNodePtr textNode = xmlNewText(NULL);

    if(!textNode)

        {

        delete con;

        OOM_HAPPENED;

        }

    textNode->doc = LIBXML_DOC;

    textNode->content = con;

    TXmlEngNode text(textNode);

    TakeOwnership(text);

    return text.AsText();

    }

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

// Creates new binary container and copies the content string into it.

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

//

EXPORT_C TXmlEngBinaryContainer RXmlEngDocument::CreateBinaryContainerL( const TDesC8& aCid,

                                                             const TDesC8& aData )

    {

    // Note: TXmlEngBinaryContainer is treated internally by Libxml2 as text node.

    TUint len = aCid.Size();

    unsigned char* cid = new(ELeave) unsigned char[len + 1];

    memcpy(cid, aCid.Ptr(), len);

    cid[len] = 0;

    len = aData.Size();

    CleanupStack::PushL(cid);

    unsigned char* str = new(ELeave) unsigned char[len + 1];

    CleanupStack::Pop(cid);

    memcpy(str, aData.Ptr(), len);

    str[len] = 0;

    xmlNodePtr contNode = xmlNewText(NULL);

    if(!contNode)

        {

        delete cid;

        delete str;

        OOM_HAPPENED;

        }

    contNode->ns = (xmlNs*) cid;    

    contNode->content = (xmlChar*) str;

    contNode->properties = (xmlAttr*) len;

	contNode->psvi = (void*) EBinaryContainer;

    contNode->doc = LIBXML_DOC;

    contNode->name = xmlStringTextNoenc;

    xmlAppendDataList(contNode, LIBXML_DOC);

    if(OOM_FLAG)

    	{

        xmlFreeNode(contNode);

        OOM_HAPPENED;    	

    	}    

    TXmlEngNode container(contNode);

    TakeOwnership(container);

    return container.AsBinaryContainer();

    }

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

// Creates new binary container that stores reference to memory chunk mapped with descriptor

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

//

EXPORT_C TXmlEngChunkContainer RXmlEngDocument::CreateChunkContainerL( const TDesC8& aCid, 

	    												   const RChunk& aChunk,

						                                   const TInt aChunkOffset,

						                                   const TInt aDataSize )

    {

    // Note: TXmlEngChunkContainer is treated internally by Libxml2 as text node.

    TUint len = aCid.Size();