/*

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

#include "catalogsbasemessage.h"

#include "catalogsdebug.h"

#include "ncdqueryimpl.h"

#include "ncd_cp_queryresponseimpl.h"

#include "ncd_cp_query.h"

#include "catalogsutils.h"

#include "ncdoperationobserver.h"

#include "ncd_pp_information.h"

#include "catalogssession.h"

#include "ncdoperationremovehandler.h"

#include "ncd_pp_error.h"

#include "ncd_pp_expiredcacheddata.h"

#include "ncdnodeidentifier.h"

#include "ncdnodemanager.h"

#include "catalogscontext.h"

#include "ncddeviceinteractionfactory.h"

#include "ncddeviceservice.h"

#include "ncdquerytextitem.h"

#include "ncdparser.h"

#include "ncdprotocoldefaultobserver.h"

#include "catalogsconstants.h"

#include "ncdexpirednode.h"

#include "ncdrequestbase.h"

#include "ncdproviderutils.h"

#include "ncderrors.h"

#include "ncdgeneralmanager.h"

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

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

// ?description_if_needed

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

//

CNcdBaseOperation::~CNcdBaseOperation()

    {

    DLTRACEIN((""));

    if ( iRemoveHandler ) 

        {

        iRemoveHandler->RemoveOperation( *this );

        }

    iObservers.Close();    

    if ( iActiveQuery )

        {

        iActiveQuery->InternalRelease();

        }

    if ( iPendingMessage )

        {

        DLTRACE(("Message pending"));

        // Operation destroyed unexpectedly when a message was still pending

        iPendingMessage->CompleteAndRelease( KErrDied );

        }    

    iEmbeddedDataQuerys.ResetAndDestroy();

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

        {

        iPendingQuerys[i]->InternalRelease();

        }

    iPendingQuerys.Close();

    delete iRunner;

    iExpiredNodes.ResetAndDestroy();

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

        {

        iCompletedQuerys[i]->InternalRelease();

        }

    iCompletedQuerys.Reset();

    DLTRACEOUT((""));

    }

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

// ?implementation_description

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

//

TInt CNcdBaseOperation::Start()

    {

    DLTRACEIN((""));

    if ( iOperationState == EStateStopped )

        {

        // Op not yet running, start it

        iOperationState = EStateRunning;

        TInt err = RunOperation();

        DLTRACE(("Returned from RunOperation()"));

        DLTRACEOUT((""));

        return err;

        }

    else

        {

        // Op already started.

        DLTRACEOUT((""));

        return KErrInUse;

        }

    }

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

// ?implementation_description

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

//

void CNcdBaseOperation::AddObserverL( 

    MNcdOperationObserver* aObserver )

    {

    DLTRACEIN((""));

    DASSERT( aObserver );

    iObservers.AppendL( aObserver );

    }

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

// ?implementation_description

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

//

TInt CNcdBaseOperation::RemoveObserver( 

    MNcdOperationObserver* aObserver )

    {

    DLTRACEIN((""));

    TInt index = iObservers.Find( aObserver );

    if ( index != KErrNotFound )

        {

        iObservers.Remove( index );

        return KErrNone;

        }

    else

        {

        return KErrNotFound;

        }

    }

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

// ?implementation_description

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

//

TNcdOperationType CNcdBaseOperation::Type() const

    {

    DLTRACEIN((""));

    return iOperationType;

    }

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

// ?implementation_description

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

//

void CNcdBaseOperation::HandleStartMessage( 

    MCatalogsBaseMessage* aMessage )    

    {

    DLTRACEIN((""));

    DASSERT( ! iPendingMessage );

    if ( iOperationState == EStateStopped )

        {        

        iPendingMessage = aMessage;

        TInt err = Start();

        DLTRACE(( "Start returned with: %d", err ));

        }

    else

        {

        DLTRACE(("Operation already started"));

        // Operation already started.

        TInt err = CompleteMessage( aMessage, ENCDOperationMessageCompletionError,

            KErrInUse );

        if ( err != KErrNone )

            {

            FailOperation( err );

            }

        }       

    DLTRACEOUT(("")); 

    }

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

// ?implementation_description

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

//

void CNcdBaseOperation::HandleCancelMessage( 

    MCatalogsBaseMessage* aMessage )

    {

    DLTRACEIN((""));

    // release pending message if any

    if ( iPendingMessage )

        {

        DLTRACE(("Completing pending message"));

        // Completing the message so no memory is pending in the

        // framework because of it.            

        iPendingMessage->CompleteAndRelease( KErrCancel );            

        iPendingMessage = NULL;

        }

    // iOperationState has to be set to EStateCancelled before

    // cancelling purchase operation.

    // See CNcdPurchaseOperationImpl::HandleSmsEvent()

    iOperationState = EStateCancelled;

    Cancel();

    aMessage->CompleteAndRelease( KErrNone );

    DLTRACEOUT((""));

    }

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

// ?implementation_description

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

//

void CNcdBaseOperation::HandleContinueMessage( 

    MCatalogsBaseMessage* aMessage )

    {

    DLTRACEIN(( "iOperationState: %d", iOperationState ));

    DASSERT( ! iPendingMessage );

    if ( iOperationState == EStateRunning )

        {

        DLTRACE(("iOperationState == EStateRunning"));        

        // Message is just stored here, it will be completed 

        // when progress has been made.

        iPendingMessage = aMessage;

        iOperationState = EStateRunning;

        RunOperation();

        DLTRACE(("Returned from RunOperation()"));

        }

    else if ( iOperationState == EStateQuery )

        {

        DLTRACE(("iOperationState == EStateQuery"));

        // A query is pending and has not yet been sent to proxy        

        TInt err = CompleteMessage( aMessage, ENCDOperationMessageCompletionQuery,

            *iActiveQuery,

            KErrNone );

        if( err != KErrNone )

            {

            FailOperation( err );

            }

        }

    else if ( iOperationState == EStateSendExpirationInfo )

        {

        DLTRACE(("iOperationState == EStateSendExpirationInfo"));

        iOperationState = EStateRunning;

        iPendingMessage = aMessage;

        TInt err = SendExpirationInfo( iExpiredNodes );

        if( err != KErrNone )

            {

            FailOperation( err );            

            }

        else

            {

            iExpiredNodes.ResetAndDestroy();

            if ( iActiveQuery )

                {

                // there's a query pending, change state accordingly

                iOperationState = EStateQuery;

                }

            }

        }

    else

        {

        DLTRACE(("Not waiting for a continue message!"));

        // Fail operation can't complete the message if it's not set

        // to iPendingMessage

        iPendingMessage = aMessage;

        // Not waiting for a continue message.

        FailOperation( KErrNotReady );

        }

    DLTRACEOUT((""));

    }

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

// ?implementation_description

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

//

void CNcdBaseOperation::HandleQueryResponseMessage( 

    MCatalogsBaseMessage* aMessage )

    {

    DLTRACEIN((""));

    DASSERT( ! iPendingMessage );

    if ( iOperationState == EStateQuery )

        {        

        DASSERT( iActiveQuery );

        // store message, it will be completed later

        iPendingMessage = aMessage;

        iOperationState = EStateRunning;

        DLINFO(("input length= %d",iPendingMessage->InputLength()));

        TRAPD( err,

            {            

            HBufC8* des = HBufC8::NewLC( iPendingMessage->InputLength() );

            TPtr8 ptr = des->Des();

            iPendingMessage->ReadInput( ptr );

            RDesReadStream stream( *des );

            CleanupReleasePushL( stream );

            iActiveQuery->InternalizeL( stream );

            CleanupStack::PopAndDestroy( &stream );

            CleanupStack::PopAndDestroy( des );

            QueryHandledL( iActiveQuery );

            }); // TRAP

        if( err != KErrNone )

            {

            FailOperation( err );

            }

        // Should handle cases where both expired info and querys have been received

        /*else if( iExpiredNodes.Count() > 0 )

            {

            DLTRACE(("Expired nodes received previously, send to proxy"));

            TInt err = SendExpirationInfo( iExpiredNodes );

            if( err != KErrNone )

                {

                FailOperation( err );

                }

            }*/

        }

    else

        {

        DLTRACE(("Not waiting for a query"));

        // Not waiting for a query response message.

        TInt err = CompleteMessage( aMessage, ENCDOperationMessageCompletionError,

            KErrNotReady );

        if ( err != KErrNone )

            {

            FailOperation( err );

            }

        }

    DLTRACEOUT((""));

    }

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

// Handle initialization messages

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

//

void CNcdBaseOperation::HandleInitMessage( MCatalogsBaseMessage* aMessage )

    {

    DLTRACEIN( ( "" ) );

    if ( iOperationState == EStateStopped )

        {

        // this will probably cause an error in the proxy, remove?

        if ( iPendingMessage )

            {

            DLTRACE( ( "MESSAGE PENDING! THIS CAN NOT BE!" ) );

            iPendingMessage->CompleteAndRelease( KErrAlreadyExists );

            DASSERT( 0 );

            }

        iPendingMessage = aMessage;

        Initialize();

        }

    else

        {

        // Operation already started.

        TInt err = CompleteMessage( aMessage, 

            ENCDOperationMessageCompletionError,

            KErrInUse );

        if ( err != KErrNone )

            {

            FailOperation( err );

            }

        }        

    DLTRACEOUT((""));

    }

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

// Handles release messages

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

//

void CNcdBaseOperation::HandleReleaseMessage( MCatalogsBaseMessage* aMessage )    

    {

    DLTRACEIN((""));

    if ( iPendingMessage ) 

        {

        // Notice that because we complete the iPendingMessage here the

        // client has to say AsyncMessageSenderDown() to the

        // ClientServer so the client won't receive this

        // iPendingMessage. iPendingMessage is released here so no memory

        // is pending because of it.

        DLTRACE(("Releasing pending message"));

        iPendingMessage->CompleteAndRelease( KErrCancel );            

        iPendingMessage = NULL;        

        DLTRACE(("Message released"));

        }

    MCatalogsSession& requestSession( aMessage->Session() );

    DLTRACE(("Getting handle"));

    TInt handle( aMessage->Handle() );

    DLTRACE(("Completing message"));

    aMessage->CompleteAndRelease( KErrNone );

    DLTRACE(("Removing object"));

    requestSession.RemoveObject( handle );

    }

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

// ?implementation_description

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

//

TInt CNcdBaseOperation::CompleteMessage( MCatalogsBaseMessage* & aMessage,

        TNcdOperationMessageCompletionId aId,

        const MNcdSendable& aSendableObject,

        TInt aStatus )

    {

    DLTRACEIN((""));

    DLTRACE(("Handle: %d", aMessage->Handle()));

    TRAPD(err,    

        {

        DLTRACE(("new buf"));

        CBufBase* buf = CBufFlat::NewL( 30 );

        CleanupStack::PushL( buf );

        RBufWriteStream stream( *buf );

        CleanupClosePushL( stream );

        stream.WriteInt32L( aId );

        aSendableObject.ExternalizeL( stream );

        CleanupStack::PopAndDestroy( &stream );

        TPtrC8 ptr = buf->Ptr( 0 );

        DLTRACE(("complete msg"));

        DASSERT((aMessage != NULL));

        aMessage->CompleteAndReleaseL( ptr, aStatus );

        DLTRACE(("pop buf"));

        CleanupStack::PopAndDestroy( buf );

        DLTRACE(("done"));

        });

    if( err != KErrNone )

        {

        aMessage->CompleteAndRelease( aStatus );

        }

    aMessage = NULL;

    DLTRACEOUT(("error=%d", err));

    return err;

    }

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

// ?implementation_description

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

//

TInt CNcdBaseOperation::CompleteMessage(MCatalogsBaseMessage* & aMessage,

        TNcdOperationMessageCompletionId aId,

        TInt aStatus )

    {

    DLTRACEIN((""));

    DASSERT((aMessage));

    DLTRACE(("Handle: %d", aMessage->Handle()));

    TRAPD(err,

        {

        HBufC8* buffer = HBufC8::NewLC( sizeof(TInt) );

        TPtr8 bufferPtr( buffer->Des() );        

        RDesWriteStream desWriteStream( bufferPtr );

        CleanupClosePushL( desWriteStream );

        desWriteStream.WriteInt32L( aId );

        CleanupStack::PopAndDestroy( &desWriteStream );

        aMessage->CompleteAndReleaseL( *buffer, aStatus );

        CleanupStack::PopAndDestroy( buffer );

        });

    if( err != KErrNone )

        {

        aMessage->CompleteAndRelease( aStatus );

        }

    aMessage = NULL;

    DLTRACEOUT(("error=%d", err));

    return err;

    }

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

// ?implementation_description

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

//

TInt CNcdBaseOperation::CompleteMessage( MCatalogsBaseMessage*& aMessage,

        TNcdOperationMessageCompletionId aId,

        const MNcdSendable& aSendableObject,

        RPointerArray<CNcdNodeIdentifier>& aNodes,

        TInt aStatus )

    {

    DLTRACEIN(("Handle: %i", aMessage->Handle()));

    TRAPD(err,    

        {

        CBufBase* buf = CBufFlat::NewL( KBufExpandSize );

        CleanupStack::PushL( buf );

        RBufWriteStream stream( *buf );

        CleanupClosePushL( stream );

        stream.WriteInt32L( aId );

        aSendableObject.ExternalizeL( stream );

        stream.WriteInt32L( aNodes.Count() );

        DLINFO(("Node loop: %d", aNodes.Count()));

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

            {

            aNodes[i]->ExternalizeL( stream );

            }

        CleanupStack::PopAndDestroy( &stream );

        TPtrC8 ptr = buf->Ptr( 0 );

        aMessage->CompleteAndReleaseL( ptr, aStatus );

        CleanupStack::PopAndDestroy( buf );

        });

    if( err != KErrNone )

        {

        aMessage->CompleteAndRelease( aStatus );

        }

    aMessage = NULL;

    DLTRACEOUT((""));

    return err;

    }

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

// ?implementation_description

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

//