/*

* 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 "ncdloadbundlenodeoperationimpl.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 "ncdprotocolstrings.h"

#include "ncdnodeseeninfo.h"

#include "ncdchildentitymap.h"

#include "ncdproviderutils.h"

#include "ncdhttputils.h"

#include "ncdoperationqueue.h"

#include "ncdgeneralmanager.h"

#include "ncd_cp_queryimpl.h"

#include "ncdstring.h"

#include "ncdnodedisclaimer.h"

#include "catalogsdebug.h"

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

// ?description_if_needed

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

//

CNcdLoadBundleNodeOperation* CNcdLoadBundleNodeOperation::NewL(

    const CNcdNodeIdentifier& aNodeIdentifier,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue& aOperationQueue,

    MCatalogsSession& aSession )

    {

    CNcdLoadBundleNodeOperation* self = CNcdLoadBundleNodeOperation::NewLC(

        aNodeIdentifier,

        aGeneralManager,

        aHttpSession,

        aRemoveHandler,

        aOperationQueue,

        aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadBundleNodeOperation* CNcdLoadBundleNodeOperation::NewLC(

    const CNcdNodeIdentifier& aNodeIdentifier,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue& aOperationQueue,

    MCatalogsSession& aSession )

    {

    CNcdLoadBundleNodeOperation* self =

        new( ELeave ) CNcdLoadBundleNodeOperation( 

            aGeneralManager,

            aHttpSession, 

            aRemoveHandler, 

            aOperationQueue, 

            aSession );

    CleanupClosePushL( *self );

    self->ConstructL( aNodeIdentifier );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadBundleNodeOperation::~CNcdLoadBundleNodeOperation()

    {

    DLTRACEIN((""));

    DASSERT( !iNodeDbLocked );

    iConfigManager.RemoveObserver( *this );

    iLoadedNodes.ResetAndDestroy();

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

    delete iNodeIdentifier;

    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& CNcdLoadBundleNodeOperation::NodeIdentifier() const

    {

    return *iNodeIdentifier;

    }

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

// ?implementation_description

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

//

void CNcdLoadBundleNodeOperation::HandleCancelMessage( MCatalogsBaseMessage* aMessage ) 

    {

    DLTRACEIN((""));

    Cancel();

    CNcdBaseOperation::HandleCancelMessage( aMessage );

    iOperationQueue.QueuedOperationComplete( *this );

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadBundleNodeOperation::CompleteMessage(

    MCatalogsBaseMessage* & aMessage,

    TNcdOperationMessageCompletionId aId,

    const MNcdSendable& aSendableObject,

    TInt aStatus ) 

    {

    DLTRACEIN((""));    

    NotifyCompletionOfQueuedOperation( aId );

    return CNcdBaseOperation::CompleteMessage( aMessage, aId, aSendableObject, aStatus );

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadBundleNodeOperation::CompleteMessage(

    MCatalogsBaseMessage* & aMessage,

    TNcdOperationMessageCompletionId aId,

    TInt aStatus )

    {

    DLTRACEIN((""));

    NotifyCompletionOfQueuedOperation( aId );

    return CNcdBaseOperation::CompleteMessage( aMessage, aId, aStatus );

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadBundleNodeOperation::CompleteMessage(

    MCatalogsBaseMessage*& aMessage,

    TNcdOperationMessageCompletionId aId,

    const MNcdSendable& aSendableObject,

    RPointerArray<CNcdNodeIdentifier>& aNodes,

    TInt aStatus )

    {

    DLTRACEIN((""));

    NotifyCompletionOfQueuedOperation( aId );

    return CNcdBaseOperation::CompleteMessage( aMessage, aId, aSendableObject, aNodes, aStatus );

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadBundleNodeOperation::CompleteMessage(

    MCatalogsBaseMessage*& aMessage,

    TNcdOperationMessageCompletionId aId,

    RPointerArray<CNcdExpiredNode>& aExpiredNodes,

    TInt aStatus )

    {

    DLTRACEIN((""));

    NotifyCompletionOfQueuedOperation( aId );

    return CNcdBaseOperation::CompleteMessage( aMessage, aId, aExpiredNodes, aStatus );

    }

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

// ?implementation_description

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

//

TInt CNcdLoadBundleNodeOperation::Start()

    {

    DLTRACEIN((""));

    if ( iOperationState == EStateStopped )

        {

        // Op not yet running, queue it

        iOperationState = EStateRunning;                

        TRAPD( err, iOperationQueue.QueueOperationL( *this ) );        

        return err;

        }

    else

        {

        return KErrInUse;

        }

    }    

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

// ?implementation_description

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

//

void CNcdLoadBundleNodeOperation::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( iNodeIdentifier->ClientUid() );

        iNodeDbLocked = EFalse;

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

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadBundleNodeOperation::HandleHttpEventL( 

        MCatalogsHttpOperation& aOperation, 

        TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN((""));

    DASSERT( &aOperation == iTransaction );

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

    TCatalogsTransportProgress progress( iTransaction->Progress() );

    // Are state and id needed?

    iProgress = TNcdSendableProgress( iBundleNodeState,

        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 ( iBundleNodeState == EReceiveConf ) 

                    {

                    iConfigResponseBuf->InsertL(

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

                    }               

                // send received data to parser

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

                }

            break;

            }

        default:

            {

            break;

            }

        }

    }

TBool CNcdLoadBundleNodeOperation::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;

            iBundleNodeState = EFailed;

            }

        else

            {

            iMasterServerRedirectionState = EReverted;

            iBundleNodeState = EConfRequest;

            }

        }

    else

        {

        iError = aError.iError;

        iBundleNodeState = EFailed;

        }

    RunOperation();

    return ETrue;

    }

void CNcdLoadBundleNodeOperation::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;

                iBundleNodeState = EFailed;

                }

            else

                {

                iMasterServerRedirectionState = EReverted;

                iBundleNodeState = EConfRequest;

                }

            }

        else 

            {            

            iBundleNodeState = EFailed;

            iError = aErrorCode;

            }

        if ( iTransaction )

            {

            iTransaction->Cancel();

            iTransaction = NULL;

            }

        if ( iParser )

            {

            iParser->CancelParsing();

            }

        RunOperation();

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadBundleNodeOperation::ParseCompleteL( TInt aError )

    {

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

    if ( iParser )

        {

        delete iParser;

        iParser = NULL;

        }

    if ( aError != KErrNone )

        {

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

        iError = aError;

        iBundleNodeState = EFailed;

        RunOperation();

        }

    else

        {

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

        if ( iConfQuery )

            {

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

            iBundleNodeState = EConfQuery;

            // let base op handle the query

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

            if ( err != KErrNone ) 

                {

                iError = err;

                iBundleNodeState = EFailed;

                RunOperation();

                }

            }

        else if ( iBundleNodeState == EConfRequest )

            {

            DASSERT( iMasterServerRedirectionState == ERedirecting );

            RunOperation();

            }

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

            {

            iError = KNcdErrorNoContentSources;

            iBundleNodeState = EFailed;

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

            RunOperation();

            }

        else

            {            

            iBundleNodeState = EBrowseRequest;

            RunOperation();

            }

        }

    DLTRACEOUT((""));

    }

void CNcdLoadBundleNodeOperation::ConfigurationBeginL( const TDesC& aVersion, 

                                                     TInt aExpirationDelta )

    {

    DLTRACEIN((""));

    // set expiration delta for the bundle node

    iNodeManager->NodeL( *iNodeIdentifier ).

        CreateAndSetLinkL().SetValidUntilDelta( aExpirationDelta );

    // Pass to default observer.

    DASSERT( iDefaultConfigurationProtocolObserver != NULL );

    iDefaultConfigurationProtocolObserver->ConfigurationBeginL( aVersion, aExpirationDelta );

    DLTRACEOUT((""));

    }