/*

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

*

*/

#include "ncdpurchaseoperationimpl.h"

#include <badesca.h>

#include <s32mem.h>

#include <exterror.h> // for KErrGsmSMSShortMessageTransferRejected

#include "ncdoperationfunctionids.h"

#include "catalogsbasemessage.h"

#include "catalogssmssession.h"

#include "catalogshttpincludes.h"

#include "ncdrequestgenerator.h"

#include "ncdrequestbase.h"

#include "ncdrequestpurchase.h"

#include "ncdrequestconfigurationdata.h"

#include "ncdprotocol.h"

#include "ncdparser.h"

#include "ncdnodemanager.h"

#include "ncdnodeidentifier.h"

#include "ncdnodeimpl.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdparserfactory.h"

#include "ncdpaymentmethod.h"

#include "ncd_pp_purchaseinformationimpl.h"

#include "ncd_pp_purchaseprocessedimpl.h"

#include "ncd_pp_information.h"

#include "ncd_pp_error.h"

#include "ncd_cp_queryresponse.h"

#include "ncd_cp_query.h"

#include "ncd_cp_queryimpl.h"

#include "ncd_cp_queryelement.h"

#include "ncd_cp_detail.h"

#include "ncdstring.h"

#include "ncdpurchaseoptionimpl.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdutils.h"

#include "ncddelay.h"

#include "ncdnodelink.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "ncd_pp_download.h"

#include "ncd_pp_descriptor.h"

#include "ncd_pp_rights.h"

#include "ncdqueryimpl.h"

#include "ncdqueryselectionitemimpl.h"

#include "ncdnodeiconimpl.h"

#include "ncdoperationremovehandler.h"

#include "ncdnodedownloadimpl.h"

#include "ncddownloadinfo.h"

#include "ncdsubscriptionmanagerimpl.h"

#include "ncderrors.h"

#include "ncdsessionhandler.h"

#include "ncdprotocoldefaultobserver.h"

#include "ncdnodedependencyimpl.h"

#include "ncdnodeupgradeimpl.h"

#include "ncdproviderutils.h"

#include "ncdengineconfiguration.h"

#include "catalogscontext.h"

#include "ncdsearchnodefolder.h"

#include "ncdhttputils.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

// Resend after timer is not needed if iResendAfter is -1

const TInt KResendAfterDisabled = -1;

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

// ?description_if_needed

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

//

CNcdPurchaseOperationImpl* CNcdPurchaseOperationImpl::NewL(

    const TDesC& aNameSpace,

    const TDesC& aNodeId,

    const TUid& aClientUid,

    const TDesC& aPurchaseOptionId,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MCatalogsSmsSession& aSmsSession,

    CNcdSubscriptionManager& aSubscriptionManager,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdPurchaseOperationImpl* self = 

        CNcdPurchaseOperationImpl::NewLC(

            aNameSpace,

            aNodeId,

            aClientUid,

            aPurchaseOptionId,

            aGeneralManager,

            aHttpSession,

            aSmsSession,

            aSubscriptionManager,

            aRemoveHandler,

            aSession );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationImpl* CNcdPurchaseOperationImpl::NewLC(

    const TDesC& aNameSpace,

    const TDesC& aNodeId,

    const TUid& aClientUid,

    const TDesC& aPurchaseOptionId,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MCatalogsSmsSession& aSmsSession,

    CNcdSubscriptionManager& aSubscriptionManager,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    {

    CNcdPurchaseOperationImpl* self = 

        new( ELeave ) CNcdPurchaseOperationImpl(

            aGeneralManager,

            aHttpSession,

            aSmsSession,

            aSubscriptionManager,

            aRemoveHandler,

            aSession );

    CleanupClosePushL( *self );

    self->ConstructL( aNameSpace, aNodeId, aClientUid, aPurchaseOptionId );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationImpl::CNcdPurchaseOperationImpl(

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MCatalogsSmsSession& aSmsSession,

    CNcdSubscriptionManager& aSubscriptionManager,

    MNcdOperationRemoveHandler* aRemoveHandler,

    MCatalogsSession& aSession )

    : CNcdBaseOperation( aGeneralManager, aRemoveHandler, EPurchaseOperation,

        aSession ),

      iAccessPointManager( aGeneralManager.AccessPointManager() ),

      iPurchaseHistory( &aGeneralManager.PurchaseHistory() ),

      iHttpSession( aHttpSession ),

      iSmsSession( &aSmsSession ),

      iProtocol( aGeneralManager.ProtocolManager() ),

      iSubscriptionManager( aSubscriptionManager ),

      iLocked( EFalse )

    {

    iPurchaseOperationState = EBegin;

    }

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

// ?description_if_needed

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

//

void CNcdPurchaseOperationImpl::ConstructL(

    const TDesC& aNameSpace,

    const TDesC& aNodeId,

    const TUid& aClientUid,

    const TDesC& aPurchaseOptionId )

    {

    DLTRACEIN((""));

    CNcdBaseOperation::ConstructL();

    iNodeIdentifier = CNcdNodeIdentifier::NewL( aNameSpace, aNodeId, aClientUid );

    // Get the node where the purchase operation was started from

    iNode = &iNodeManager->NodeL( *iNodeIdentifier );

    // Get the selected purchase option

    RPointerArray<CNcdPurchaseOptionImpl> purchaseOptions = 

        iNode->NodeMetaDataL().PurchaseOptions();

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

        {

        if( purchaseOptions[i]->Id().CompareF( aPurchaseOptionId ) == 0 )

            {

            iSelectedPurchaseOption = purchaseOptions[i];

            }

        }

    // Purchase option is needed so leave if not found    

    if ( !iSelectedPurchaseOption )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationImpl::~CNcdPurchaseOperationImpl()

    {

    delete iPurchaseOptionId;

    delete iNodeIdentifier;

    delete iParser;

    if ( iHttpTransaction ) 

        {

        // Cancel also releases the operation

        iHttpTransaction->Cancel();        

        }

    delete iSmsRegistrationRequest;

    delete iPurchaseInformationData;

    delete iPurchaseProcessedData;

    if( iPurchaseQuery )

        {

        iPurchaseQuery->InternalRelease();

        }

    delete iRedirectUri;

    delete iDelay;

    iPendingSmsOperations.Reset();

    }

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

// Node Id getter

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

//

const CNcdNodeIdentifier& CNcdPurchaseOperationImpl::NodeIdentifier() const

    {

    return *iNodeIdentifier;

    }

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

// ?implementation_description

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

//

void CNcdPurchaseOperationImpl::Cancel()

    {

    DLTRACEIN( ( "" ) );

    if ( iHttpTransaction )

        {

        iHttpTransaction->Cancel();

        iHttpTransaction = NULL;

        }

    if ( iParser )

        {

        iParser->CancelParsing();        

        }

    DeletePtr( iDelay );

    TInt i = iPendingSmsOperations.Count();

    while( i-- )

        {

        iPendingSmsOperations[i]->Cancel();

        // The previous cancel will result with current implementation

        // in HandleSmsEvent() call. Although this happens release

        // and removal is done here to be sure that they are done.

        // (This way this function is not dependant whether the

        // HandleSmsEvent callback occurs or not)                    

	    iPendingSmsOperations[i]->Release();

        iPendingSmsOperations.Remove( i );

        }

    }

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

// ?implementation_description

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

//

void CNcdPurchaseOperationImpl::HandleHttpEventL( 

        MCatalogsHttpOperation& aOperation, 

        TCatalogsHttpEvent aEvent )

    {

    DLTRACEIN((""));

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

    TInt err = KErrNone;

    switch( aEvent.iOperationState )

        {

        case ECatalogsHttpOpInProgress:

            {

            // Don't bother to send empty bodies because this event 

            // is sent also for received headers etc.

            if ( aOperation.Body().Length() )

                {                

                // Send received data to the parser

                TRAP(err, iParser->ParseL( aOperation.Body() ));

                }

            break;

            }

        case ECatalogsHttpOpCompleted:

            {

            TRAP( err, iParser->EndL() );

            break;

            }

        }

    if( err != KErrNone )

        {

        iError = err;

        iPurchaseOperationState = EFailed;

        Cancel();

        RunOperation();

        }

    DLTRACEOUT((""));

    }

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

// From class CNcdBaseOperation.

// ?implementation_description

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

//

TInt CNcdPurchaseOperationImpl::RunOperation()

    {

    DLTRACEIN((""));

    if ( !iPendingMessage )

        {

        DLTRACEOUT(("No pending message -> return"));

        return KErrNone;

        }

    DLTRACE(("Purchase operation state: %d", iPurchaseOperationState));

    if ( iLocked ) 

        {

        DLINFO(("Operation locked"));

        return KErrNone;

        }

    TRAPD( err, DoRunOperationL() );

     if ( err != KErrNone )

        {

        DLTRACE(("error: %d", err));

        Cancel();

        iPurchaseOperationState = EFailed;

        iError = err;

        if ( iPendingMessage )

            {

            // error ignored because operation already failed

            CNcdBaseOperation::CompleteMessage( iPendingMessage,

                ENCDOperationMessageCompletionError, err );

            }

        }

    DLTRACEOUT((""));

    return err;

    }

void CNcdPurchaseOperationImpl::DoRunOperationL()

    {

    DLTRACEIN((""));

    switch ( iPurchaseOperationState )

        {

        case EBegin:

            {

            DLTRACE( _L( "->EBegin" ) );

            // At first check if there is enough disk space for the downloadable

            // content. Stop the purchase process if this is not the case.

            TInt contentSize = 0;

            TRAP_IGNORE( contentSize = iNode->NodeMetaDataL().ContentInfoL().TotalContentSize() );          

            DLINFO((("contentSize=%d"), contentSize ));

            if ( contentSize > 0 ) 

                {                

                HBufC* clientDataPath = CNcdProviderUtils::EngineConfig().ClientDataPathLC( 

                    iGeneralManager.FamilyName(), EFalse );    

                DLINFO(( _L("Client data path: %S"), clientDataPath )); 

                WouldDiskSpaceGoBelowCriticalLevelL(

                    *clientDataPath, CNcdProviderUtils::FileSession(), contentSize );

                CleanupStack::PopAndDestroy( clientDataPath );                

                }

            // Skip purchase process for free items that doesn't implicitely

            // require going through it

            // Notice that we don't support purchasing of a subscription

            // that is free and does not require purchase process. Purchase

            // process is used as no downloadinfo is received!!

            if( iSelectedPurchaseOption->IsFree() && 

                !iSelectedPurchaseOption->RequirePurchaseProcess() &&

                iSelectedPurchaseOption->DownloadInfoCount() > 0 ) 

                {

                iPurchaseOperationState = EDownloadDetailsReceived;

                CNcdBaseOperation::CompleteMessage( 

                    iPendingMessage, 

                    ENCDOperationMessageCompletionProgress,

                    iProgress,

                    KErrNone );

                }

            else

                {

                // Create purchase request and send it. Next callback will be

                // HandleHttpEventL or HandleHttpError.

                HBufC8* purchaseRequest = CreatePurchaseRequestLC(

                    EPurchaseRequest,

                    iNode->NodeLinkL().ServerUri() );

                SendRequestL( iNode->NodeLinkL().ServerUri(), *purchaseRequest );

                CleanupStack::PopAndDestroy( purchaseRequest );

                iPurchaseOperationState = EPurchaseRequestSent;

                }

            DLTRACE(( "EBegin done" ));

            break;

            }

        case EPurchaseInformationReceived:

            {

            DLTRACE( _L( "->EPurchaseInformationReceived" ) );

            if( !iPurchaseInformationData )

                {

                User::Leave( KNcdErrorNoPurchaseInformationReceived );

                }

            // Handle redirection if server requested for it.

            if( iPurchaseInformationData->Uri() != KNullDesC )

                {

                // store redirect uri

                delete iRedirectUri;

                iRedirectUri = NULL;

                iRedirectUri = iPurchaseInformationData->Uri().AllocL();

                HBufC8* purchaseRequest;

                // Redirection with new session

                if( iPurchaseInformationData->InitiateSession() )

                    {

                    // remove session if there is one

                    iProtocol.SessionHandlerL( iSession.Context() ).RemoveSession(

                    iPurchaseInformationData->Uri(), iNodeIdentifier->NodeNameSpace() );

                    purchaseRequest = 

                        CreatePurchaseRequestLC( 

                            EPurchaseRequest,

                            iPurchaseInformationData->Uri() );

                    }

                // Redirection without new session

                else

                    {

                    purchaseRequest = 

                        CreatePurchaseRequestLC( 

                            EPurchaseRequest,

                            iNode->NodeLinkL().ServerUri() ); 

                    }

                SendRequestL( 

                    *iRedirectUri, *purchaseRequest );

                CleanupStack::PopAndDestroy( purchaseRequest );

                iPurchaseOperationState = EPurchaseRequestResent;

                }

            else if( iPurchaseInformationData->Disclaimer() )

                {

                DLTRACE(("Sending purchase disclaimer"));

                if ( iPurchaseQuery )

                    {

                    iPurchaseQuery->InternalRelease();

                    iPurchaseQuery = NULL;

                    }

                iPurchaseQuery = 

                    CNcdQuery::NewL( *iPurchaseInformationData->Disclaimer() );

                CNcdBaseOperation::QueryReceivedL( iPurchaseQuery );

                iPurchaseOperationState = EDisclaimerQueried;

                }

            else

                {

                iPurchaseOperationState = EDisclaimerQueried;

                // Send progress info to the proxy

                CNcdBaseOperation::CompleteMessage( iPendingMessage,

                         ENCDOperationMessageCompletionProgress,

                         iProgress,

                         KErrNone );

                }

            DLTRACE(( "EPurchaseInformationReceived done" ));

            break;

            }

        case EDisclaimerQueried:

            {

            DLTRACE(( "EDisclaimerQueried" ));

            // purchase option is free but payment methods exist

            // -> there may be querys that need showing

            if( iSelectedPurchaseOption->IsFree() &&

                iPurchaseInformationData->PaymentCount() == 1 )

                {

                // automatically select the purchase option

                iSelectedPaymentMethod = &iPurchaseInformationData->PaymentL( 0 );

                // continue operation so that possible querys get shown

                iPurchaseOperationState = EPaymentMethodsQueried;