/*

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

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <LiwServiceHandler.h>

#include <Liwbufferextension.h>

#include <gmxmldocument.h>

#include <gmxmlelement.h>

#include <gmxmlcharacterdata.h>

#include <charconv.H>

#include <gmxmltext.h>

#include "txmlconvertor.h"

#include <f32file.h>

#include <e32des16.h>

#include <e32base.h>

#include "tprovidertestobserver.h"

_LIT8(KErrorCode,"ErrorCode");

// Define constants

const TInt KTYPE_ID_LEN = 7;

const TInt KENTRY_LEN = 5;

const TInt KINT_LEN = 3;

const TInt KBOOL_LEN = 4;

const TInt KDATE_LEN = 4;

const TInt KFLOAT_LEN = 5;

const TInt KMAX_LEN = 255;

const TInt KSTRING_LEN = 8;

const TInt KLIST_LEN = 4;

const TInt KITER_LEN = 8;

const TInt KMAP_LEN = 3;

const TInt KKEY_LEN = 3;

const TInt KNAME_LEN = 4;

const TInt KPARAMS_LEN = 6;

const TInt KPARAM_LEN = 5;

const TInt KDateLen = 25;

const TInt KMaxOutputLen = 1000;

_LIT(KAttribute, "type_id");

_LIT(KKeyAttribute, "name");

_LIT(KInt, "int");

_LIT(KFloat, "float");

_LIT(KString, "string");

_LIT(KString8, "string8");

_LIT(KList, "list");

_LIT(KMap, "map");

_LIT(KKey, "key");

_LIT(KBool, "bool");

_LIT(KDate, "date");

_LIT(KEntry, "entry");

_LIT(KIterator, "iterator");

_LIT(KOpenTag, "<");

_LIT(KFinalCloseTag, "/>");

_LIT(KCloseTag, ">");

_LIT(KOpenTagSlash, "</");

_LIT(KParams, "params");

_LIT(KParam, "param");

_LIT(KNameAttribute, "name");

_LIT(KSTDDATE, "19700001:000000.000000");

// Converts the output params from LIW specific data type to xml based flash

// specific data type.

void CXmlConvertor::BuildOutputTreeL(CLiwGenericParamList& aOutParamList,TPtrC& aPtr)

    {

    CMDXMLDocument* pDocNode = CMDXMLDocument::NewLC();

    if (pDocNode)

    	{

	    TBuf<KPARAMS_LEN> paramsNode(KParams);

	    CMDXMLElement* pParamsNode = CMDXMLElement::NewLC(ETrue,pDocNode,paramsNode);

		if (pParamsNode)

			{

		    for(TInt i=0; i < aOutParamList.Count(); ++i)

		        {

		        //create <param name=""/> tag

		        TBuf<KPARAM_LEN> paramNode(KParam);

		        CMDXMLElement* pParamNode = CMDXMLElement::NewLC(ETrue,pDocNode,paramNode);

		        if (pParamNode)

		        	{

			        TBuf<KMAX_LEN> paramName;

			        TLiwGenericParam outParam = aOutParamList[i];

			        if(outParam.Name().Length()!=0)

			        	{

			        	paramName.Copy(outParam.Name());

			        	}

			        else

			        	{

			        	TInt semID = outParam.SemanticId();

			        	const TDesC8& strParam = this->GetParamAsString(semID);

			        	paramName.Copy(strParam);

			        	}

			        TBuf<KNAME_LEN> nameAttr(KKeyAttribute);

			        //Create an attribute "name"

			        pParamNode->SetAttributeL(nameAttr,paramName);

			        pParamsNode->AppendChild(pParamNode);

			        AppendOutParamL(pDocNode,pParamNode,outParam.Value());

			        CleanupStack::Pop(pParamNode);

		        	}

		        }

		    // Convert the output to string.

		    ToStringL(pParamsNode, aPtr);

		    CleanupStack::PopAndDestroy(pParamsNode);

			}

	    CleanupStack::PopAndDestroy(pDocNode);

    	}

    }

// Converts the TGenericParamId passed by the service provider

// to string, as we can pass only string values to flash content.

const TDesC8& CXmlConvertor::GetParamAsString(TGenericParamId aParamID)

    {

    switch(aParamID)

        {

        case EGenericParamError:

        	{

           	return KErrorCode();

        	}

        //Convert other generic param IDs if required

        default:

        	break;

        }

    return KNullDesC8();

    }

//Output parameter processing

// Appends the value in TLiwVariant to the XML tree.

void CXmlConvertor::AppendOutParamL(CMDXMLDocument* aDocNode, CMDXMLElement* aParentNode,

								 const TLiwVariant& aParamVar)

    {

        if (aDocNode && aParentNode)

    	{

	    TBuf<KTYPE_ID_LEN> typeIdAttr(KAttribute);

	    TBuf<KENTRY_LEN> entryNode(KEntry);

	    CMDXMLElement* pEntryNode = CMDXMLElement::NewL(ETrue,aDocNode,entryNode);

	    if (pEntryNode)

	    	{

		    CleanupStack::PushL(pEntryNode);

		    if(aParamVar.TypeId()==EVariantTypeTInt32)

		        {

		        //Form attribute "name" with value "int"

		        TBuf<KINT_LEN> typeIdValue(KInt);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsTInt32()

		        CMDXMLText* pValueNode = CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

		        TInt intValue = aParamVar.AsTInt32();

		        TInt len = GetLengthToStoreInt(intValue);

		        HBufC* hInt = HBufC::NewLC(len+1);

		        TPtr intPtr(hInt->Des());

		        intPtr.Num(intValue);

				pValueNode->SetDataL(intPtr);

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::PopAndDestroy(hInt);

		        CleanupStack::Pop(pValueNode);

		        }

		   else if(aParamVar.TypeId()==EVariantTypeTBool)

		        {

		        //Form attribute "name" with value "bool"

		        TBuf<KBOOL_LEN> typeIdValue(_L("bool"));

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsTBool()

		        CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

				TBuf<KMAX_LEN> value;

		        value.Num(aParamVar.AsTBool());

		        pValueNode->SetDataL(value);

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::Pop(pValueNode);

		        }

		   else if(aParamVar.TypeId()==EVariantTypeDesC8)

		        {

		        //Form attribute "name" with value "string"

		        TBuf<KSTRING_LEN> typeIdValue(KString8);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsDes()

		        CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

		        TPtrC8 pValue;

		        aParamVar.Get(pValue);

		        HBufC* heapBuffer = HBufC::NewL( pValue.Length() );

	            CleanupStack::PushL( heapBuffer );

	            TPtr value( heapBuffer->Des() );

	            value.Copy( pValue );

		        pValueNode->SetDataL(value);

		        CleanupStack::PopAndDestroy();    

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::Pop(pValueNode);

		        }

		   else if(aParamVar.TypeId()==EVariantTypeTTime)

		        {

		        //Form attribute "name" with value "date"

		        TBuf<KDATE_LEN> typeIdValue(_L("date"));

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsTTime()

		        CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

				// Convert the date as ActionScript requires that the date be passed as

				// milliseconds since midnight January 1, 1970.

				TBuf<KDateLen> dateBuf(KSTDDATE);

				TTime std(dateBuf);

		        TTime timeVal = aParamVar.AsTTime();

		        //Convert microseconds to milliseconds.

		        TTimeIntervalMicroSeconds timeMS = timeVal.MicroSecondsFrom(std);

		        TInt64 timeInt = timeMS.Int64();

		        timeInt = timeInt/1000;

		        TInt64 len = GetLengthToStoreInt64(timeInt);

		        HBufC* hInt = HBufC::NewLC(len);

		        TPtr intPtr(hInt->Des());

		        intPtr.Num(timeInt);

		        pValueNode->SetDataL(intPtr);

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::PopAndDestroy(hInt);

		        CleanupStack::Pop(pValueNode);

		        }

		    else if(aParamVar.TypeId()==EVariantTypeTReal)

		        {

		        //Form attribute "name" with value "float"

		        TBuf<KFLOAT_LEN> typeIdValue(KFloat);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsReal()

		        CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

		        TRealFormat format;

				format.iType = KRealFormatGeneral;

				TBuf<KMAX_LEN> value;

				value.Num(aParamVar.AsTReal(),format);

		        pValueNode->SetDataL(value);

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::Pop(pValueNode);

		        }

		    else if(aParamVar.TypeId()==EVariantTypeDesC)

		        {

		        //Form attribute "name" with value "string"

		        TBuf<KSTRING_LEN> typeIdValue(KString);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        //Create text node with value equivalent to aParamVar.AsDes()

		        CMDXMLText* pValueNode=CMDXMLText::NewL(aDocNode);

		        CleanupStack::PushL(pValueNode);

		        TPtrC pValue=aParamVar.AsDes();

		        pValueNode->SetDataL(pValue);

		        pEntryNode->AppendChild(pValueNode);

		        CleanupStack::Pop(pValueNode);

		        }

		    else if( aParamVar.TypeId()==EVariantTypeList)

		        {

		        //Form attribute "name" with value "list"

		        TBuf<KLIST_LEN> typeIdValue(KList);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        const CLiwList* pList=aParamVar.AsList();

		        if ( pList )

		       		{

			        CleanupStack::PushL(const_cast<CLiwList*>(pList));

			        for(TInt l=0; l != pList->Count(); ++l)

			            {

			            TLiwVariant listEntry;

			            pList->AtL(l,listEntry);

			            this->AppendOutParamL(aDocNode,pEntryNode,listEntry);

			            listEntry.Reset();

			            }

			        CleanupStack::Pop(const_cast<CLiwList*>(pList));

		       		}

		        }

		    else if(aParamVar.TypeId()==EVariantTypeIterable)

		        {

		        //Handling is same as that of list, accessor

		        //method is different (AsIterable)

		        //Form attribute "name" with value "iterator"

		        TBuf<KITER_LEN> typeIdValue(KIterator);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        CLiwIterable* pIter=aParamVar.AsIterable();

		        if (pIter)

		        	{

			        CleanupStack::PushL(pIter);

			        TLiwVariant entry;

			        while(EFalse != pIter->NextL(entry))

			            {

			            this->AppendOutParamL(aDocNode,pEntryNode,entry);

			            entry.Reset();

			            }

			        entry.Reset();

			        CleanupStack::Pop(pIter);

		        	}

		        }

		    else if(aParamVar.TypeId()==EVariantTypeMap)

		        {

		        //Form attribute "name" with value "list"

		        TBuf<KMAP_LEN> typeIdValue(KMap);

		        pEntryNode->SetAttributeL(typeIdAttr,typeIdValue);

		        const CLiwMap* pMap=aParamVar.AsMap();

		        if ( pMap )

		        	{

			        CleanupStack::PushL(const_cast<CLiwMap*>(pMap));

			        for(TInt m=0; m!=pMap->Count();++m)

			            {

			            TBuf8<KMAX_LEN> mapKey;

			            pMap->AtL(m,mapKey);

			            TBuf<KMAX_LEN> mapKey16;

			            mapKey16.Copy(mapKey);

			            //Add key node as child of entry node

			            TBuf<KKEY_LEN> keyNode(KKey);

			            TBuf<KNAME_LEN> nameAttr(KKeyAttribute);

			            CMDXMLElement* pKeyNode = CMDXMLElement::NewL(ETrue,aDocNode,keyNode);

			            if (pKeyNode)

			            	{

				            CleanupStack::PushL(pKeyNode);

				            pKeyNode->SetAttributeL(nameAttr,mapKey16);

				            pEntryNode->AppendChild(pKeyNode);

				            TLiwVariant fndEntry;

				            TBool found = pMap->FindL(mapKey,fndEntry);

				            if ( found )

				            	{

				            	this->AppendOutParamL(aDocNode,pKeyNode,fndEntry);

				            	fndEntry.Reset();

				            	}

				            CleanupStack::Pop(pKeyNode);

			            	}

			            }

			           CleanupStack::Pop(const_cast<CLiwMap*>(pMap));

		        	}

		        }

		    aParentNode->AppendChild(pEntryNode);

		    CleanupStack::Pop(pEntryNode);

	    	}

    	}

    }

// The ouput XML tree contains the output params. This function converts the output to the

// string representation of the xml based flash specific data type.

void CXmlConvertor::ToStringL(CMDXMLElement* aRootNode,TPtrC& aPtr)

    {

    delete iOutputBuffer;

    iOutputBuffer = NULL;

    iOutputBuffer = HBufC::NewL(KMaxOutputLen);

    WriteElementL(aRootNode);

    aPtr.Set(*iOutputBuffer);

    }

// This function writes the contents of the XML node to the output.

void CXmlConvertor::WriteElementL(CMDXMLElement* aElemNode)

    {

    if (aElemNode)

    	{

	    //write start element tag i.e <element_name>

	    WriteStartElementTagL(aElemNode);

	    if(aElemNode->HasChildNodes()==0)

	        {

	        AppendStringL(KFinalCloseTag);

	        return;

	        }

	    else //write end element tag i.e </element_name>

	        {

	        AppendStringL(KCloseTag);

	        for(CMDXMLNode* pCurrNode = aElemNode->FirstChild();

	                NULL != pCurrNode;

	        	    pCurrNode = pCurrNode->NextSibling()

	                )

	            {

	            if(CMDXMLNode::EElementNode==pCurrNode->NodeType())

	                {

	                WriteElementL((CMDXMLElement*)pCurrNode);

	                }

	            else if(CMDXMLNode::ETextNode==pCurrNode->NodeType())

	                {

	                AppendStringL(((CMDXMLCharacterData*)pCurrNode)->Data());

	                }

	            }

	        WriteEndElementTagL(aElemNode);

	        }

    	}

    }

  // This function writes the start element tag and the attributes of the node

// to the output.

void CXmlConvertor::WriteStartElementTagL(CMDXMLElement* aElemNode)

    {

    if (aElemNode)

    	{

	    AppendStringL(KOpenTag); //<

	    AppendStringL(aElemNode->NodeName()); //<element_name

	    if(aElemNode->NumAttributes()>0)

	        {

	        WriteAttributeTagL(aElemNode);

	        }

    	}

    }

    // This function writes the end element tag to the output.

void CXmlConvertor::WriteEndElementTagL(CMDXMLElement* aElemNode)

    {

    if(aElemNode && aElemNode->HasChildNodes())

        {

        AppendStringL(KOpenTagSlash);

        AppendStringL(aElemNode->NodeName());

        AppendStringL(KCloseTag);

        }

    else

        {

        AppendStringL(KFinalCloseTag);

        }

    }

    // This function writes the attributes of the node to the output.

void CXmlConvertor::WriteAttributeTagL(CMDXMLElement* aElemNode)

    {

    //Add a space before adding attr

    if(aElemNode && aElemNode->NumAttributes()>0)

        {

        TPtrC attributeValue;

        TPtrC attributeName;

        for(TInt i=0; i!=aElemNode->NumAttributes(); ++i)

            {

            AppendStringL(KSingleSpace);

            aElemNode->AttributeDetails(i, attributeName, attributeValue);

            AppendStringL(attributeName);

            AppendStringL(KEqualSign);

            AppendStringL(KQuotation);

            AppendStringL(attributeValue);

            AppendStringL(KQuotation);

            }

        }

    }

    // Appends the output to the output buffer.

void CXmlConvertor::AppendStringL(const TDesC& aStr)

	{

	TPtr bufPtr(iOutputBuffer->Des());

	TInt maxLen = bufPtr.MaxLength();

	TInt outLen = iOutputBuffer->Length();

	TInt strLen = aStr.Length();

	TInt remLen = maxLen - outLen;

	// ReAlloc if more space is required.

	if ( strLen > remLen)

		{

		iOutputBuffer = iOutputBuffer->ReAllocL(maxLen+strLen);

		}

	TPtr outPtr(iOutputBuffer->Des());

	outPtr.Append(aStr);

	}

// Calculates the length of the string needed to store the integer.

TInt CXmlConvertor::GetLengthToStoreInt(TInt aNum)