/*

* Copyright (c) 2003 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:  Imps engine wbxml message encoder

*

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    <apparc.h>

#include    <s32mem.h>

#include    <utf.h>

#include    <e32math.h>

#include    <miutconv.h>

//#include    <mentact.h>

#include    "ImpsWbXmlData.h"

#include    "ImpsEncodewbxml.h"

#include    "ImpsDataAccessorapi.h"

#include    "ImpsErrors.h"

#include    "Imps_1_1_Tokens.h"

#include    "Imps_1_2_Tokens.h"

#include    "ImpsWbXmlCommon.h"

#include    "ImpsCspDtd.h"

#include    "ImpsUtils.h"

#include    "ImpsServices.h"

#include    "ImpsVariantAPI.h"

#include    "impsfields.h"

#include    "ImpsDataUtils.h"

// ================= LOCAL FUNCTIONS ====================

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CImpsEncodeWbXml::CImpsEncodeWbXml( ):

    iCspVersion( EImpsCspVersion11 )

    {

    }

// default constructor can leave.

void CImpsEncodeWbXml::ConstructL()

    {

    iElementValue = HBufC::NewL(KImpsWbXmlMaxStringLength);

    iStoreValue = HBufC8::NewL(KImpsWbXmlMaxStringLength);

    // create handler for wbxml data

    iWbXmlData = CImpsWbXmlData::NewL( );

    iCurrentDictionary = iDictionaryCount = 0;

    iDictionaries[iDictionaryCount++] = 

        (NW_WBXML_Dictionary_s*)&NW_Imps_1_1_WBXMLDictionary;

    iDictionaries[iDictionaryCount++] = 

        (NW_WBXML_Dictionary_s*)&NW_Imps_1_2_WBXMLDictionary;

    if(NW_WBXML_Dictionary_initialize (iDictionaryCount,iDictionaries) != NW_STAT_SUCCESS)

    {

        User::Leave(KImpsErrorEncode);

    }

    // PEC in use ?

    CImpsVariant* dpb = CImpsVariant::NewLC();

    if (dpb->IsFeatureSupportedL(EDpb))

    {

        iXmlUtils = CImpsXmlUtils::NewL( );

        iPEC = ETrue;

    }

    else

    {

        iXmlUtils = NULL;

        iPEC = EFalse;

    }

   CleanupStack::PopAndDestroy();

    }

// Two-phased constructor.

CImpsEncodeWbXml* CImpsEncodeWbXml::NewL( )

    {

    CImpsEncodeWbXml* self = new (ELeave) CImpsEncodeWbXml( );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CImpsEncodeWbXml::~CImpsEncodeWbXml()

    {

    delete iWbXmlData;

    delete iElementValue;

    delete iStoreValue;

    delete iXmlUtils;

    NW_WBXML_Dictionary_destroy(); 

    }

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

// CImpsEncodeXml::EncodeMessageL

// wbxml message encoder main function, which provides API

// class aImpsData contains message data,

// encoded message is stored to aEncodeBuffer

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

//

void CImpsEncodeWbXml::EncodeMessageL(

    MImpsDataAccessor& aImpsData,

    CBufFlat& aEncodeBuffer)

    {

    // INIT BUFFERS

    iImpsData = &aImpsData;

    iEncodeBuffer = &aEncodeBuffer;

    // CREATE EMPTY DOM DOCUMENT TREE

    NW_TinyDom_Handle_t handle;

    // set up the version related things

    iCspVersion = iImpsData->GetImpsFields()->CspVersion();

    TInt cspVersion = 

        ((iCspVersion == EImpsCspVersion11)?KImpsWvCsp11PublicIdentifier:KImpsWvCsp12PublicIdentifier);

	iCurrentDictionary =

    	((iCspVersion == EImpsCspVersion11)? 0 : 1);	

    iDocument = NW_DOM_DocumentNode_createDocumentWithNumberPublicId(&handle,

    KImpsWbXmlVersion,cspVersion,KImpsDefaultCharset,NW_TRUE,NW_TRUE);

    if(!iDocument)

    {

        User::Leave(KImpsErrorEncode);

    }

    // check for possible buffer allocation failure

    if(!iElementValue)

    {

        iElementValue = HBufC::NewL(KImpsWbXmlMaxStringLength);

    }

    if(!iStoreValue)

    {

        iStoreValue = HBufC8::NewL(KImpsWbXmlMaxStringLength);

    }

    // create key for data accessor

    iAccessKey = iImpsData->NewKeyL();

    iNameSpace = KImpsNameSpaceCspMessage;

    // start building DOM document tree

    TInt rcode = KErrNone;

    TBufC<16> root(KImpsWvCspMessage);

    TRAPD(error,rcode = EncodeElementL(root,iDocument,0))

    if(error != KErrNone || rcode != KErrNone)

    {

        // FAILURE !

        // delete DOM document

        NW_DOM_DocumentNode_Delete(iDocument);

        // delete access key        

        iAccessKey->Destroy( );

        if(rcode != KErrNone)

        {

            User::Leave(rcode);

        }

        else

        {

            User::Leave(KImpsErrorEncode);

        }

    }

    iAccessKey->Destroy( );

    // ENCODE MESSAGE

    TUint32 size = 0;

    unsigned char *buffer = NULL;

    NW_Encoder_t WbXmlEncoder;

    if(NW_Encoder_encodeWBXML(&WbXmlEncoder,iDocument,NW_TRUE,&size,&buffer) != NW_STAT_SUCCESS)

    {

        // FAILURE !

        // delete DOM document

        NW_DOM_DocumentNode_Delete(iDocument);

        if(buffer)

        {

            free(buffer);

        }

        User::Leave(KImpsErrorEncode);

    }

    // put the new public ID there

//    if (size >0)

//        {

//        buffer[1] = 0x10;

//        }

    // copy message to aEncodeBuffer

    if((TInt)size > iEncodeBuffer->Size())

    {

        iEncodeBuffer->Reset();

    }

    iEncodeBuffer->ResizeL(size);

    iEncodeBuffer->Write(0,buffer,size);

    free(buffer);

    // delete DOM document

    NW_DOM_DocumentNode_Delete(iDocument);

    }

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

// CImpsEncodeWbXml::ReadElementDeclaration

// method reads elements DTD declaration

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

//

TPtrC CImpsEncodeWbXml::ReadElementDeclaration(TDesC &aElement)

    {

    TPtrC dtd;

    if ( iCspVersion == EImpsCspVersion11 ) 

        {

        dtd.Set(KCspHeaderDtd11[NULL]);

        }

    else

        {

        dtd.Set(KCspHeaderDtd12[NULL]);

        }

    TInt i(0);

    TInt count = 0;

    if(iNameSpace == KImpsNameSpaceTransactionContent)

        {

        count = ((iCspVersion == EImpsCspVersion11)?KImpsTransactionDtd11Count:KImpsTransactionDtd12Count);

        }

    else if(iNameSpace == KImpsNameSpacePresenceSubList)

        {

        count = ((iCspVersion == EImpsCspVersion11)?KImpsPresenceDtd11Count:KImpsPresenceDtd12Count);

        }

    else

        {

        count = ((iCspVersion == EImpsCspVersion11)?KImpsHeaderDtd11Count:KImpsHeaderDtd12Count);

        }

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

    {

        switch(iNameSpace)

        {

        case KImpsNameSpaceCspMessage:

            if ( iCspVersion == EImpsCspVersion11 )

                {

                dtd.Set(KCspHeaderDtd11[i]);

                }

            else

                {

                dtd.Set(KCspHeaderDtd12[i]);

                }

            break;

        case KImpsNameSpaceTransactionContent:

            if ( iCspVersion == EImpsCspVersion11 )

                {

                dtd.Set(KCspContentDtd11[i]);

                }

            else

                {

                dtd.Set(KCspContentDtd12[i]);

                }

            break;

        case KImpsNameSpacePresenceSubList:

            if ( iCspVersion == EImpsCspVersion11 )

                {

                dtd.Set(KCspPresenceDtd11[i]);

                }

            else

                {

                dtd.Set(KCspPresenceDtd12[i]);

                }

            break;

        }

        if(dtd.Find(aElement) == 1 && dtd.Locate(' ') == (aElement.Length() + 1))

        {

            break;

        }

    }

    return(dtd);

    }

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

// CImpsEncodeWbXml::EncodeElementL

// method adds one node to DOM tree

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

//

TInt CImpsEncodeWbXml::EncodeElementL(TDesC &aElement, NW_DOM_ElementNode_t* aNode,TInt aIndex)

    {

    TBuf<sizeof(SImpsValueList)> valuebuf(sizeof(SImpsValueList));

    SImpsValueList* valuelist = (SImpsValueList*)valuebuf.Ptr();

    // Read element declaration

    TPtrC element = ReadElementDeclaration(aElement);

    // prepare child element list

    ReadElementList(element,valuelist);

    // Get element WBXML token

    TBool extraelem = EFalse;

    TInt token = ReadToken(element);

    TInt elementcounter = 0; 

    TBool literal = false;

    if(token == KErrNotFound)

    {

    	// check for the extension token APIClient as it is not in the dictionary

        if ( (aElement.CompareF(KImpsAPIClient))==0 ) 

            {

            literal = true;

            }

        else

            {

        	extraelem = ETrue;

        	elementcounter = aIndex;

            }

    }

    // Update data accessor key (root element is left out)

    TInt primitive = KErrNone;

    if(token != KImpsMessageRootElement && !extraelem)

    {

        if ( literal ) 

            {

            // add the APIClient key to accessor key

            iAccessKey->AddL(CREATEKEY(EImpsKeyAPIClient,aIndex),EImpsKeyTypeIM);

            }

        else

            {

        	primitive = SetDataAccessorKeyL(token,aIndex);

            }

    }

    TInt rcode = KErrNotFound;

    NW_DOM_ElementNode_t *node = NULL;

	TInt exrcode = KErrNotFound;

    if(iImpsData->CheckBranchExistenceL(iAccessKey) || extraelem)

    {

        if ( literal ) 

            {

            HBufC8* literalToken = HBufC8::NewL(aElement.Length()+1);// for the \0 at the end

            CleanupStack::PushL(literalToken);

            literalToken->Des().Copy(aElement);

            // create an element node from string for extension element

            NW_String_t* elementString = NW_String_new();

            NW_String_initialize(elementString, (void*)literalToken->Des().PtrZ(), HTTP_utf_8);

            node = NW_DOM_DocumentNode_createElementNode(iDocument, elementString);

            NW_String_delete(elementString);

            // literalToken has to be deleted as last because NW_String keeps the pointer

            CleanupStack::PopAndDestroy(); // literalToken

            }        

        else

            {

            node = NW_DOM_DocumentNode_createElementNodeByToken(iDocument,(TUint16)token);

            }

            if(node != NULL || extraelem)

			    {

			        if((rcode = EncodeAttributes(token,node)) == KErrNone || extraelem)

			        {

			            if(!(valuelist->Flags & KImpsValueListEmpty))

			            {

			                TPtrC value = ReadNextValue(valuelist,element);

			                if(value.Find(KPcData) != KErrNotFound)

			                {

			                    // encode value

			                    rcode = EncodeValueL(token,node,aIndex);

			                }

			                else

			                {

			                    for(;;)

			                    {

			                        if(valuelist->Flags & KImpsValueListAlternative && !extraelem)

			                        {

			                            if(primitive == KErrNotFound)

			                            {

			                                TImpsKeyType type = EImpsKeyTypeIM;

			                                iImpsData->RestoreAlternativeL(iAccessKey,primitive,aIndex,type);

			                            }

			                            // Get the element name string from the 1.2 dictionary as it has all the elements

			//                                TPtrC elementName(KNullDesC);

			                            TUint16* elementNamePtr = (TUint16*)NW_WBXML_Dictionary_getTagByFqToken((NW_Uint32)(2<<16)+primitive)->bytes;

			                            if (elementNamePtr)

			                            	{

			                            	value.Set(elementNamePtr);

			                            	}

										else

											{

											value.Set(KNullDesC);

											}

			                            //value.Set(iWbXmlData->GetDtdValue(token,primitive));

			                        }

			                        if(extraelem)

			                        {

			                            node = aNode;

			                        }

			                        rcode = EncodeElementL(value,node,elementcounter);

									if(rcode == KErrNone && extraelem)

									{

										exrcode = KErrNone;

									}

									value.Set(FetchNextElement(valuelist,elementcounter,rcode,element,value));

									if(rcode == KErrNotFound)

									{

										if(extraelem) rcode = exrcode;

										else rcode = KErrNone;

										break;

									}

									if(rcode == KImpsErrorEncode || rcode == KImpsErrorValidate)

			                        {

			                            if(extraelem) 

			                                {

			                                rcode = KErrNotFound;

			                                }

										else 

			                                {

			                                rcode = KImpsErrorValidate;

			                                }

			                            break;

			                        }		

			                    }

			                }

			            }

			            if(rcode == KErrNone && !extraelem)

			            {

			                // append node to parent node

			                NW_Status_t status = NW_DOM_Node_appendChild((NW_TinyTree_Node_s*)aNode,node);

			                if(status != NW_STAT_SUCCESS) 

			                    {

			                    rcode = KImpsErrorEncode;

			                    }

			            }

			        }

			        else

			        {

			            rcode = KImpsErrorEncode;

			        }

			    }

			    else

			    {

			        rcode = KImpsErrorEncode;

            	}

    	}

    else

    {

        if(token == KImpsWbXmlContentSize)

        {

            // special case, content size must be calculated

            rcode = SetContentSizeL(token,aNode);

        }

        else

        {

            rcode = KErrNotFound;

        }

    }

    // update data access key

    if(!extraelem)

    {

        PopAccessKeyL(token);

    }

    return(rcode);

    }

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

// CImpsEncodeWbXml::SetContentSize

// method counts message content size

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

//

TInt CImpsEncodeWbXml::SetContentSizeL(TInt aToken,NW_DOM_ElementNode_t* aNode)

    {

    iAccessKey->PopL(2);

    iAccessKey->AddL(EImpsKeyContentData);

    TInt size(0);

    if ( TImpsDataUtils::GetContentDataTypeL( iImpsData, 0 ) == EImpsDataTypeDesc )

        {

    TDesC *p;

        if ( iImpsData->RestoreDescL(iAccessKey,p) )

            {

            size = p->Length();   

            }

        }

     else

         {

         TDesC8 *p;

         if ( iImpsData->RestoreDesc8L(iAccessKey,p) )

            {

            size = p->Length();   

            }

         }