/*

* 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 <limits.h>

#include "ncdloadnodeoperationimpl.h"

#include "ncdoperationfunctionids.h"

#include "catalogsbasemessage.h"

#include "catalogsbigdes.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_pp_error.h"

#include "ncd_pp_datablock.h"

#include "ncd_pp_icon.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 "ncdoperationobserver.h"

#include "catalogssession.h"

#include "ncdnodeimpl.h"

#include "ncdnodelink.h"

#include "ncdqueryimpl.h"

#include "catalogsutils.h"

#include "ncd_cp_query.h"

#include "ncdnodemetadata.h"

#include "ncdnodemetadataimpl.h"

#include "ncderrors.h"

#include "ncdoperationremovehandler.h"

#include "ncdnodeiconimpl.h"

#include "ncdsessionhandler.h"

#include "ncdnodefactory.h"

#include "ncdnodeidentifiereditor.h"

#include "ncdexpirednode.h"

#include "ncdhttputils.h"

#include "ncdproviderutils.h"

#include "catalogshttpincludes.h"

#include "ncdnodeseeninfo.h"

#include "ncdchildentity.h"

#include "ncdoperationqueue.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

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

// ?description_if_needed

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

//

CNcdLoadNodeOperationImpl* CNcdLoadNodeOperationImpl::NewL(

    const CNcdNodeIdentifier& aNodeIdentifier,

    const CNcdNodeIdentifier& aParentIdentifier,

    CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

    TNcdResponseFilterParams aFilterParams,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue* aOperationQueue,

    MCatalogsSession& aSession,

    TBool aLoadChildren,

    TNcdChildLoadMode aMode,

    TBool aIsSubOperation,

    TBool aCreateParent )

    {

    CNcdLoadNodeOperationImpl* self = CNcdLoadNodeOperationImpl::NewLC(

        aNodeIdentifier,

        aParentIdentifier,

        aParentNodePurpose,

        aFilterParams,        

        aGeneralManager,

        aHttpSession,

        aRemoveHandler,

        aOperationQueue,

        aSession,

        aLoadChildren,

        aMode,

        aIsSubOperation,

        aCreateParent );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadNodeOperationImpl* CNcdLoadNodeOperationImpl::NewLC(

    const CNcdNodeIdentifier& aNodeIdentifier,

    const CNcdNodeIdentifier& aParentIdentifier,

    CNcdNodeFactory::TNcdNodePurpose aParentNodePurpose,

    TNcdResponseFilterParams aFilterParams,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MNcdOperationQueue* aOperationQueue,

    MCatalogsSession& aSession,

    TBool aLoadChildren,

    TNcdChildLoadMode aMode,

    TBool aIsSubOperation,

    TBool aCreateParent )

    {

    CNcdLoadNodeOperationImpl* self =

        new( ELeave ) CNcdLoadNodeOperationImpl( 

            aParentNodePurpose, 

            aFilterParams,

            aMode, 

            aLoadChildren, 

            aGeneralManager, 

            aHttpSession,

            aRemoveHandler, 

            aOperationQueue, 

            aSession, 

            aIsSubOperation, 

            aCreateParent );

    CleanupClosePushL( *self );

    self->ConstructL( aNodeIdentifier, aParentIdentifier );

    return self;

    }

CNcdLoadNodeOperationImpl* CNcdLoadNodeOperationImpl::NewLC(

    CNcdContentSource& aContentSource,

    CNcdContentSourceMap* aContentSourceMap,

    const CNcdNodeIdentifier& aParentIdentifier,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdLoadNodeOperationImpl* self =

        new( ELeave ) CNcdLoadNodeOperationImpl( 

            aGeneralManager, 

            aHttpSession, 

			aRemoveHandler, 

			aSession );

    CleanupClosePushL( *self );

    self->ConstructL( aContentSource, aContentSourceMap, aParentIdentifier );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdLoadNodeOperationImpl::~CNcdLoadNodeOperationImpl()

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    // If the operation proxy is released without cancelling, eg. UI exits 

    // while node loading is going on, then the operation is not removed

    // from the operation queue.

    //

    // HandleReleaseMessage() would be a bit better place for this but I

    // don't want to implement it just for this :)

    NotifyCompletionOfQueuedOperation( ENCDOperationMessageCompletionComplete );

    delete iNodeIdentifier;

    delete iServerUri;

    delete iParentIdentifier;

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

    if( iLoadNodeQuery )

        {

        iLoadNodeQuery->InternalRelease();

        }

    iSubOpQuerys.Close();

    DLTRACE(("Deleting iLoadedNodes"));

    iLoadedNodes.ResetAndDestroy();

    DLTRACE(("Deleting iParser"));

    delete iParser;

    DLTRACE(("Releasing iTransaction"));

    if ( iTransaction )

        {

        iTransaction->Release();

        }

    DLTRACE(("Releasing iHttpSession"));

    iHttpSession.Release();

    iRemoteFolders.ResetAndDestroy();

    iTransparentChildFolders.ResetAndDestroy();

    iTransparentChildItems.ResetAndDestroy();

    iNodeIconMaps.ResetAndDestroy();

    DLTRACEOUT((""));  

    }

CNcdLoadNodeOperationImpl::TLoadNodeOperationState

    CNcdLoadNodeOperationImpl::State()

    {

    return iLoadNodeState;

    }

const RPointerArray<CNcdNodeIdentifier>&

    CNcdLoadNodeOperationImpl::LoadedNodes()

    {

    return iLoadedNodes;

    }

const CNcdNodeIdentifier* CNcdLoadNodeOperationImpl::NodeIdentifier() const

    {

    return iNodeIdentifier;

    }

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

// ?implementation_description

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

//

TInt CNcdLoadNodeOperationImpl::Start()

    {

    DLTRACEIN((""));

    if ( iOperationState == EStateStopped )

        {

        // Op not yet running, queue it

        iOperationState = EStateRunning;

        TInt err;

        // Do not add sub operations to queue, since the parent operation will jam then.

        if ( IsSubOperation() )

            {

            err = RunOperation();

            }

        else

            {

            DASSERT( iOperationQueue );            

            TRAP( err, iOperationQueue->QueueOperationL( *this ) );        

            }

        return err;

        }

    else

        {

        return KErrInUse;

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadNodeOperationImpl::Cancel()

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    if ( iTransaction )

        {

        iTransaction->Cancel();

        iTransaction = NULL;

        }

    if ( iParser )

        {

        iParser->CancelParsing();

        }

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

        {

        CNcdLoadNodeOperationImpl* operation = iSubOps[i];

        if ( iCompletedSubOps.Find( operation ) == KErrNotFound &&

             iFailedSubOps.Find( operation ) == KErrNotFound ) 

            {

            operation->Cancel();

            }

        } 

    DLTRACEOUT((""));

    }

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

// ?implementation_description

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

//

void CNcdLoadNodeOperationImpl::HandleCancelMessage( MCatalogsBaseMessage* aMessage ) 

    {

    DLTRACEIN((""));

    CNcdBaseOperation::HandleCancelMessage( aMessage );

    if ( !IsSubOperation() )

        {

        DASSERT( iOperationQueue );    

        iOperationQueue->QueuedOperationComplete( *this );

        }

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadNodeOperationImpl::CompleteMessage(

    MCatalogsBaseMessage* & aMessage,

    TNcdOperationMessageCompletionId aId,

    const MNcdSendable& aSendableObject,

    TInt aStatus ) 

    {

    DLTRACEIN((""));    

    NotifyCompletionOfQueuedOperation( aId );

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

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadNodeOperationImpl::CompleteMessage(

    MCatalogsBaseMessage* & aMessage,

    TNcdOperationMessageCompletionId aId,

    TInt aStatus )

    {

    DLTRACEIN((""));

    NotifyCompletionOfQueuedOperation( aId );

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

    }

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

// ?implementation_description

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

//    

TInt CNcdLoadNodeOperationImpl::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 CNcdLoadNodeOperationImpl::CompleteMessage(

    MCatalogsBaseMessage*& aMessage,

    TNcdOperationMessageCompletionId aId,

    RPointerArray<CNcdExpiredNode>& aExpiredNodes,

    TInt aStatus )

    {

    DLTRACEIN((""));

    NotifyCompletionOfQueuedOperation( aId );

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

    }

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

// ?implementation_description

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

//

void CNcdLoadNodeOperationImpl::HandleHttpEventL( 

        MCatalogsHttpOperation& aOperation, 

        TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN(( "this-ptr: %X", this ));

    DASSERT( &aOperation == iTransaction );

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

    TCatalogsTransportProgress progress( iTransaction->Progress() );

    // Are state and id needed?

    iProgress = TNcdSendableProgress( iLoadNodeState,

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

        progress.iMaxProgress );

    switch( aEvent.iOperationState ) 

        {

        // Handle completed operation

        case ECatalogsHttpOpCompleted:

            {

            ReleasePtr( iTransaction );

            // Inform parser that no more data will be sent

            iParser->EndL();

            break;

            }        

        // Handle operation in progress

        case ECatalogsHttpOpInProgress:

            {

            if ( aEvent.iProgressState == ECatalogsHttpResponseBodyReceived )

                {

                // send received data to parser

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

                }

            break;

            }

        default:

            {

            break;

            }

        }

    DLTRACEOUT((""));    

    }

TBool CNcdLoadNodeOperationImpl::HandleHttpError( 

    MCatalogsHttpOperation& aOperation, 

    TCatalogsHttpError aError )    

    {

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

    DLINFO(( "this-ptr: %X", this ));

    DASSERT( &aOperation == iTransaction );

    if ( iLoadMode == EContentSource )

        {

        iContentSource->SetBroken( ETrue );

        }

    aOperation.Release();

    iTransaction = NULL;

    iError = aError.iError;

    iLoadNodeState = EFailed;

    RunOperation();

    DLTRACEOUT((""));

    return ETrue;

    }

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

// ?implementation_description

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

//

void CNcdLoadNodeOperationImpl::ParseError( TInt aErrorCode )

    {

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

    DLINFO(( "this-ptr: %X", this ));

    // Hanlde only if this operation isn't already handling an error.

    // Canceling parsing may lead to such a situation.

    if( iLoadNodeState == EReceive && iError == KErrNone )

        {

        iLoadNodeState = EFailed;

        iError = aErrorCode;

        if ( iTransaction )

            {

            iTransaction->Cancel();        

            iTransaction = NULL;

            }

        // There's nothing we can do for errors here

        TRAP_IGNORE( ContinueOperationL() );

        }

    }

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

// ?implementation_description

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

//

void CNcdLoadNodeOperationImpl::ParseCompleteL( TInt aError )

    {

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

    DLINFO(( "this-ptr: %X", this ));   

    if ( aError != KErrNone )

        {

        iError = aError;

        iLoadNodeState = EFailed;        

        ContinueOperationL();

        }

    // if iError != KErrNone, the error has already been handled

    else if ( iError == KErrNone )

        {

        DASSERT( iLoadNodeState == EReceive );

        // Completed queries have been responded to successfully, remove them.

        ClearCompletedQueries();

        if ( QueriesPending() )

            {

            HandleQuerysL();

            }

        else if ( RemoteFolderCount() )

            {

            // remote folders need to be loaded next

            iLoadNodeState = ERemote;

            ContinueOperationL();            

            }

        else

            {

            // no querys received, go to next state