/*

* 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:   ?Description

*

*/

#include <badesca.h>

#include <s32strm.h>

#include "ncdpurchaseoperationproxy.h"

#include "ncdpurchaseoperationobserver.h"

#include "ncdoperationfunctionids.h"

#include "catalogsdebug.h"

#include "catalogsclientserver.h"

#include "ncdpurchaseoptionproxy.h"

#include "ncdoperationproxyremovehandler.h"

#include "catalogsconstants.h"

#include "catalogsutils.h"

#include "ncdqueryimpl.h"

#include "ncdqueryselectionitemimpl.h"

#include "ncdsubscriptionmanagerproxy.h"

#include "ncdnodeproxy.h"

#include "ncdnodemanagerproxy.h"

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

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

// ?description_if_needed

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

//

CNcdPurchaseOperationProxy* CNcdPurchaseOperationProxy::NewL( 

    MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdPurchaseOptionProxy* aSelectedPurchaseOption,

    MNcdPurchaseOperationObserver* aObserver,

    CNcdSubscriptionManagerProxy* aSubscriptionManager,

    CNcdNodeManagerProxy* aNodeManager,

    MNcdClientLocalizer* aLocalizer )

    {

    CNcdPurchaseOperationProxy* self = CNcdPurchaseOperationProxy::NewLC( 

        aSession,

        aHandle,

        aRemoveHandler,

        aNode,

        aSelectedPurchaseOption,

        aObserver,

        aSubscriptionManager,

        aNodeManager,

        aLocalizer );

    CleanupStack::Pop( self );

    return self;

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationProxy* CNcdPurchaseOperationProxy::NewLC( 

    MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdPurchaseOptionProxy* aSelectedPurchaseOption,

    MNcdPurchaseOperationObserver* aObserver,

    CNcdSubscriptionManagerProxy* aSubscriptionManager,

    CNcdNodeManagerProxy* aNodeManager,

    MNcdClientLocalizer* aLocalizer )

    {

    CNcdPurchaseOperationProxy* self =

        new( ELeave ) CNcdPurchaseOperationProxy( aLocalizer );

    self->AddRef();

    CleanupReleasePushL( *self );    

    self->ConstructL( 

        aSession, 

        aHandle, 

        aRemoveHandler, 

        aNode, 

        aSelectedPurchaseOption,

        aObserver,

        aSubscriptionManager,

        aNodeManager );

    return self;

    }

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

// From MNcdPurchaseOperation

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

//

const MNcdPurchaseOption& CNcdPurchaseOperationProxy::PurchaseOption()

    {

    DASSERT( iPurchaseOption );

    return *iPurchaseOption;

    }

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

// From MNcdOperation

// ?implementation_description

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

//

TNcdInterfaceId CNcdPurchaseOperationProxy::OperationType() const

    {

    return static_cast<TNcdInterfaceId>(MNcdPurchaseOperation::KInterfaceUid);

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationProxy::CNcdPurchaseOperationProxy(

    MNcdClientLocalizer* aLocalizer ) : 

    CNcdOperation< MNcdPurchaseOperation >( aLocalizer )

    {

    }

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

// ?description_if_needed

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

//

CNcdPurchaseOperationProxy::~CNcdPurchaseOperationProxy()

    {    

    DLTRACEIN( ( "" ) );

    if ( iPurchaseOption != NULL )

        {

        iPurchaseOption->InternalRelease();

        }

    DASSERT( iRemoveHandler );

    if ( iRemoveHandler )

        {        

        DLTRACE(("Removing proxy from remove handler"));

        iRemoveHandler->RemoveOperationProxy( *this );

        }    

    DLTRACEOUT( ( "" ) );    

    }

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

// ?description_if_needed

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

//

void CNcdPurchaseOperationProxy::ConstructL( MCatalogsClientServer& aSession,

    TInt aHandle,

    MNcdOperationProxyRemoveHandler* aRemoveHandler,

    CNcdNodeProxy* aNode,

    CNcdPurchaseOptionProxy* aSelectedPurchaseOption,

    MNcdPurchaseOperationObserver* aObserver,

    CNcdSubscriptionManagerProxy* aSubscriptionManager,

    CNcdNodeManagerProxy* aNodeManager )

    {

    DLTRACEIN( ( "" ) );

    CNcdBaseOperationProxy::ConstructL( aSession, 

                                        aHandle, 

                                        aRemoveHandler,

                                        aNode,

                                        aNodeManager );

    iObserver = aObserver;

    iSubscriptionManager = aSubscriptionManager;

    // We increment the reference count of the used purchaseoption

    // to ensure that it exists as long as the operation.

    iPurchaseOption = aSelectedPurchaseOption;

    if ( iPurchaseOption != NULL )

        {

        iPurchaseOption->InternalAddRef();

        }

    // Initialize the operation

//    InitializeOperationL();

    DLTRACEOUT( ( "" ) );

    }

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

// HandleCompletedMessage

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

//

void CNcdPurchaseOperationProxy::HandleCompletedMessage(

    TNcdOperationMessageCompletionId aCompletionId,

    RReadStream& aReadStream,

    TInt aDataLength )

    {

    DLTRACEIN((_L("aCompletionId =%d, aDataLength =%d"), aCompletionId,

        aDataLength));

    switch ( aCompletionId )

        {

        case ENCDOperationMessageCompletionProgress:

            {

            TRAPD( err, SendContinueMessageL() );

            if ( err != KErrNone ) 

                {

                CompleteCallback( err );

                }

            break;

            }

        case ENCDOperationMessageCompletionComplete:

            {

            DLTRACE( ( "ENCDOperationMessageCompletionComplete" ) );

            // Should get errorcode from the received message

            CompleteCallback( KErrNone );

            break;

            }

        default:

            {

            // Call base class

            CNcdBaseOperationProxy::HandleCompletedMessage( aCompletionId,

                aReadStream,

                aDataLength );

            break;

            }

        }

    }

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

// Handle progress callback

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

//

void CNcdPurchaseOperationProxy::ProgressCallback()

    {

    DLTRACEIN( ( "" ) );

    DASSERT( 0 );

    DLTRACEOUT( ( "" ) );

    }

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

// Handle query received callback

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

//

void CNcdPurchaseOperationProxy::QueryReceivedCallback( CNcdQuery* aQuery )

    {

    DLTRACEIN((""));

    aQuery->AddRef();

    // Following special case concerns only one query received during

    // the purchase process.

    // The query is received in the first phase of purchase process.

    // It is not received from the server but it is constructed on

    // the server side when the information response is received

    // from the server. The information response contains

    // updated price for the purchase. The updated price is set

    // on the server side into the used purchase option. This is

    // why the purchase option has to be reinternalized.

    if ( aQuery->Id() == KQueryIdPaymentMethod() )

        {

        // If this fails, then possibly updated price

        // cannot be shown to user and purchase process should

        // not be continued

        TRAPD( priceError, iPurchaseOption->InternalizeL() );

        if ( priceError )

            {

            // This error handling is copied and altered from the base

            // operation's DoCancelOperation because call for

            // DoCancelOperation would complete the operation with

            // KErrCancel

            DLTRACE(("Price update failed. Canceling operation."));

            Cancel();

            // Send cancel message to server-side        

            TInt tmpNum( 0 );

            ClientServerSession().

                SendSync( ENCDOperationFunctionCancel,

                          KNullDesC8(),

                          tmpNum,

                          Handle() );     

            SetState( MNcdOperation::EStateCancelled );

            DLTRACE(( "Calling complete callback with error: %d",

                      priceError ));

            CompleteCallback( priceError );

            return;

            }

        }    

    iObserver->QueryReceived( *this, aQuery );

    DLTRACEOUT((""));

    }

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

// Handle operation complete

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

//

void CNcdPurchaseOperationProxy::CompleteCallback( TInt aError )

    {

    DLTRACEIN( ( "Error: %d", aError ) );

    TInt error = aError;

	AddRef();

    DASSERT( iPurchaseOption );

    MNcdPurchaseOption::TType purchaseOptionType =

        iPurchaseOption->PurchaseOptionType();

    DLINFO(("Update purchase history"));

    TRAP_IGNORE( UpdateOperationInfoToPurchaseHistoryL( aError ) );        

    // Subscription manager on server side handles the informing

    // of all relevant proxies so no internalization for

    // subscription manager proxy here is needed.

    // Actually node internalization is probably not needed

    // in case we buy subscription, or subscription upgrade.

    // Then again, a updated price can be received in the

    // purchase operation. Should because of this internalize

    // be done always to update purchase options? Or can the

    // prices change?

    TRAPD( err,

           NodeManager()->InternalizeRelatedNodesL( *NodeProxy() ) );	

    if ( err != KErrNone ) 

	    {

	    error = err;

	    }

    iObserver->OperationComplete( *this, error );

    Release();

    DLTRACEOUT( ( "" ) );

    }