/*

* 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 decoder

*

*

*/

// INCLUDE FILES

#include    <apparc.h>

#include    <s32mem.h>

#include    <utf.h>

#include    <e32std.h>

#include    "ImpsDecodewbxml.h"

#include    "Imps_1_1_Tokens.h"

#include    "Imps_1_2_Tokens.h"

#include    "ImpsDataAccessorApi.h"

#include    "ImpsErrors.h"

#include    "ImpsWbXmlCommon.h"

#include    "ImpsVariantAPI.h"

#include    "impsutils.h"

#include    "ImpsFields.h"

#include    "ImpsDataUtils.h"

//LITERALS

// TODO: This could be changed so that the NS form the message itself is used!

// There is no simple solution for proper attribute handling because of the callback

// interface logic!!!

_LIT8( KAttr11, " xmlns=\"http://www.wireless-village.org/TRC1.1\"");

_LIT8( KAttr12, " xmlns=\"http://www.openmobilealliance.org/DTD/WV-TRC1.2\"");

_LIT8( KPresSubListAttr11, " xmlns=\"http://www.wireless-village.org/PA1.1\"");

_LIT8( KPresSubListAttr12,  " xmlns=\"http://www.openmobilealliance.org/DTD/WV-PA1.2\"");

// Maximum length of the element in DTD

const TInt KDtdElementMaxLength = 100;

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

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

// TagStart

// Callback function for handling tag begin

// Returns: NW_Status_t indicates success

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

//

NW_Status_t TagStart(NW_WBXML_Parser_t* aParser, void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateTagStart);

    }

    return NW_STAT_SUCCESS;

    }

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

// AttributeStart

// Callback function for handling attribute begin

// Returns: NW_Status_t indicates success

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

//

NW_Status_t AttributeStart(NW_WBXML_Parser_t* aParser, void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateAttributeStart);

    }

    return NW_STAT_SUCCESS;

    }

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

// Binary

// Callback function for handling WBXML binary data

// Returns: NW_Status_t indicates success

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

//

NW_Status_t Binary(NW_WBXML_Parser_t* aParser,TUint32 aValue, void* aContext)

    {

    if(aParser)

    {

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aValue));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    else

    {

        return NW_STAT_FAILURE;

    }

    }

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

// FQTokenL

// Callback function for handling WBXML tokens

// Returns: NW_Status_t indicates success

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

//

NW_Status_t FQTokenL(NW_WBXML_Parser_t* aParser,TUint32 aFqtoken, void* aContext)

    {

    if(aParser)

    {

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aFqtoken));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    return NW_STAT_FAILURE;

    }

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

// InlineStringL

// Callback function for handling WBXML inline strings

// Returns: NW_Status_t indicates success

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

//

NW_Status_t InlineStringL(NW_WBXML_Parser_t* aParser,TUint32 aLength, void* aContext)

    {

    if(aParser)

    {

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreInlineStringL(aParser,aLength));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    return NW_STAT_SUCCESS;

    }

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

// TableStringL

// Callback function for handling WBXML string table strings

// Returns: NW_Status_t indicates success

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

//

NW_Status_t TableStringL(NW_WBXML_Parser_t* aParser,TUint32 aIndex, void* aContext)

    {

    if(aParser)

    {

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTableStringL(aIndex));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    else

    {

        return NW_STAT_FAILURE;

    }

    }

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

// Extension

// Callback function for handling WBXML extension tokens

// Returns: NW_Status_t indicates success

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

//

NW_Status_t Extension(NW_WBXML_Parser_t* aParser,void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateExtension);

    }

    return NW_STAT_SUCCESS;

    }

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

// Opaque

// Callback function for handling WBXML opaque data

// Returns: NW_Status_t indicates success

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

//

NW_Status_t Opaque(NW_WBXML_Parser_t* aParser,TUint32 aLength, void* aContext)

    {

    return(((CImpsDecodeWbXml*)aContext)->StoreOpaqueData(aParser,aLength));

    }

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

// BinaryL

// Callback function for handling WBXML binary data

// Returns: NW_Status_t indicates success

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

//

NW_Status_t BinaryL(NW_WBXML_Parser_t* aParser,TUint32 aValue, void* aContext)

    {

    if(aParser)

    {

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->StoreTokenL(aValue));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    else

    {

        return NW_STAT_FAILURE;

    }

    }

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

// StartDocument

// Callback function for handling wbxml document header information

// Returns: NW_Status_t indicates success

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

//

NW_Status_t StartDocument(NW_WBXML_Parser_t* aParser,

                          NW_WBXML_Document_t* aDocument, void* aContext)

    {

    if(aParser)

    {

        return(((CImpsDecodeWbXml*)aContext)->StoreDocument(aDocument));

    }

    return NW_STAT_SUCCESS;

    }

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

// AttributeValue

// Callback function for handling attribute value

// Returns: NW_Status_t indicates success

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

//

NW_Status_t AttributeValue(NW_WBXML_Parser_t* aParser, void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateAttributeValue);

    }

    return NW_STAT_SUCCESS;

    }

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

// TagEndL

// Callback function for handling tag end

// Returns: NW_Status_t indicates success

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

//

NW_Status_t TagEndL(NW_WBXML_Parser_t* aParser, void* aContext)

    {

    if(aParser)

    {   

        NW_Status_t rcode = NW_STAT_SUCCESS;

        TRAPD(error,rcode = ((CImpsDecodeWbXml*)aContext)->TagEndHandleL( ));

        if(error != KErrNone)

        {

            return NW_STAT_FAILURE;

        }

        else

        {

            return rcode;

        }

    }

    else

    {

        return NW_STAT_FAILURE;

    }

    }

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

// Content

// Callback function for handling WBXML content

// Returns: NW_Status_t indicates success

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

//

NW_Status_t Content(NW_WBXML_Parser_t* aParser, void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->SetState(EImpsDecodeStateContent);

    }

    return NW_STAT_SUCCESS;

    }

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

// EntityL

// Callback function for handling WBXML entity

// Returns: NW_Status_t indicates success

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

//

NW_Status_t EntityL(NW_WBXML_Parser_t* aParser, TUint32 aValue, void* aContext)

    {

    if(aParser)

    {

        if(aValue)

        {

            TRAPD(error, ((CImpsDecodeWbXml*)aContext)->DecodeEntityL(aValue));

            if(error != KErrNone)

            {

                return NW_STAT_FAILURE;

            }

        }

    }

    return NW_STAT_SUCCESS;

    }

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

// Exception

// Callback function for handling WBXML parser exceptions

// Returns: NW_Status_t indicates success

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

//

NW_Status_t Exception(NW_WBXML_Parser_t* aParser,NW_WBXML_Exception_t aException, void* aContext)

    {

    if(aParser)

    {

        ((CImpsDecodeWbXml*)aContext)->ExceptionHandle(aException);

    }

    return NW_STAT_FAILURE;

    }

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

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

// might leave.

//

CImpsDecodeWbXml::CImpsDecodeWbXml():

    iDecodeToXml(EFalse),

    iTransactions(0),

    iTypeStatus(EFalse),

    iPureMessageType( EImpsMessageNone )

    {

    }

// default constructor can leave.

void CImpsDecodeWbXml::ConstructL()

    {

        // create buffers for data handling

    iStoreValue8   = HBufC8::NewL(KImpsWbXmlMaxStringLength);

    iElementValue  = HBufC8::NewL(KImpsWbXmlMaxStringLength);

    iStoreValue    = HBufC::NewL(KImpsWbXmlMaxStringLength);

    // create handler for wbxml data

    iWbXmlData = CImpsWbXmlData::NewL( );

    // PEC in use ?

    CImpsVariant* dpb = CImpsVariant::NewLC();

    if (dpb->IsFeatureSupportedL(EDpb))

    {

        iXmlUtils = CImpsXmlUtils::NewL( );

        iPEC = ETrue;

    }

    else

    {

        iXmlUtils = NULL;

        iPEC = EFalse;

    }

    CleanupStack::PopAndDestroy( );

    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);

        }

    iStack = new(ELeave) CStack<NW_String_UCS2Buff_t, EFalse>();

    }

// Two-phased constructor.

CImpsDecodeWbXml* CImpsDecodeWbXml::NewL( MImpsCSPSession* /*aCallback*/ )

    {

    CImpsDecodeWbXml* self = new (ELeave) CImpsDecodeWbXml;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CImpsDecodeWbXml::~CImpsDecodeWbXml()

    {

    delete iWbXmlData;

    delete iStoreValue;

    delete iStoreValue8;

    delete iElementValue;

    delete iXmlUtils;

    delete iStack;

    NW_WBXML_Dictionary_destroy(); 

    }

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

// CImpsDecodeXml::DecodeMsgAsyncL

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

//

TInt CImpsDecodeWbXml::DecodeMsgAsyncL( HBufC8** aBuffer )

    {

    // TODO: implement it!

    __ASSERT_DEBUG(aBuffer, User::Panic(KImpsPanicCategory, KErrArgument));

    delete *aBuffer;

    *aBuffer = NULL; // indicate that the ownerships was taken

    return 0;

    }

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

// CImpsDecodeXml::DecodeMessageL

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

//

void CImpsDecodeWbXml::CancelDecoding()

    {

    // TODO: implement it!

//    TTime finished;

//    finished.HomeTime();

//    TReal sec = finished.MicroSecondsFrom(started).Int64()/1000000.0;

    }

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

// CImpsDecodeXml::DecodeMessageL

// IMPS engine WBXML message decoder main function and API for user

// aImpsData provides data storage for parsed out values

// aDecodeBuffer contains message to be decoded

// if error occurs method leaves with error code

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

//

void CImpsDecodeWbXml::DecodeMessageL(

    MImpsDataAccessor& aImpsData,

    HBufC8**  aDecodeBuffer )

    {

    __ASSERT_DEBUG(aDecodeBuffer, User::Panic(KImpsPanicCategory, KErrArgument));

    HBufC8* decodeBuffer = *aDecodeBuffer;

    *aDecodeBuffer = NULL; // indicate that the ownership was taken;

    CleanupStack::PushL(decodeBuffer); // take the message buffer

    iImpsData = &aImpsData;

    // initializing the XML decoder states

    iTransactions = 0;

    iDecodeToXml = EFalse;

    iTypeStatus = EFalse;

    iStack->Reset();

    //////////////////////////////////////

    // CREATE AND INITIALIZE WBXML PARSER

    NW_WBXML_Parser_t WBXML_parser;

    NW_WBXML_Parser_newInPlace(&WBXML_parser);

    WBXML_parser.ext_t_not_table_index = NW_TINYDOM_EXTENSION_TYPE_EXT_T_INTEGER;

    WBXML_parser.recursiveCallCnt = 0;

    // CREATE EVENT HANDLER AND SET EVENT HANDLER CALLBACK

    // FUNCTION POINTERS

    NW_WBXML_EventHandler_t WBXML_event_handler;

    WBXML_event_handler.StartDocument_CB = StartDocument;

    WBXML_event_handler.EndDocument_CB = NULL;

    WBXML_event_handler.Pi_CB = NULL;

    WBXML_event_handler.Tag_Start_CB = TagStart;

    WBXML_event_handler.Tag_End_CB = TagEndL;

    WBXML_event_handler.Attr_Start_CB = AttributeStart;