/*

* Copyright (c) 2006 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:      

*

*/

#include <s32strm.h> // RWriteStream

#include <SenXmlReader.h>

#include "senpropertieselement.h"   // private: Utils\inc

#include "senpropertiesfragment.h"  // private: Utils\inc

#include <SenXmlUtils.h>

#include <SenXmlConstants.h>

#include "senlayeredxmlproperties.h"

#include "SenXmlProperties.h"

#include "senxmldebug.h"

namespace

    {

    const TInt KFlatBufSize         = 64;  // CBufFlat

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL()

    {

    CSenLayeredXmlProperties* pNew =

            CSenLayeredXmlProperties::NewLC();

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC()

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor

    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname,

                         KNullDesC8,

                         NULL);

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL(const TDesC8& aXmlUtf8,

                                                         CSenXmlReader& aParser)

    {

    CSenLayeredXmlProperties* pNew = NewLC(aXmlUtf8, aParser);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC(const TDesC8& aXmlUtf8,

                                                          CSenXmlReader& aParser)

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname,

                         aXmlUtf8,

                         &aParser);

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL(const CSenElement& aElement)

    {

    CSenLayeredXmlProperties* pNew =

                CSenLayeredXmlProperties::NewLC(aElement);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC(const CSenElement& aElement)

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // Parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(aElement);

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL(RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew =

            CSenLayeredXmlProperties::NewLC(aStringPool);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC(RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // omit parsing by passing zero-length descriptor

    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname,

                         KNullDesC8,

                         NULL,

                         &aStringPool);

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL(const TDesC8& aXmlUtf8,

                                                         CSenXmlReader& aParser,

                                                         RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew = NewLC(aXmlUtf8, aParser, aStringPool);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC(const TDesC8& aXmlUtf8,

                                                          CSenXmlReader& aParser,

                                                          RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(KSenLayeredXmlPropertiesLocalname,

                         aXmlUtf8,

                         &aParser,

                         &aStringPool);

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewL(const CSenElement& aElement,

                                                         RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew =

                CSenLayeredXmlProperties::NewLC(aElement, aStringPool);

    CleanupStack::Pop(); // pNew

    return pNew;

    }

CSenLayeredXmlProperties* CSenLayeredXmlProperties::NewLC(const CSenElement& aElement,

                                                          RStringPool& aStringPool)

    {

    CSenLayeredXmlProperties* pNew = new (ELeave) CSenLayeredXmlProperties;

    CleanupStack::PushL(pNew);

    // Parse the XML document  descriptor into DOM fragment

    pNew->BaseConstructL(aElement, &aStringPool);

    return pNew;

    }

void CSenLayeredXmlProperties::SetReader(CSenXmlReader& aReader)

    {

    // De-allocate the owned reader, if one exists:

    if( ipReader )

        {

        delete ipReader; 

        ipReader = NULL;

        }

    // Note: ipFragment does not own the reader 

    // behind the given reference (aReader) 

    ipFragment->SetReader(aReader);

    if ( ipChildProperties )

        {

        ipChildProperties->SetReader(aReader);

        }

    }

MSenProperties::TSenPropertiesClassType CSenLayeredXmlProperties::PropertiesClassType() 

    { 

    return ESenLayeredXmlProperties; 

    }

void CSenLayeredXmlProperties::WriteToL(RWriteStream& aWriteStream)

    {

    // Find out whether we should declare the namespace

    TPtrC8 nsPrefix = ipFragment->NsPrefix();

    // Element name

    aWriteStream.WriteL(KSenLessThan);

    if ( nsPrefix.Length() > 0 )

        {

        aWriteStream.WriteL(nsPrefix);

        aWriteStream.WriteL(KSenColon);

        }

    aWriteStream.WriteL(ipFragment->AsElement().LocalName());

    RPointerArray<CSenBaseAttribute>& attrs = ipFragment->AsElement().AttributesL();

    RPointerArray<CSenNamespace>& namespaces = ipFragment->AsElement().NamespacesL();

    if ( ( attrs.Count() > 0 ) || ( namespaces.Count() > 0 ) )

        {

        CSenNamespace* ns = NULL;

        TInt count = namespaces.Count();

        for (TInt i=0; i < count; i++)

            {

            ns = (namespaces)[i];

            if (ns)

                {

                aWriteStream.WriteL(KSenSpaceXmlns);

                if (ns->Prefix().Length() > 0)

                    {

                    aWriteStream.WriteL(KSenColon);

                    aWriteStream.WriteL(ns->Prefix());

                    }

                aWriteStream.WriteL(KSenEqualsDblQuot);

                aWriteStream.WriteL(ns->URI());

                aWriteStream.WriteL(KSenDblQuot);

                }

            }

        count = attrs.Count();

        for (TInt j = 0; j < count; j++)

            {

            aWriteStream.WriteL(KSenSpace);

            aWriteStream.WriteL((attrs)[j]->Name());

            aWriteStream.WriteL(KSenEqualsDblQuot);

            aWriteStream.WriteL((attrs)[j]->Value());

            aWriteStream.WriteL(KSenDblQuot);

            }

        }

    // Elements and content

    RPointerArray<CSenElement> elements;

    ElementsL(elements);

    if ( (elements.Count() > 0) || ipFragment->AsElement().HasContent() )

        {

        aWriteStream.WriteL(KSenGreaterThan);

        // Body

        TInt elementCount(elements.Count());

        for (TInt k=0; k<elementCount; k++)

            {

            elements[k]->WriteAsXMLToL(aWriteStream);

            }        

        aWriteStream.WriteL(ipFragment->AsElement().Content());

        // Closing element

        aWriteStream.WriteL(KSenLessThanSlash);

        if (nsPrefix.Length() > 0)

            {

            aWriteStream.WriteL(nsPrefix);

            aWriteStream.WriteL(KSenColon);

            }

        aWriteStream.WriteL(ipFragment->AsElement().LocalName());

        aWriteStream.WriteL(KSenGreaterThan);

        }

    else

        {

        aWriteStream.WriteL(KSenSlashGreaterThan);

        }

    elements.Close();

    }

void CSenLayeredXmlProperties::ReadFromL(const TDesC8& aBuffer)

    {

    // Sanity check: ignore zero-length strings

    if ( aBuffer.Length() == 0)

        {

        return;

        }

    // Check if fragment already has a reference to *some*

    // XML reader

    if ( !ipFragment->Reader() )

        {

        // Check if there is already an owned reader instance

        if( !ipReader )

            {

            ipReader = CSenXmlReader::NewL(KXmlParserMimeType); // use libxml2 sax parser

            }

        // Sets reference of that XML reader for this fragment:

        ipFragment->ParseWithL(*ipReader);

        }

    ipFragment->ParseL(aBuffer);   

    }

HBufC8* CSenLayeredXmlProperties::AsUtf8L()

    {

    CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

    CleanupStack::PushL(pBuf);

    RBufWriteStream bufWs(*pBuf);

    CleanupClosePushL(bufWs);

    this->WriteToL(bufWs);

    CleanupStack::PopAndDestroy(); // bufWs.Close();

    TPtrC8 p = pBuf->Ptr(0);    

    HBufC8* pRet = p.AllocL();

    CleanupStack::PopAndDestroy(); // pBuf;

    return pRet;

    // return ipFragment->AsXmlL();

    }

HBufC8* CSenLayeredXmlProperties::AsUtf8LC()

    {

    HBufC8* pRet = this->AsUtf8L();

    CleanupStack::PushL(pRet);

    return pRet;

    }

TInt CSenLayeredXmlProperties::SetPropertyL(const TDesC8& aName,

                                            const TDesC8& aValue)

    {

	CSenElement* pElement = ipFragment->AsElement().Element(aName);

	if(!pElement)

		{

		// Add new element

		pElement =  &ipFragment->AsElement().AddElementL(aName);

		}

    pElement->SetContentL(aValue);

    return KErrNone;

    }

TInt CSenLayeredXmlProperties::PropertyL(const TDesC8& aName, TPtrC8& aValue)

    {

    if ( ipChildProperties )

        {

        TInt retVal = ipChildProperties->PropertyL(aName, aValue);

        if ( retVal == KErrNotFound )

            {

        	CSenElement* pElement = ipFragment->AsElement().Element(aName);

        	if ( pElement )

        		{

        		const TDesC8* pAttrValue = pElement->AttrValue(KSenOmittedAttributeName);

        		if ( pAttrValue )

                    {

                    if ( *pAttrValue == KSenOmittedTrueNoValue)

        		        {

                        return KErrSenOmitted;

                        }

                    else if ( *pAttrValue == KSenPropertyTrue)

                        {

                        return KErrSenOmitted;

                        }

        		    }

        		aValue.Set(pElement->Content());

        		return KErrNone;

        		}

            else

                {

                return KErrNotFound;

                }

            }

        return retVal;

        }

    else

        {

    	CSenElement* pElement = ipFragment->AsElement().Element(aName);

    	if ( pElement )

    		{

    		const TDesC8* pAttrValue = pElement->AttrValue(KSenOmittedAttributeName);

    		if ( pAttrValue )

                {

                if ( *pAttrValue == KSenOmittedTrueNoValue)

    		        {

                    return KErrSenOmitted;

                    }

                else if ( *pAttrValue == KSenPropertyTrue)

                    {

                    return KErrSenOmitted;

                    }

    		    }

        	aValue.Set(pElement->Content());

        	return KErrNone;

    		}

        else

            {

            return KErrNotFound;

            }

        }

    }

TInt CSenLayeredXmlProperties::SetIntPropertyL(const TDesC8& aName,

                                               const TInt aValue)

    {

    TBuf8<KFlatBufSize> buffer;

    buffer.Num(aValue);

    return SetPropertyL(aName, buffer);

    }

TInt CSenLayeredXmlProperties::IntPropertyL(const TDesC8& aName, TInt& aValue)

    {

    TPtrC8 value;

    TInt retVal(KErrNone);

    retVal = PropertyL(aName, value);

    if ( retVal == KErrNone )

        {

        TLex8 lex(value);

        retVal = lex.Val(aValue);

        }

    return retVal;

    }

TInt CSenLayeredXmlProperties::SetBoolPropertyL(const TDesC8& aName,

                                                const TBool aValue)

    {

    if ( aValue )

        {

        return SetPropertyL(aName, KSenPropertyTrue);

        }

    else

        {

        return SetPropertyL(aName, KSenPropertyFalse);

        }

    }

TInt CSenLayeredXmlProperties::BoolPropertyL(const TDesC8& aName,

                                             TBool& aValue)

    {

    TInt retVal(KErrNone);

    TPtrC8 value;

    retVal = PropertyL(aName, value);

    if ( retVal == KErrNone )

        {

        if (value == KSenPropertyTrue)

            {

            aValue = ETrue;

            }

        else if (value == KSenPropertyFalse)

            {

            aValue = EFalse;

            }

        else

            {

            retVal = KErrGeneral;

            }

        }

    return retVal;

    }

TInt CSenLayeredXmlProperties::SetOmittedL(const TDesC8& aName, TBool aValue)

    {

    TBool newElementCreated = EFalse;

 	CSenElement* pElement = ipFragment->AsElement().Element(aName);

	if ( !pElement )

		{

		// Add new element

		pElement =  &ipFragment->AsElement().AddElementL(aName);

		newElementCreated = ETrue;

		}

    else

        {

        const TDesC8* pVal = pElement->AttrValue(KSenOmittedAttributeName);

        if ( pVal )

            {

            delete SenXmlUtils::RemoveAttributeL(*pElement, KSenOmittedAttributeName);

            }

        }

    if ( pElement )  

        {

        if ( aValue )

            {

            if ( newElementCreated )

                {

                SenXmlUtils::AddAttributeL(*pElement, KSenOmittedAttributeName, KSenOmittedTrueNoValue);

                }

            else

                {

                SenXmlUtils::AddAttributeL(*pElement, KSenOmittedAttributeName, KSenPropertyTrue);

                }

            }

        else

            {

            SenXmlUtils::AddAttributeL(*pElement, KSenOmittedAttributeName, KSenPropertyFalse);

            }

        }

    else

        {

        return KErrNotFound;

        }

    return KErrNone;   

    }

TInt CSenLayeredXmlProperties::RemovePropertyL(const TDesC8& aName)

    {

 	CSenElement* pElement = ipFragment->AsElement().RemoveElement(aName);

	if ( pElement )

		{

		delete pElement;

		return KErrNone;

		}

    else

        {

        return KErrNotFound;

        }

    }

void CSenLayeredXmlProperties::WriteToL(RWriteStream& aWriteStream, TSenPropertiesLayer aLayer)

    {

    if ( aLayer > iLayer )

        {

        if ( ipChildProperties )

            {

            ipChildProperties->AsUtf8L(aLayer);

            }

        }

    else

        {

        if ( aLayer == iLayer )

            {

            ipFragment->WriteAsXMLToL(aWriteStream);

            }

        }

    }

void CSenLayeredXmlProperties::ReadFromL(const TDesC8& aBuffer, TSenPropertiesLayer aLayer)

    {

    // Sanity check: ignore zero-length strings

    if ( aBuffer.Length() == 0)

        {