/*

* Copyright (c) 2002 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:  Implementation of CSIContentHandler.

*

*/

// INCLUDE FILES

#include "CSIContentHandler.h"

#include "PushMtmUtil.h"

#include "PushMtmSettings.h"

#include "PushMtmLog.h"

#include "PushMtmUiDef.h"

#include "StringResourceReader.h"

#include "PushContentHandlerPanic.h"

#include "si_dict.h"

#include "PushContentHandlerUtils.h"

#include <push/CSIPushMsgEntry.h>

#include <msvids.h>

#include <PushMtmUi.rsg>

#include <nw_dom_node.h>

#include <nw_dom_document.h>

#include <nw_dom_element.h>

#include <nw_dom_text.h>

#include <nw_wbxml_dictionary.h>

#include <THttpFields.h>

// CONSTANTS

// si attributes / elements

_LIT8( KSi,          "si" );

_LIT8( KIndication,  "indication" );

_LIT8( KHrefAttrib,  "href" );

_LIT8( KSiIdAttrib,  "si-id" );

_LIT8( KCreatedAttrib,   "created" );

_LIT8( KExpiresAttrib,   "si-expires" );

_LIT8( KActionAttrib,    "action" );

// action attribute literals

_LIT8( KDeleteAction,    "delete" );

_LIT8( KSignalNone,      "signal-none" );

_LIT8( KSignalLow,       "signal-low" );

_LIT8( KSignalMedium,    "signal-medium" );

_LIT8( KSignalHigh,      "signal-high" );

_LIT( KSiTextContentType, "text/vnd.wap.si" );

const TInt KValidMaxEncodedDateTimeSize = 7;

const TInt KValidUTCLength = 20; // YYYY-MM-DDTHH:MM:SSZ

const TInt KValidUTCNumericals = 14;

const TInt KValidUTCYearBlockLength = 4;

const TInt KValidUTCOtherBlockLength = 2;

const TUint8 KAsciiZeroCharCode = 0x30;

const TInt KValidTTimeMonthStart = 4;

const TInt KValidTTimeDayStart = 6;

const TInt KValidTTimeHourStart = 8;

const TInt KValidTTimeMinuteStart = 10;

const TInt KValidTTimeSecondStart = 12;

const TInt KValidTTimeBlockLength = 2;

const TInt KValidTTimeLength = 14; // YYYYMMDDHHMMSS

const TInt KNoOfDictArrays = 1;

_LIT( KCharMinus, "-" );

_LIT( KCharT, "T" );

_LIT( KCharColon, ":" );

_LIT( KCharZ, "Z" );

/// Conversion buffer size.

LOCAL_D const TInt KPushConversionBufferSize = 256;

/// Zero width non-breaking space character.

LOCAL_D const TUint16 KPushZeroWidthNbsp = 0xfeff;

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

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

// CSIContentHandler::NewL

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

//

CSIContentHandler* CSIContentHandler::NewL()

	{

    PUSHLOG_ENTERFN("CSIContentHandler::NewL")

	CSIContentHandler* self = new (ELeave) CSIContentHandler;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

    PUSHLOG_LEAVEFN("CSIContentHandler::NewL")

	return self;

	}

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

// CSIContentHandler::~CSIContentHandler

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

//

CSIContentHandler::~CSIContentHandler()

	{

    PUSHLOG_ENTERFN("CSIContentHandler::~CSIContentHandler")

    Cancel();

	delete iHrefBuf;

	delete iSiIdBuf;

	delete iData;

    delete iCharacterSetConverter;

    iCharacterSetConverter = NULL;

    delete iCharacterSetsAvailable;

    iCharacterSetsAvailable = NULL;

    PUSHLOG_LEAVEFN("CSIContentHandler::~CSIContentHandler")

	}

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

// CSIContentHandler::CSIContentHandler

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

//

CSIContentHandler::CSIContentHandler()

:   CPushContentHandlerBase(),

    iSavedMsgId( KMsvNullIndexEntryId ),

    iPushMsgAction( KErrNotFound ),

    iExpiresTime( Time::NullTTime() ),

    iCreatedTime( Time::NullTTime() )

	{

	}

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

// CSIContentHandler::ConstructL

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

//

void CSIContentHandler::ConstructL()

	{

    PUSHLOG_ENTERFN("CSIContentHandler::ConstructL")

    CPushContentHandlerBase::ConstructL();

    // Added to Active Scheduler.

    PUSHLOG_LEAVEFN("CSIContentHandler::ConstructL")

    }

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

// CSIContentHandler::CollectGarbageL

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

//

void CSIContentHandler::CollectGarbageL()

	{

    PUSHLOG_ENTERFN("CSIContentHandler::CollectGarbageL")

    DoCollectGarbageL();

    //Ready.

    iState = EFilteringAndParsing;

	IdleComplete();

    PUSHLOG_LEAVEFN("CSIContentHandler::CollectGarbageL")

    }

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

// CSIContentHandler::ParsePushMsgL

// Note that cXML parser dosn't do any validation!

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

//

void CSIContentHandler::ParsePushMsgL()

	{

    PUSHLOG_ENTERFN("CSIContentHandler::ParsePushMsgL")

    TPtrC8 bodyPtr;

    iMessage->GetMessageBody( bodyPtr );

    // If there is no body in the message leave with an error

    if ( bodyPtr.Size() == 0 )

        {

        PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: Empty body")

        User::Leave( KErrCorrupt );

        }

    // Get content type. It will tell us wheather the msg body is encoded or

    // textual.

    TPtrC contentType;

	iMessage->GetContentType( contentType );

    PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: HTTP header - Content type <%S>",&contentType);

    /*

    TPtrC8 encodingPtr;

    TBool encodingFound = iMessage->GetHeaderField

                          ( EHttpContentEncoding, encodingPtr );

    #ifdef __TEST_LOG__

    TBuf<64> encodingBuf;

    encodingBuf.Copy( encodingPtr );

    PUSHLOG_WRITE_FORMAT(" HTTP header - Content encoding <%S>",&encodingBuf);

    #endif // __TEST_LOG__

    */

    // Add SI dictionary.

    NW_WBXML_Dictionary_t* dictArray[ KNoOfDictArrays ] =

        { (NW_WBXML_Dictionary_t*)&NW_SI_WBXMLDictionary };

    NW_Status_t stat = NW_STAT_SUCCESS;

    RWbxmlDictionary wbxmlDict;

    wbxmlDict.InitializeL( KNoOfDictArrays, dictArray );

    CleanupClosePushL<RWbxmlDictionary>( wbxmlDict );

    NW_TinyDom_Handle_t domHandle;

    NW_Byte* buffer = (NW_Byte*)bodyPtr.Ptr();

    NW_Int32 length = (NW_Int32)bodyPtr.Size();

    // Let's use the content type now.

    NW_Bool encoded = ( contentType.CompareF( KSiTextContentType ) == 0 ) ?

                                                         NW_FALSE : NW_TRUE;

    // SI public identifier.

    NW_Uint32 publicID = NW_SI_PublicId;

    NW_Bool extTNotStringTable = NW_FALSE;

    NW_DOM_NodeType_t type = 0;

    /**********************************

    *   Root of DOM

    ***********************************/

    CDocumentTreeOwner* docTreeOwner = new (ELeave) CDocumentTreeOwner;

    CleanupStack::PushL( docTreeOwner );

    NW_DOM_DocumentNode_t* domNode = NW_DOM_DocumentNode_BuildTree

        (

                            &domHandle,

                            buffer,

                            length,

                            encoded,

                            publicID,

                            extTNotStringTable

        );

	if (!domNode)

		{

		PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: domNode is Null")

		}

    User::LeaveIfNull( domNode );

	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: domNode is not Null") // to be deleted

    // Let domNode be on the Cleanup Stack.

    docTreeOwner->SetDocTree( domNode );

    // It must be a document node.

    type = NW_DOM_Node_getNodeType( domNode );

    if ( type != NW_DOM_DOCUMENT_NODE )

        {

        PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: Not Document node <%d>",type)

        User::Leave( KErrArgument );

        }

    // Get character encoding (NW_Uint32)

    iCharEncoding = NW_DOM_DocumentNode_getCharacterEncoding( domNode );

    PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: Doc char encoding <%x>",iCharEncoding)

    /**********************************

    *   ELEMENT si

    ***********************************/

    // Get the first element of the document that must be an si.

	// first make sure if there any children in the dom tree, otherwise we will PANIC(in NW_DOM_DocumentNode_getDocumentElement) and crash WatcherMainThread.

	TBool domNodeHasChildNodes = EFalse;

	domNodeHasChildNodes = NW_DOM_Node_hasChildNodes( domNode );

	PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: check if Dom tree has <SI> node <%d>", domNodeHasChildNodes)

	if (!domNodeHasChildNodes)

        {

        PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: No SI element present in the dom tree. Message corrupted.")

        User::Leave( KErrCorrupt );

        }

	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: before calling getDocumentElement")

    NW_DOM_ElementNode_t* siElement =

        NW_DOM_DocumentNode_getDocumentElement( domNode );

	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: after calling getDocumentElement")

	if (!siElement)

		{

		PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: siElement is Null")

		}

	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: siElement is not Null, before leaving")

    User::LeaveIfNull( siElement );

	PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: siElement is not Null, after leaving if siElement is null")

    type = NW_DOM_Node_getNodeType( siElement );

    CStringOwner* stringOwner = new (ELeave) CStringOwner;

    CleanupStack::PushL( stringOwner );

    NW_String_t* name = NW_String_new();

    User::LeaveIfNull( name );

    // Let name be on the Cleanup Stack.

    stringOwner->SetString( name );

    stat = NW_DOM_Node_getNodeName( siElement, name );

    User::LeaveIfError( NwxStatusToErrCode( stat ) );

    NW_Byte*  nameBuf = NW_String_getStorage( name );

    NW_Uint16 nameLen = NW_String_getCharCount( name, iCharEncoding );

    TPtrC8 namePtr( nameBuf, nameLen );

    // Now comes the validity check.

    if ( type != NW_DOM_ELEMENT_NODE || namePtr.CompareF( KSi ) != 0 )

        {

        PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: Not si element node <%d>",type)

        User::Leave( KErrArgument );

        }

    CleanupStack::PopAndDestroy( stringOwner ); // stringOwner

    /**********************************

    *   ELEMENT indication

    ***********************************/

    if ( NW_DOM_Node_hasChildNodes( siElement ) )

        {

        NW_DOM_Node_t* node = NW_DOM_Node_getFirstChild( siElement );

		if (!node)

			{

			PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: no si child nodes!")

			}

        User::LeaveIfNull( node );

        // Find the indication element.

        TBool indicationFound = EFalse;

        do {

            type = NW_DOM_Node_getNodeType( node );

            CStringOwner* stringOwner = new (ELeave) CStringOwner;

            CleanupStack::PushL( stringOwner );

            NW_String_t* name = NW_String_new();

            User::LeaveIfNull( name );

            stringOwner->SetString( name );

            stat = NW_DOM_Node_getNodeName( node, name );

			PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: getNodeName ErrCode: %d", NwxStatusToErrCode( stat ))

            User::LeaveIfError( NwxStatusToErrCode( stat ) );

            NW_Byte*  nameBuf = NW_String_getStorage( name );

            NW_Uint16 nameLen = NW_String_getCharCount( name,

                                                        iCharEncoding );

            TPtrC8 namePtr( nameBuf, nameLen );

            if ( type == NW_DOM_ELEMENT_NODE &&

                 namePtr.CompareF( KIndication ) == 0 )

                {

                // We found the indication element. Parse it.

                PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: indication under si found.")

                indicationFound = ETrue;

                NW_DOM_ElementNode_t* indicationElement =

                    REINTERPRET_CAST( NW_DOM_ElementNode_t*, node );

                ParseIndicationL( *indicationElement );

                }

            CleanupStack::PopAndDestroy( stringOwner ); // stringOwner

            if ( !indicationFound )

                {

                // Iterate next.

                node = NW_DOM_Node_getNextSibling( node );

                if ( !node )

                    {

                    PUSHLOG_WRITE("CSIContentHandler::ParsePushMsgL: No more sibling.")

                    break;

                    }

                }

            } while ( !indicationFound );

        }

    // Cleanup.

    CleanupStack::PopAndDestroy( 2, &wbxmlDict ); // docTreeOwner, wbxmlDict

    if ( !ActionFlag() )

        {

        // default if no action explicitly stated

        iPushMsgAction = CSIPushMsgEntry::ESIPushMsgSignalMedium;

        SetActionFlag( ETrue );

        PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParsePushMsgL: Defaulting to ActionFlag: %d",iPushMsgAction)

        }

    iState = EProcessing;

	IdleComplete();

    PUSHLOG_LEAVEFN("CSIContentHandler::ParsePushMsgL")

	}

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

// CSIContentHandler::ParseIndicationL

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

//

void CSIContentHandler::ParseIndicationL( NW_DOM_ElementNode_t& aIndication )

	{

    PUSHLOG_ENTERFN("CSIContentHandler::ParseIndicationL")

    NW_Status_t stat = NW_STAT_SUCCESS;

    NW_DOM_NodeType_t type = 0;

    if ( NW_DOM_ElementNode_hasAttributes( &aIndication ) )

        {

        NW_DOM_AttributeListIterator_t attrIter;

        stat = NW_DOM_ElementNode_getAttributeListIterator

                             ( &aIndication, &attrIter );

		PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParseIndicationL: getAttribListIter ErrCode: %d", NwxStatusToErrCode( stat ))

        User::LeaveIfError( NwxStatusToErrCode( stat ) );

        NW_DOM_AttributeHandle_t attrHandle;

        while ( NW_DOM_AttributeListIterator_getNextAttribute

                ( &attrIter, &attrHandle ) == NW_STAT_WBXML_ITERATE_MORE )

            {

            ParseIndAttributeL( attrHandle );

            }

        }

    /**********************************

    *   PCDATA of ELEMENT indication

    ***********************************/

    if ( NW_DOM_Node_hasChildNodes( &aIndication ) )

        {

        NW_DOM_TextNode_t* textNode =

            NW_DOM_Node_getFirstChild( &aIndication );

        User::LeaveIfNull( textNode );

        type = NW_DOM_Node_getNodeType( textNode );

        if ( type != NW_DOM_TEXT_NODE )

            {

            PUSHLOG_WRITE_FORMAT("CSIContentHandler::ParseIndicationL: Not text node <%d>",type)

            User::Leave( KErrArgument );

            }

        ParseTextL( *textNode );

        }

    PUSHLOG_LEAVEFN("CSIContentHandler::ParseIndicationL")

    }

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

// CSIContentHandler::ParseIndAttributeL

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

//

void CSIContentHandler::ParseIndAttributeL( NW_DOM_AttributeHandle_t&

                                            aAttrHandle )

	{

    PUSHLOG_ENTERFN("CSIContentHandler::ParseIndAttributeL")

    NW_Status_t stat = NW_STAT_SUCCESS;

    CStringOwner* stringOwner = new (ELeave) CStringOwner;

    CleanupStack::PushL( stringOwner );

    NW_String_t* attrName = NW_String_new();

    User::LeaveIfNull( attrName );

    stringOwner->SetString( attrName );

    // Get the name of the attribute.

    stat = NW_DOM_AttributeHandle_getName( &aAttrHandle, attrName );

    User::LeaveIfError( NwxStatusToErrCode( stat ) );

    NW_Byte*  attrNameBuf = NW_String_getStorage( attrName );

    NW_Uint16 attrNameLen = NW_String_getCharCount( attrName, iCharEncoding );

    TPtrC8 attrNamePtr( attrNameBuf, attrNameLen );

    if ( attrNamePtr.CompareF( KCreatedAttrib ) == 0 )

        {

        if ( CreatedFlag() )

            {

            PUSHLOG_WRITE(" created redefinition")

            User::Leave( KErrCorrupt );

            }

        else

            {

            TBool gotDate = AttributeToTTimeL( aAttrHandle, iCreatedTime );

            SetCreatedFlag( gotDate );

            PUSHLOG_WRITE_FORMAT(" iCreatedTime set %d",gotDate?1:0)

            }

        }

    else if ( attrNamePtr.CompareF( KHrefAttrib ) == 0 )

        {

        if ( HrefFlag() )

            {

            PUSHLOG_WRITE(" href redefinition")

            User::Leave( KErrCorrupt );

            }

        else

            {

            CStringOwner* stringOwner = new (ELeave) CStringOwner;

            CleanupStack::PushL( stringOwner );

            NW_String_t* val = NW_String_new();

            User::LeaveIfNull( val );

            stringOwner->SetString( val );

            stat = NW_DOM_AttributeHandle_getValue( &aAttrHandle, val );

            if ( stat != NW_STAT_DOM_NO_STRING_RETURNED )

                {

                User::LeaveIfError( NwxStatusToErrCode( stat ) );

                NW_Byte* storage = NW_String_getStorage( val );

                NW_Uint16 length = NW_String_getCharCount( val,

                                                           iCharEncoding );

                if ( length == 0 )

                    {

                    // Zero length href attribute is considered as missing.

                    PUSHLOG_WRITE(" Zero length HrefFlag");

                    }

                else

                    {

                    TPtrC8 hrefPtr( storage, length );

                    HBufC* tempHrefBuf = HBufC::NewMaxL( length );

                    // No leavable after it!!! until...

                    tempHrefBuf->Des().Copy( hrefPtr );

                    iHrefBuf = tempHrefBuf; // ...until here.

                    SetHrefFlag( ETrue );

                    PUSHLOG_WRITE_FORMAT(" HrefFlag set <%S>",iHrefBuf);

                    }

                }

            CleanupStack::PopAndDestroy( stringOwner ); // stringOwner

            }

        }

    else if ( attrNamePtr.CompareF( KExpiresAttrib ) == 0 )

        {

        if ( ExpiresFlag() )

            {

            PUSHLOG_WRITE(" expires redefinition")

            User::Leave( KErrCorrupt );

            }

        else

            {

            TBool gotDate = AttributeToTTimeL( aAttrHandle, iExpiresTime );

            SetExpiresFlag( gotDate );

            PUSHLOG_WRITE_FORMAT(" iExpiresTime set %d",gotDate?1:0)

            }