/*

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

*

*/

#include <badesca.h>

#include <s32mem.h>

#include "ncdloadrootnodeoperationimpl.h"

#include "ncdoperationfunctionids.h"

#include "catalogsbasemessage.h"

#include "catalogshttpsession.h"

#include "catalogshttpoperation.h"

#include "catalogshttpconfig.h"

#include "catalogsbigdes.h"

#include "catalogsaccesspointmanagerimpl.h"

#include "ncdrequestgenerator.h"

#include "ncdrequestbase.h"

#include "ncdrequestbrowsesearch.h"

#include "ncdrequestconfiguration.h"

#include "ncd_pp_itemref.h"

#include "ncd_pp_folderref.h"

#include "ncd_pp_dataentity.h"

#include "ncd_cp_query.h"

#include "ncd_cp_queryelement.h"

#include "ncd_cp_queryoption.h"

#include "ncdprotocolutils.h"

#include "ncdprotocol.h"

#include "ncdprotocolimpl.h"

#include "ncdparser.h"

#include "ncdnodemanager.h"

#include "ncdproviderdefines.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeclassids.h"

#include "ncdnodefolder.h"

#include "ncdrootnode.h"

#include "ncdbundlefolder.h"

#include "ncdloadnodeoperationimpl.h"

#include "ncd_cp_detail.h"

#include "ncd_cp_clientconfiguration.h"

#include "ncd_cp_error.h"

#include "catalogscontext.h"

#include "ncd_cp_serverdetails.h"

#include "ncdqueryimpl.h"

#include "ncdnodelink.h"

#include "ncd_cp_queryresponseimpl.h"

#include "catalogsutils.h"

#include "ncderrors.h"

#include "ncdconfigurationmanager.h"

#include "ncdoperationremovehandler.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodeiconimpl.h"

#include "ncdsessionhandler.h"

#include "ncd_pp_error.h"

#include "ncdconfigurationkeys.h"

#include "ncdutils.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdnodeidentifier.h"

#include "ncdchildentity.h"

#include "ncdprotocolstrings.h"

#include "ncdnodeseeninfo.h"

#include "ncdchildentitymap.h"

#include "ncdproviderutils.h"

#include "ncdhttputils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

// ?description_if_needed

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

//

CNcdLoadRootNodeOperation* CNcdLoadRootNodeOperation::NewL(

    TInt aClientUid,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdLoadRootNodeOperation* self = CNcdLoadRootNodeOperation::NewLC(

        aClientUid,

        aGeneralManager,

        aHttpSession,

        aRemoveHandler,

        aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadRootNodeOperation* CNcdLoadRootNodeOperation::NewLC(

    TInt aClientUid,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdLoadRootNodeOperation* self =

        new( ELeave ) CNcdLoadRootNodeOperation( 

            aClientUid, 

            aGeneralManager,

            aHttpSession,

            aRemoveHandler, 

            aSession );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadRootNodeOperation::~CNcdLoadRootNodeOperation()

    {

    DLTRACEIN((""));

    DASSERT( !iNodeDbLocked );

    iConfigManager.RemoveObserver( *this );

    iLoadedNodes.ResetAndDestroy();

    DLTRACE(("Delete id, buffer"));

    delete iRootNodeIdentifier;

    DLTRACE(("Delete parser"));

    delete iParser;

    if ( iTransaction )

        {

        DLTRACE(("Releasing transaction"));

        iTransaction->Release();

        }

    DLTRACE(("Delete loaded nodes"));

    iLoadedNodes.ResetAndDestroy();

    DLTRACE(("Closing suboperations"));

    // Close operations

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

        {

        iSubOps[i]->Close();        

        }

    DLTRACE(("Suboperations closed"));

    iSubOps.Reset();

    iFailedSubOps.Reset();

    iCompletedSubOps.Reset();

    DLTRACE(("Deleting content sources"));

    delete iContentSourceMap;

    DLTRACE(("Delete conf response buffer"));

    delete iConfigResponseBuf;

    if( iConfQuery )

        {

        iConfQuery->InternalRelease();

        }

    iSubOpQuerys.Close();

    delete iServerUri;

    iChildEntityMaps.ResetAndDestroy();

    DLTRACEOUT((""));

    }

const CNcdNodeIdentifier& CNcdLoadRootNodeOperation::NodeIdentifier() const

    {

    return *iRootNodeIdentifier;

    }

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

// ?implementation_description

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

//

void CNcdLoadRootNodeOperation::HandleCancelMessage( MCatalogsBaseMessage* aMessage ) 

    {

    DLTRACEIN((""));

    Cancel();

    CNcdBaseOperation::HandleCancelMessage( aMessage );

    }

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

// ?implementation_description

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

//

void CNcdLoadRootNodeOperation::Cancel()

    {

    DLTRACEIN( ( "" ) );

    if ( iTransaction )

        {

        iTransaction->Cancel();        

        iTransaction = NULL;

        }

    if ( iParser )

        {

        iParser->CancelParsing();

        }    

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

        {

        iSubOps[i]->Cancel();

        iSubOps[i]->Close();

        }

    iSubOps.Reset();

    if ( iNodeDbLocked ) 

        {        

        iNodeManager->UnlockNodeDb( TUid::Uid( iClientUid ) );

        iNodeDbLocked = EFalse;

        TRAP_IGNORE( iNodeManager->RevertNodeCacheL( *iRootNodeIdentifier ) );

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadRootNodeOperation::HandleHttpEventL( 

        MCatalogsHttpOperation& aOperation, 

        TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN((""));

    DASSERT( &aOperation == iTransaction );

    DASSERT( aOperation.OperationType() == ECatalogsHttpTransaction );

    TCatalogsTransportProgress progress( iTransaction->Progress() );

    // Are state and id needed?

    iProgress = TNcdSendableProgress( iRootNodeState,

        iTransaction->OperationId().Id(), progress.iProgress,

        progress.iMaxProgress );

    switch( aEvent.iOperationState ) 

        {

        // Handle completed operation

        case ECatalogsHttpOpCompleted:

            {

            iTransaction->Release();

            iTransaction = NULL;

            // Inform parser that no more data will be sent

            iParser->EndL();

            break;

            }     

        // Handle operation in progress

        case ECatalogsHttpOpInProgress:

            {

            if( aEvent.iProgressState == ECatalogsHttpResponseBodyReceived )

                {

                // If config response, append the contents to the buffer.

                if ( iRootNodeState == EReceiveConf ) 

                    {

                    iConfigResponseBuf->InsertL(

                        iConfigResponseBuf->Size(), aOperation.Body() );                        

                    }               

                // send received data to parser

                iParser->ParseL( aOperation.Body() );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

TBool CNcdLoadRootNodeOperation::HandleHttpError( 

    MCatalogsHttpOperation& aOperation, 

    TCatalogsHttpError aError )    

    {

    DLTRACEIN(("Error type: %d, code: %d", aError.iType, aError.iError ));    

    DASSERT( &aOperation == iTransaction );

    aOperation.Release();

    iTransaction = NULL;

    if ( iMasterServerRedirectionState == ERedirecting ) 

        {

        // Return back to original master server uri.

        iConfigManager.RemoveObserver( *this );

        TRAPD(err, iConfigManager.ResetMasterServerAddressL(

            iPendingMessage->Session().Context() ));

        if( err != KErrNone )

            {

            iError = err;

            iRootNodeState = EFailed;

            }

        else

            {

            iMasterServerRedirectionState = EReverted;

            iRootNodeState = EConfRequest;

            }

        }

    else

        {

        iError = aError.iError;

        iRootNodeState = EFailed;

        }

    RunOperation();

    return ETrue;

    }

void CNcdLoadRootNodeOperation::ParseError( TInt aErrorCode )

    {

    DLTRACEIN(("error:%d", aErrorCode ));

    // Handle error only if not handling an error already

    // (cancellation of parsing may cause an unnecessary call to this function).

    if ( iError == KErrNone )

        {

        if ( iMasterServerRedirectionState == ERedirecting ) 

            {

            // Return back to original master server uri.

            iConfigManager.RemoveObserver( *this );

            TRAPD(err, iConfigManager.ResetMasterServerAddressL(

                iPendingMessage->Session().Context() ));

            if( err != KErrNone )

                {

                iError = err;

                iRootNodeState = EFailed;

                }

            else

                {

                iMasterServerRedirectionState = EReverted;

                iRootNodeState = EConfRequest;

                }

            }

        else 

            {            

            iRootNodeState = EFailed;

            iError = aErrorCode;

            }

        if ( iTransaction )

            {

            iTransaction->Cancel();

            iTransaction = NULL;

            }

        if ( iParser )

            {

            iParser->CancelParsing();

            }

        RunOperation();

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadRootNodeOperation::ParseCompleteL( TInt aError )

    {

    DLTRACEIN((_L("error:%d"), aError ));

    if ( iParser )

        {

        delete iParser;

        iParser = NULL;

        }

    if ( aError != KErrNone )

        {

        DLTRACE(("Parsing error, stop operation!"))

        iError = aError;

        iRootNodeState = EFailed;

        RunOperation();

        }

    else

        {

        DASSERT( iRootNodeState == EReceiveConf || iRootNodeState == EConfRequest );

        if ( iConfQuery )

            {

            DLTRACE(("Query received, let base op handle it"));

            iRootNodeState = EConfQuery;

            // let base op handle the query

            TRAPD( err, CNcdBaseOperation::QueryReceivedL( iConfQuery ) );

            if ( err != KErrNone ) 

                {

                iError = err;

                iRootNodeState = EFailed;

                RunOperation();

                }

            }

        else if ( iRootNodeState == EConfRequest ) 

            {

            DASSERT( iMasterServerRedirectionState == ERedirecting );

            RunOperation();

            }

        else if ( iContentSourceMap->ContentSourceCount() < 1 &&

                  iContentSourceMap->BundleFolderCount() < 1 )

            {

            iError = KNcdErrorNoContentSources;

            iRootNodeState = EFailed;

            DLINFO(("No content sources received, stop operation!"))

            RunOperation();

            }

        else

            {            

            iRootNodeState = EBrowseRequest;

            RunOperation();

            }

        }

    DLTRACEOUT((""));

    }

void CNcdLoadRootNodeOperation::ConfigurationBeginL( const TDesC& aVersion, 

                                                     TInt aExpirationDelta )

    {

    DLTRACEIN((""));

    // set expiration delta for root node

    // No need to set metadata value for root, because it does not have one.

    iNodeManager->RootNodeL( iRootNodeIdentifier->ClientUid() ).

        CreateAndSetLinkL().SetValidUntilDelta( aExpirationDelta );

	// Pass to default observer.

	DASSERT( iDefaultConfigurationProtocolObserver != NULL );

    iDefaultConfigurationProtocolObserver->ConfigurationBeginL( aVersion, aExpirationDelta );

    DLTRACEOUT((""));

    }

void CNcdLoadRootNodeOperation::ConfigurationQueryL(

    MNcdConfigurationProtocolQuery* aQuery )

    {

    DLTRACEIN((""));

    DASSERT( !iConfQuery );

    CleanupDeletePushL( aQuery );

    // create a query object form the protocol entity

    iConfQuery = CNcdQuery::NewL( *aQuery, IsHttpsUri( *iServerUri ) );

    CleanupStack::Pop( aQuery );    

	// Pass ownership to default observer.

	DASSERT( iDefaultConfigurationProtocolObserver != NULL );

    iDefaultConfigurationProtocolObserver->ConfigurationQueryL( aQuery );

    DLTRACEOUT((""));

    }

void CNcdLoadRootNodeOperation::ClientConfigurationL(

    MNcdConfigurationProtocolClientConfiguration* aConfiguration )

    {

    DLTRACEIN((""));

    CleanupDeletePushL( aConfiguration );

    if ( !iNodeDbLocked )

        {        

        iNodeManager->LockNodeDbL( TUid::Uid( iClientUid ) );        

        iNodeDbLocked = ETrue;

        }

    DLINFO(("detail count:%d", aConfiguration->DetailCount()));

    // Parse access point data from client configuration response.

    iAccessPointManager.ParseAccessPointDataFromClientConfL(

        *aConfiguration, iPendingMessage->Session().Context().FamilyId() );

    iBundleInsertIndex = 0;

    for( TInt i = 0 ; i < aConfiguration->DetailCount() ; i++ )

        {

        const MNcdConfigurationProtocolDetail& detail = aConfiguration->DetailL( i );

        DLINFO((_L("detail: id=%S value=%S"), &detail.Id(), &detail.Value() ));

        if ( detail.Id() != KContentSources )

            {

            continue;

            }

        const RPointerArray<MNcdConfigurationProtocolDetail>& csDetails =

            detail.Details();

        DLINFO(("csDetails count=%d", csDetails.Count()));

        for ( TInt j = 0 ; j < csDetails.Count() ; j++ )

            {            

            MNcdConfigurationProtocolDetail* csDetail = csDetails[j];

            DLINFO((_L("csDetail: id=%S value=%S"), &csDetail->Id(), &csDetail->Value() ));

            if ( csDetail->Id() != KNameSpace )

                {

                continue;

                }

            if ( csDetail->GroupId() == KCatalogBundle ) 

                {

                ParseCatalogBundleL( *csDetail );

                continue;

                }

            // create a content source

            // The parameter is the parent node identifier.

            CNcdContentSource* contentSource =

                CNcdContentSource::NewLC( *iRootNodeIdentifier );

            contentSource->SetNameSpaceL( csDetail->Value() );

            // get details

            const RPointerArray<MNcdConfigurationProtocolDetail>& nsDetails =

                csDetail->Details();

            DLINFO(("nsDetails count=%d", nsDetails.Count()));

            for ( TInt k = 0 ; k < nsDetails.Count() ; k++ )

                {

                MNcdConfigurationProtocolDetail* nsDetail = nsDetails[k];

                DLINFO((_L("nsDetail: id=%S value=%S"), &nsDetail->Id(), &nsDetail->Value() ));

                if ( nsDetail->Id() == KUri )

                    {

                    contentSource->SetUriL( nsDetail->Value() );

                    }

                }

            // get contents

            const RPointerArray<MNcdConfigurationProtocolContent>& nsContents =