/*

* 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 CSLContentHandler.

*

*/

// INCLUDE FILES

#include "CSLContentHandler.h"

#include "PushMtmUtil.h"

#include "PushMtmSettings.h"

#include "PushAuthenticationUtilities.h"

#include "PushMtmLog.h"

#include "PushContentHandlerPanic.h"

#include "PushMtmAutoFetchOperation.h"

#include "PushMtmUiDef.h"

#include "StringResourceReader.h"

#include "sl_dict.h"

#include "PushContentHandlerUtils.h"

#include <push/cslpushmsgentry.h>

#include <msvids.h>

#include <apgtask.h>

#include <apgcli.h>

#include <w32std.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 <nw_string_char.h>

#include "PushMtmPrivateCRKeys.h"

#include <centralrepository.h> 

// CONSTANTS

// sl attributes / elements

_LIT8( KSl,      "sl" );

_LIT8( KHref,    "href" );

_LIT8( KAction,  "action" );

// action attribute literals

_LIT8( KExecHigh,"execute-high" );  

_LIT8( KExecLow, "execute-low" );

_LIT8( KCache,   "cache" );

// Text SL MIME type

_LIT( KSlTextContentType, "text/vnd.wap.sl" );

// Browser command to fetch an URL. See Browser API Specification!

_LIT( KBrowserCmdFetchUrl, "4 " );

const TUid KBrowserAppUid = { 0x10008D39 };

const TInt KNoOfDictArrays = 1;

/// Autofetch time delay in seconds.

const TInt KAutofetchDelayInSec = 5;

// file monitored by browser

_LIT( KPushMtmUrl, "c:\\system\\temp\\PushMtmUrl.txt" );

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

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

// CSLContentHandler::NewL

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

//

CSLContentHandler* CSLContentHandler::NewL()

	{

	CSLContentHandler* self = new (ELeave) CSLContentHandler;

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop( self );

	return self;

	}

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

// CSLContentHandler::~CSLContentHandler

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

//

CSLContentHandler::~CSLContentHandler()

	{

    PUSHLOG_ENTERFN("CSLContentHandler::~CSLContentHandler")

    Cancel();

    delete iFetchOp;

    delete iHrefBuf;

    PUSHLOG_LEAVEFN("CSLContentHandler::~CSLContentHandler")

    }

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

// CSLContentHandler::CSLContentHandler

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

//

CSLContentHandler::CSLContentHandler()

:   CPushContentHandlerBase(), 

    iSavedMsgId( KMsvNullIndexEntryId ), 

    iPushMsgAction( KErrNotFound ), 

    iSaveAsRead( EFalse )

	{

	}

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

// CSLContentHandler::ConstructL

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

//

void CSLContentHandler::ConstructL()

	{

    PUSHLOG_ENTERFN("CSLContentHandler::ConstructL")

    CRepository* PushSL = CRepository::NewL( KCRUidPushMtm );

    CleanupStack::PushL( PushSL );

    User::LeaveIfError( PushSL->Get( KPushMtmServiceEnabled , iPushSLEnabled ) );

    CleanupStack::PopAndDestroy( PushSL ); 

    CPushContentHandlerBase::ConstructL();

    // Added to Active Scheduler.

    PUSHLOG_LEAVEFN("CSLContentHandler::ConstructL")

    }

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

// CSLContentHandler::CollectGarbageL

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

//

void CSLContentHandler::CollectGarbageL()

	{

    PUSHLOG_ENTERFN("CSLContentHandler::CollectGarbageL")

    DoCollectGarbageL();

	if(iPushSLEnabled)

	    iState = EFilteringAndParsing;

	else

	    iState = EDone;

	IdleComplete();

    PUSHLOG_LEAVEFN("CSLContentHandler::CollectGarbageL")

    }

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

// CSLContentHandler::ParsePushMsgL

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

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

//

void CSLContentHandler::ParsePushMsgL()

	{

    PUSHLOG_ENTERFN("CSLContentHandler::ParsePushMsgL")

    TPtrC8 bodyPtr;

    iMessage->GetMessageBody( bodyPtr );

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

    if ( bodyPtr.Size() == 0 )

        {

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

        User::Leave( KErrCorrupt );

        }

    TPtrC contentType;

    iMessage->GetContentType( contentType );

    PUSHLOG_WRITE_FORMAT(" Content type <%S>",&contentType)

    // Add SL dictionary.

    NW_WBXML_Dictionary_t* dictArray[ KNoOfDictArrays ] = 

        { (NW_WBXML_Dictionary_t*)&NW_SL_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();

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

                                                         NW_FALSE : NW_TRUE;

    NW_Uint32 publicID = NW_SL_PublicId;

    NW_Bool extTNotStringTable = NW_FALSE; // What is this?

    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("CSLContentHandler::ParsePushMsgL: domNode is Null")

		}

    User::LeaveIfNull( domNode );

    docTreeOwner->SetDocTree( domNode );

    type = NW_DOM_Node_getNodeType( domNode );

    if ( type != NW_DOM_DOCUMENT_NODE )

        {

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

        User::Leave( KErrArgument );

        }

    iCharEncoding = NW_DOM_DocumentNode_getCharacterEncoding( domNode );

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

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

    *   ELEMENT sl

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

	// 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("CSLContentHandler::ParsePushMsgL: check if Dom tree has <SI> node <%d>", domNodeHasChildNodes)

	if (!domNodeHasChildNodes)

        {

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

        User::Leave( KErrCorrupt );

        }

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

    NW_DOM_ElementNode_t* slElement = 

        NW_DOM_DocumentNode_getDocumentElement( domNode );

	if (!slElement)

		{

		PUSHLOG_WRITE("CSLContentHandler::ParsePushMsgL: slElement is Null")

		}

    User::LeaveIfNull( slElement );

    type = NW_DOM_Node_getNodeType( slElement );

    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( slElement, name );

	PUSHLOG_WRITE_FORMAT("CSLContentHandler::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( KSl ) != 0 )

        {

        PUSHLOG_WRITE_FORMAT("CSLContentHandler::ParsePushMsgL: Not sl element node <%d>",type)

        User::Leave( KErrArgument );

        }

    CleanupStack::PopAndDestroy( stringOwner ); // stringOwner

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

    *   Attributes of ELEMENT sl

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

    if ( NW_DOM_ElementNode_hasAttributes( slElement ) )

        {

        NW_DOM_AttributeListIterator_t attrIter;

        stat = NW_DOM_ElementNode_getAttributeListIterator

                             ( slElement, &attrIter );

		PUSHLOG_WRITE_FORMAT("CSLContentHandler::ParsePushMsgL: 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 )

            {

            ParseSlAttributeL( attrHandle );

            }

        }

    // Cleanup.

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

    // if 'action' attribute not specified, the value 'execute-low' is used.

	if ( !ActionFlag() )

        {

		iPushMsgAction = CSLPushMsgEntry::ESLPushMsgExecuteLow;

        SetActionFlag( ETrue );

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

        }

    iState = EProcessing;

    IdleComplete();

    PUSHLOG_LEAVEFN("CSLContentHandler::ParsePushMsgL")

	}

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

// CSLContentHandler::ParseSlAttributeL

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

//

void CSLContentHandler::ParseSlAttributeL

                        ( NW_DOM_AttributeHandle_t& aAttrHandle )

	{

    PUSHLOG_ENTERFN("CSLContentHandler::ParseSlAttributeL")

    NW_Status_t stat = NW_STAT_SUCCESS;

    CStringOwner* attrNameOwner = new (ELeave) CStringOwner;

    CleanupStack::PushL( attrNameOwner );

    NW_String_t* attrName = NW_String_new();

    User::LeaveIfNull( attrName );

    attrNameOwner->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( KHref ) == 0 )

        {

        if ( !HrefFlag() )

            {

            HBufC* tempHrefBuf = NULL;

            CStringOwner* valOwner = new (ELeave) CStringOwner;

            CleanupStack::PushL( valOwner );

            NW_String_t* val = NW_String_new();

            User::LeaveIfNull( val );

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

                TPtrC8 prefixPtr( storage, length );

                tempHrefBuf = HBufC::NewMaxL( length );

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

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

                }

            CleanupStack::PopAndDestroy( valOwner ); // valOwner

            if ( tempHrefBuf )

                {

                if ( tempHrefBuf->Length() == 0 )

                    {

                    // Zero length Href is considered as nothing.

                    PUSHLOG_WRITE(" Zero length HrefFlag");

                    }

                else

                    {

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

                    SetHrefFlag( ETrue );

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

                    }

                }

            }

        }

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

        {

        if ( !ActionFlag() )

            {

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

            User::LeaveIfError( NwxStatusToErrCode( stat ) );

            NW_Byte* storage = NW_String_getStorage( val );

            NW_Uint16 length = NW_String_getCharCount( val, iCharEncoding );

            TPtrC8 actionPtr( storage, length );

            iPushMsgAction = ConvertActionString( actionPtr );

            SetActionFlag( ETrue );

            PUSHLOG_WRITE_FORMAT(" ActionFlag: %d",iPushMsgAction)

            CleanupStack::PopAndDestroy( stringOwner );

            }

        }

    else

        {

        __ASSERT_DEBUG( EFalse, 

            ContHandPanic( EPushContHandPanUnexpSlToken ) );

        }

    CleanupStack::PopAndDestroy( attrNameOwner ); // attrNameOwner

    PUSHLOG_LEAVEFN("CSLContentHandler::ParseSlAttributeL")

    }

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

// CSLContentHandler::ConvertActionString

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

//

TUint CSLContentHandler::ConvertActionString

                         ( const TDesC8& aActionString ) const

	{

	const TInt KMatchFound = 0;

	// if 'action' attribute not specified, the value 'execute-low' is used.

	TUint actionValue = CSLPushMsgEntry::ESLPushMsgExecuteLow;

	if ( aActionString.Compare( KExecHigh ) == KMatchFound )

        {

		actionValue = CSLPushMsgEntry::ESLPushMsgExecuteHigh;

        }

	else if ( aActionString.Compare( KExecLow ) == KMatchFound )

        {

		actionValue = CSLPushMsgEntry::ESLPushMsgExecuteLow;

        }

	else if ( aActionString.Compare( KCache ) == KMatchFound )

        {

		actionValue = CSLPushMsgEntry::ESLPushMsgExecuteCache;

        }

	return actionValue;

	}

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

// CSLContentHandler::SetSlPushMsgEntryFieldsL

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

//

void CSLContentHandler::SetSlPushMsgEntryFieldsL( CSLPushMsgEntry& 

                                                  aSlPushMsgEntry ) const

	{

    PUSHLOG_ENTERFN("CSLContentHandler::SetSlPushMsgEntryFieldsL")

	// Set URL and Action fields.

    if ( HrefFlag() )

        {

	    aSlPushMsgEntry.SetUrlL( *iHrefBuf );

        }

    __ASSERT_DEBUG( ActionFlag(), 

                    ContHandPanic( EPushContHandPanUnspecSlAction ) );

    if ( ActionFlag() )

        {

	    aSlPushMsgEntry.SetAction( iPushMsgAction );

        }

    else // if not specified, the value 'execute-low' is used.

        {

        aSlPushMsgEntry.SetAction( CSLPushMsgEntry::ESLPushMsgExecuteLow );

        }

	// Set all the relevant header fields.

	TPtrC8 msgHeaderPtr;

	iMessage->GetHeader( msgHeaderPtr );

	aSlPushMsgEntry.SetHeaderL( msgHeaderPtr );

    // Get server address.

    TPtrC8 srvAddress;

    if ( iMessage->GetServerAddress( srvAddress ) )

        {

	    aSlPushMsgEntry.SetFromL( srvAddress );

        }

    // First line in Inbox: TMsvEntry::iDetails.

    if ( srvAddress.Length() == 0 )

        {

        // Read from resource.

        HBufC* details = 

            iStrRscReader->AllocReadResourceLC( R_PUSHMISC_UNK_SENDER );

        aSlPushMsgEntry.SetMsgDetailsL( *details );

        CleanupStack::PopAndDestroy( details );

        }

    else

        {

        // Convert the "From" information to the format required by the UI 

        // spec and then decode it.

        HBufC* details = iWapPushUtils->ConvertDetailsL( srvAddress );

        CleanupStack::PushL( details );

        HBufC* convertedFrom = 

            CPushMtmUtil::ConvertUriToDisplayFormL( *details );

        CleanupStack::PushL( convertedFrom );

        //

        aSlPushMsgEntry.SetMsgDetailsL( *convertedFrom );

        //

        CleanupStack::PopAndDestroy( 2, details ); // convertedFrom, details

        }

    // Second line in Inbox: TMsvEntry::iDescription.

    // Read from resource.

    HBufC* description = 

        iStrRscReader->AllocReadResourceLC( R_PUSHMISC_INBOX_SERV_MSG );

    aSlPushMsgEntry.SetMsgDescriptionL( *description );

    CleanupStack::PopAndDestroy( description );

    // ******** Push MTM specific processing *********

    /*

    * Unfortunately in CPushMsgEntryBase there is no such functionality 

    * with which we can reach TMsvEntry as non-const, but we have to 

    * modify the entry's iMtmData2 member somehow. We can do it 

    * with either casting or with modifying and saving the entry 

    * manually after it has been saved by CSLPushMsgEntry. The latter 

    * solution is more expensive so we choose the first.

    */

    TMsvEntry& tEntry = CONST_CAST( TMsvEntry&, aSlPushMsgEntry.Entry() );

    if ( HrefFlag() )

        {

        CPushMtmUtil::SetAttrs( tEntry, EPushMtmAttrHasHref );

        }

    else

        {

        CPushMtmUtil::ResetAttrs( tEntry, EPushMtmAttrHasHref );

        }

    // Indication is required if the entry is saved as 'read' (delete & 

    // replacement notification). It can happen only in case of SL message.

    // Otherwise the flag has to be cleared!

    if ( !iSaveAsRead )