/*

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

#include <apmstd.h>

#include "ncdsubscriptionoperationimpl.h"

#include "catalogsbasemessage.h"

#include "catalogshttpincludes.h"

#include "ncdsubscriptionmanagerimpl.h"

#include "catalogsutils.h"

#include "catalogscontext.h"

#include "ncdproviderdefines.h"

#include "ncddescriptordownloadsuboperation.h"

#include "ncdrequestmanagesubscriptions.h"

#include "ncdrequestgenerator.h"

#include "ncdrequestconfigurationdata.h"

#include "ncdprotocol.h"

#include "ncdparser.h"

#include "ncdprotocoldefaultobserver.h"

#include "ncd_pp_error.h"

#include "ncd_pp_subscription.h"

#include "ncdsubscriptionimpl.h"

#include "ncdpurchaseoperationimpl.h"

#include "ncdsubscriptiongroup.h"

#include "ncdnodeidentifier.h"

#include "ncdserverdetails.h"

#include "ncdconfigurationmanager.h"

#include "ncdcapabilities.h"

#include "ncderrors.h"

#include "ncdsessionhandler.h"

#include "ncdproviderutils.h"

#include "ncdhttputils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

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

// NewL

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

//

CNcdSubscriptionOperation* CNcdSubscriptionOperation::NewL( 

    MNcdSubscriptionOperation::TType aSubscriptionOperationType,   

    CNcdGeneralManager& aGeneralManager,

    CNcdSubscriptionManager& aSubscriptionManager,        

    MCatalogsHttpSession& aHttpSession,    

    MNcdOperationRemoveHandler& aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdSubscriptionOperation* self = CNcdSubscriptionOperation::NewLC(

        aSubscriptionOperationType,

        aGeneralManager,

        aSubscriptionManager,

        aHttpSession,

        aRemoveHandler,

        aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CNcdSubscriptionOperation* CNcdSubscriptionOperation::NewLC( 

    MNcdSubscriptionOperation::TType aSubscriptionOperationType,

    CNcdGeneralManager& aGeneralManager,

    CNcdSubscriptionManager& aSubscriptionManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler& aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdSubscriptionOperation* self =

        new( ELeave ) CNcdSubscriptionOperation( 

            aSubscriptionOperationType,

            aGeneralManager,

            aSubscriptionManager,

            aHttpSession,

            aRemoveHandler,

            aSession );

    CleanupClosePushL( *self );

    self->ConstructL( NULL, KNullDesC, KNullDesC, KNullDesC, KNullDesC );

    return self;

    }

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

// NewL

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

//

CNcdSubscriptionOperation* CNcdSubscriptionOperation::NewL(

    MNcdSubscriptionOperation::TType aSubscriptionOperationType,

    const TDesC& aPurchaseOptionId,

    const TDesC& aEntityId,

    const TDesC& aNamespace,

    const TDesC& aServerUri,

    CNcdGeneralManager& aGeneralManager,

    CNcdSubscriptionManager& aSubscriptionManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler& aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdSubscriptionOperation* self = CNcdSubscriptionOperation::NewLC(

        aSubscriptionOperationType,

        aPurchaseOptionId,

        aEntityId,

        aNamespace,

        aServerUri,

        aGeneralManager,

        aSubscriptionManager,

        aHttpSession,

        aRemoveHandler,

        aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CNcdSubscriptionOperation* CNcdSubscriptionOperation::NewLC(

    MNcdSubscriptionOperation::TType aSubscriptionOperationType,

    const TDesC& aPurchaseOptionId,

    const TDesC& aEntityId,

    const TDesC& aNamespace,

    const TDesC& aServerUri,

    CNcdGeneralManager& aGeneralManager,

    CNcdSubscriptionManager& aSubscriptionManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdOperationRemoveHandler& aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdSubscriptionOperation* self =

        new( ELeave ) CNcdSubscriptionOperation( 

            aSubscriptionOperationType,

            aGeneralManager,

            aSubscriptionManager,

            aHttpSession,

            aRemoveHandler,

            aSession );

    CleanupClosePushL( *self );

    self->ConstructL(

        NULL,

        aPurchaseOptionId,

        aEntityId,

        aNamespace,

        aServerUri );

    return self;

    }

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

// Destructor

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

//

CNcdSubscriptionOperation::~CNcdSubscriptionOperation()

    {

    DLTRACEIN((""));    

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

        {

        iTransaction->Release();

        iTransaction = NULL;

        }

    iServersSubscriptions.ResetAndDestroy();

    delete iSource;

    delete iPurchaseOptionId;

    delete iEntityId;

    delete iNamespace;

    delete iServerUri;

    delete iParser;

    DLTRACEOUT((""));

    }

TInt CNcdSubscriptionOperation::RunOperation()

    {

    DLTRACEIN(( "Pending message: %X", iPendingMessage ));

    // Cannot determine from iOperationState whether we are

    // just starting this operation or continuing it after

    // for example expiration info has been handled.

    // This is because iOperationState will be EStateRunning

    // In both cases. This is why we use our own internal

    // variable.

    if ( iSubscriptionOperationState == EBegin )

        {

        // Operation is being started and we come here for

        // the first time

        iSubscriptionOperationState = ERunning;

        }

    else if ( iSubscriptionOperationState == EComplete )

        {

        // It is possible that the operation has completed while we have

        // been processing for example expired nodes. So we send completion

        // message immediately.

        if ( iPendingMessage )

            {

            return CompletePendingMessage();

            }

        return KErrGeneral;

        }    

    else if ( iSubscriptionOperationState == EHandlingQueries ) 

        {

        DLTRACE(("Queries handled"));

        SubscriptionOperationComplete( iError );        

        }

    else

        {

        // We don't want to start the operation again as it

        // is already running. Something should eventually trigger

        // completion of iMessage

        return KErrNone;

        }

    TRAPD( err,

        {

        switch ( iSubscriptionOperationType ) 

            {

            case MNcdSubscriptionOperation::EUnsubscribe:

                RunUnsubscribeOperationL();

                break;

            case MNcdSubscriptionOperation::ERefreshSubscriptions:

                RunRefreshOperationL();

                break;

            default:            

                User::Leave( KErrNotSupported );

                break;

            }

        } );

    if ( err != KErrNone )

        {

        SubscriptionOperationComplete( err );

        }

    DLTRACEOUT(("err: %d", err));

    return err;

    }

void CNcdSubscriptionOperation::Cancel()

    {

    DLTRACEIN( ( "" ) );

    if ( iTransaction )

        {

        iTransaction->Cancel();

        iTransaction = NULL;

        }

    if ( iParser )

        {

        iParser->CancelParsing();

        //delete iParser;

        //iParser = NULL;

        }

    CancelSuboperations();            

    DLTRACEOUT(( "" ));

    }

TBool CNcdSubscriptionOperation::QueryCompletedL( CNcdQuery* /* aQuery */ )

    {

    DLTRACEIN((""));

    return EFalse;

    }

void CNcdSubscriptionOperation::HandleHttpEventL( 

        MCatalogsHttpOperation& aOperation, 

        TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN((""));

    DASSERT( &aOperation == iTransaction );

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

    TCatalogsTransportProgress progress( iTransaction->Progress() );

    switch( aEvent.iOperationState ) 

        {

        // Handle completed operation

        case ECatalogsHttpOpCompleted:

            {

            // 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 CNcdSubscriptionOperation::HandleHttpError(

        MCatalogsHttpOperation& aOperation,

        TCatalogsHttpError aError )

    {

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

    DASSERT( &aOperation == iTransaction );

    aOperation.Release();

    iTransaction = NULL;

    SubscriptionOperationComplete( aError.iError );

    DLTRACEOUT((""));

    return ETrue;

    }

void CNcdSubscriptionOperation::ParseError( TInt aErrorCode )

    {

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

    // Handle error only if operation is not completed already

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

    if ( iSubscriptionOperationState != EComplete )

        {

            if ( iTransaction )

            {

            iTransaction->Cancel();        

            iTransaction = NULL;

            }

        SubscriptionOperationComplete( aErrorCode );

        }

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::ParseCompleteL( TInt aError )

    {

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

    if ( iParser )

        {

        delete iParser;

        iParser = NULL;

        }

    // HandleQuerysL will continue the operation in RunOperation

    iSubscriptionOperationState = EHandlingQueries;

    iError = aError;

    HandleQuerysL();

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::ValidSubscriptionL(

    MNcdPreminetProtocolSubscription* aData )

    {

    DLTRACEIN((""));

    iServersSubscriptions.AppendL( aData );

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::OldSubscriptionL(

    MNcdPreminetProtocolSubscription* aData )

    {

    DLTRACEIN((""));

    iServersSubscriptions.AppendL( aData );

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::Progress( CNcdBaseOperation& /*aOperation*/ )

    {

    DLTRACEIN((""));

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::QueryReceived( CNcdBaseOperation& /*aOperation*/,

                                CNcdQuery* /*aQuery*/ )

    {

    DLTRACEIN((""));

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::OperationComplete(

    CNcdBaseOperation* aOperation,

    TInt aError )

    {

    DLTRACEIN(("error=%d", aError));

    if ( iSubscriptionOperationType == MNcdSubscriptionOperation::EUnsubscribe )

        {

        SubscriptionOperationComplete( aError );

        }

    else if ( iSubscriptionOperationType ==

        MNcdSubscriptionOperation::ERefreshSubscriptions )

        {

        DLINFO(("Refresh subscription op complete."));

        TRAPD( err,

            {

            CNcdSubscriptionOperation* subOp =

                static_cast<CNcdSubscriptionOperation*>( aOperation );

            if ( aError != KErrNone )

                {

                DLINFO(("Refresh sub operation failed."));

                iFailedSubOps.AppendL( subOp );

                if ( iCompletionErrorCode == KErrNone )

                    {

                    iCompletionErrorCode = aError;

                    }

                }

            else

                {

                DLINFO(("Refresh sub operation successfull."));

                iCompletedSubOps.AppendL( subOp );

                }

            } ); //TRAPD

        if ( err != KErrNone )

            {

            DLERROR(("Internal subscription operation error"));

            SubscriptionOperationComplete( err );

            }

        else if ( iFailedSubOps.Count() + iCompletedSubOps.Count() ==

            iSubOps.Count() )

            {

            // All sub operations completed, the operation is complete.

            if ( iFailedSubOps.Count() && iCompletedSubOps.Count() )

                {

                // Some suboperations has failed, but not all.

                SubscriptionOperationComplete( KNcdErrorSomeSubscriptionsFailedToUpdate );

                }

            else if ( iFailedSubOps.Count() )

                {

                // All suboperations has failed.

                SubscriptionOperationComplete( iCompletionErrorCode );

                }

            else

                {                

                SubscriptionOperationComplete( KErrNone );

                }

            }

        }

    DLTRACEOUT((""));

    }

void CNcdSubscriptionOperation::ErrorL( MNcdPreminetProtocolError* aData )

    {

    DLTRACEIN((""));

    CleanupDeletePushL( aData );

    // Map error codes to correct enumeration values.

    switch ( aData->Code() ) 

        {

        case 404:

            {

            iError = KNcdErrorNotFound;

            DASSERT( iSubscription );

            if ( iSubscription )

                {

                RemoveSubscriptionL( *iSubscription );

                iSubscription = NULL;

                }                        

            break;

            }

        case 416:

            {

            DLTRACE(("session expired"));

            Cancel();

            switch ( iSubscriptionOperationType ) 

                {

                case MNcdSubscriptionOperation::EUnsubscribe:

                    {

                    iProtocol.SessionHandlerL( iSession.Context() ).

                        RemoveSession( *iServerUri, *iNamespace );