/*

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

*

*/

#include "ncdcontentdownloadoperation.h"

#include <s32mem.h>

#include <f32file.h>

#include <apmstd.h>

#include <e32math.h>

#include "catalogsbasemessage.h"

#include "catalogshttpsession.h"

#include "catalogshttpconfig.h"

#include "catalogshttpoperation.h"

#include "catalogsconstants.h"

#include "ncdnodemanager.h"

#include "ncdnodeimpl.h"

#include "ncdnodemetadataimpl.h"

#include "ncdnodeidentifier.h"

#include "ncdsessionhandler.h"

#include "ncdhttpheaders.h"

#include "catalogsutils.h"

#include "catalogshttpheaders.h"

#include "ncdconfigurationmanager.h"

#include "catalogscontext.h"

#include "ncdproviderdefines.h"

#include "ncdnodeclassids.h"

#include "ncdnodelink.h"

#include "ncdoperationremovehandler.h"

#include "ncddownloadsuboperation.h"

#include "ncddescriptordownloadsuboperation.h"

#include "ncdnodedownloadimpl.h"

#include "ncdpurchasedetails.h"

#include "ncdpurchasedownloadinfo.h"

#include "ncdpurchasehistorydbimpl.h"

#include "ncdutils.h"

#include "ncderrors.h"

#include "ncdpanics.h"

#include "ncdstorageitem.h"

#include "ncddatabasestorage.h"

#include "ncdcontentdescriptor.h"

#include "ncdproviderutils.h"

#include "ncdengineconfiguration.h"

#include "ncdnodecontentinfoimpl.h"

#include "ncdnodeinstallimpl.h"

#include "catalogshttpconnectionmanager.h"

#include "ncdpurchasehistoryutils.h"

#include "ncdnodedependencyimpl.h"

#include "catalogsaccesspointmanager.h"

#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

const TInt KNoDownloads = 25000;

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

// NewL

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

//

CNcdContentDownloadOperation* CNcdContentDownloadOperation::NewL( 

    MNcdOperationRemoveHandler& aRemoveHandler, 

    const CNcdNodeIdentifier& aNodeId,

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdDownloadReportObserver& aReportObserver,

    MNcdSessionHandler* aSessionHandler,    

    MNcdDatabaseStorage& aDownloadStorage,

    MCatalogsSession& aSession,

    TInt aDownloadIndex )

    {

    CNcdContentDownloadOperation* self = new( ELeave ) 

        CNcdContentDownloadOperation( 

        aRemoveHandler,

        aGeneralManager, 

        aHttpSession, 

        aReportObserver,

        aSessionHandler, 

        aSession,

        aDownloadStorage );

    CleanupClosePushL( *self );

    self->ConstructL( aNodeId, aDownloadIndex );

    CleanupStack::Pop();

    return self;

    }

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

// NewL

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

//

CNcdContentDownloadOperation* CNcdContentDownloadOperation::NewLC( 

    MNcdOperationRemoveHandler& aRemoveHandler, 

    CNcdGeneralManager& aGeneralManager,

    MCatalogsHttpSession& aHttpSession,

    MNcdDownloadReportObserver& aReportObserver,

    MNcdDatabaseStorage& aDownloadStorage,

    MCatalogsSession& aSession )

    {

    CNcdContentDownloadOperation* self = new( ELeave ) 

        CNcdContentDownloadOperation( 

        aRemoveHandler,

        aGeneralManager, 

        aHttpSession, 

        aReportObserver,

        NULL, 

        aSession,

        aDownloadStorage );

    CleanupClosePushL( *self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CNcdContentDownloadOperation::~CNcdContentDownloadOperation()

    {

    DLTRACEIN( ( "" ) );

    if ( iDownloadState == ENcdDownloadInProgress )

        {        

        if ( iDownload )

            {

            DLTRACE(("Pausing download"));

            iDownload->Pause();

            }

        iDownloadState = ENcdDownloadPaused;

        }

    if ( iDownloadState == ENcdDownloadPaused && 

         iOperationState != EStateCancelled )

        {

        DLINFO(("Externalizing the download since it's paused"));

        TRAP_IGNORE( SaveStateL() );            

        }

    else

        {

        TRAP_IGNORE( RemoveTempInfoL() );

        }

    if ( iDownload ) 

        {

        iDownload->Close();

        iDownload = NULL;

        }

    if ( iDescriptorDownload )

        {

        iDescriptorDownload->Close();

        iDescriptorDownload = NULL;

        }

    delete iDescriptor;

    delete iMimeType;

    delete iSessionId;

    delete iContentDescriptor;

    delete iContentFilename;

    delete iStorageUid;

    DLTRACEOUT((""));

    }

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

// Cancel

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

//

void CNcdContentDownloadOperation::Cancel() 

    {    

    DLTRACEIN(( "" ));

    // Can't handle leaves in cancel

    TNcdReportStatusInfo info( ENcdReportCancel, KErrCancel );

    TRAP_IGNORE( ReportStatusL( info ) );

    TRAP_IGNORE( SendOmaNotificationL( info ) );

    if ( iDownload ) 

        {

        // Content downloads should be cancelled only when the client says so

        if ( iDeleting )

            {

            iDownload->Pause();            

            }

        else

            {                        

            iDownload->Cancel();

            ClosePtr( iDownload );            

            }        

        }

    if ( iDescriptorDownload )

        {

        iDescriptorDownload->Cancel();

        iDescriptorDownload = NULL;

        }

    DLTRACEOUT(( "" ));

    }

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

// ReceiveMessage

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

//

void CNcdContentDownloadOperation::ReceiveMessage( 

    MCatalogsBaseMessage* aMessage,

    TInt aFunctionNumber )

    {

    DLTRACEIN(( "Function: %d", aFunctionNumber ));

    TNcdOperationMessageCompletionId completionId;

    TInt err = KErrNone;

    TBool requireStart = EFalse;

    // Response to pause and resume messages, other messages are handled

    // by the base class

    switch ( aFunctionNumber )

        {

        // GetData which in fact is pausable check

        case ENCDOperationFunctionGetData: 

            {

            DLTRACE(( "ENCDOperationFunctionGetData "));

            // Only error will come from CompleteMessageL

            TRAP_IGNORE( GetPausableStateL( *aMessage ) );

            return;

            }

        case ENCDOperationFunctionStart:

            {

            // Resume if paused, otherwise start

            if ( iDownload && iDownload->Progress().iState 

                 == ECatalogsHttpOpPaused )

                {

                DLTRACE(("Resuming download"));

                err = iDownload->Start();

                if ( err == KErrNone ) 

                    {

                    iDownloadState = ENcdDownloadInProgress;

                    }

                completionId = ENCDOperationMessageCompletionResume;

                }

            else 

                {

                CNcdBaseOperation::ReceiveMessage( aMessage, aFunctionNumber );

                return;

                }

            break;

            }

        // Pause download if it's pausable

        case ENCDOperationFunctionPause:

            {

            DLTRACE( ( "ENCDOperationFunctionPause" ) );

            if ( iOperationState != EStateComplete && 

                 iOperationState != EStateCancelled ) 

                {

                err = KErrNone;

                if ( iDownload ) 

                    {

                    // Don't care about pausable status since the user wants to pause

                    // we must pause the operation. If the download is not pausable,

                    // it will be started from the beginning                   

                    err = iDownload->Pause();              

                    }

                if ( iDescriptorDownload )

                    {

                    iDescriptorDownload->Cancel();

                    iDescriptorDownload = NULL;

                    }

                if ( err == KErrNone ) 

                    {

                    iDownloadState = ENcdDownloadPaused;

                    TNcdReportStatusInfo info( ENcdReportPause, KErrNone );

                    TRAP( err, ReportStatusL( info, EFalse ) );

                    }

                }

            completionId = ENCDOperationMessageCompletionPause;

            break;

            }

        // Resume download

        case ENCDOperationFunctionResume:

            {

            DLTRACE( ( "ENCDOperationFunctionResume" ) );

            if ( iOperationState != EStateComplete &&

                 iOperationState != EStateCancelled )             

                {

                if ( iDownload ) 

                    {                    

                    err = iDownload->Start();                

                    if ( err == KErrNone ) 

                        {

                        iDownloadState = ENcdDownloadInProgress;

                        iOperationState = EStateRunning;

                        }                

                    }

                else 

                    {

                    DLTRACE(("No download, should Start"));

                    iDownloadState = ENcdDownloadStopped;

                    iOperationState = EStateStopped;

                    requireStart = ETrue;

                    }

                }

            completionId = ENCDOperationMessageCompletionResume;

            break;

            }

        default:

            {

            DLTRACE(("Calling baseclass"));

            // Call implementation in the base class

            CNcdBaseOperation::ReceiveMessage( aMessage, aFunctionNumber );

            DLTRACEOUT(( "Called baseclass" ));

            return;

            }

        }

    if ( iDownload ) 

        {        

        iProgress = iDownload->Progress();        

        }

    iProgress.iState = iDownloadState;

    if ( !iPendingMessage && 

          iDownloadState != ENcdDownloadPaused )

        {

        DLTRACE(("No pending message, ask for one"));        

        if ( requireStart ) 

            {

            iProgress.iState = KNcdDownloadStartMessageRequired;    

            }

        else

            {

            iProgress.iState = KNcdDownloadContinueMessageRequired;    

            }

        }

    if ( err == KErrNone ) 

        {        

        TRAP( err, SaveStateL() );

        }

    // Complete pause/resume message

    // If this fails then it fails

    CompleteMessage( aMessage, completionId, iProgress, err );

    // Ensure that iState stays valid

    iProgress.iState = iCurrentFile;

    iProgress.iOperationId = iTotalFileCount;

    // The operation will halt if we don't do this because it has been paused

    // when there was a pending event so the proxy side won't send a new

    // message until we complete the pending message

    if ( iPendingMessage && 

         requireStart ) 

        {

        DLTRACE(("There was a pending message when resume was called -> Run"));

        RunOperation();

        }

    DLTRACEOUT(( "" ));

    }

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

// 

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

//

void CNcdContentDownloadOperation::CounterPartLost( 

    const MCatalogsSession& aSession )

    {

    DLTRACEIN((""));

    iDeleting = ETrue;

    CNcdBaseOperation::CounterPartLost( aSession ); 

    }

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

// Externalize the download

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

//

void CNcdContentDownloadOperation::ExternalizeL( RWriteStream& aStream )

    {

    DLTRACEIN((""));

    // Externalize node id

    iNode->Identifier().ExternalizeL( aStream );

    // Externalize metadata id

    iNode->NodeMetaDataL().Identifier().ExternalizeL( aStream );

    ExternalizeDesL( *iStorageUid, aStream );

    // Externalize node type so that we can create a correct kind of

    // a temp node when we restore the download

    ExternalizeEnumL( CNcdNodeFactory::NodeTypeL( *iNode ), aStream );

    if ( iSessionId )

        {        

        ExternalizeDesL( *iSessionId, aStream );

        }

    else

        {

        ExternalizeDesL( KNullDesC, aStream );

        }

    aStream.WriteInt32L( iDownloadIndex );

    aStream.WriteInt32L( iContentDownloadState );

    aStream.WriteInt32L( iDownloadState );

    aStream.WriteInt32L( iDependenciesUpdated );

    if ( iDownload )

        {

        DLTRACE(("Download exists"));

        aStream.WriteInt8L( 1 );

        iDownload->ExternalizeL( aStream );

        }

    else

        {

        DLTRACE(("No download"));

        // no download 

        aStream.WriteInt8L( 0 );

        }

    }

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

// Internalize the download

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

//

void CNcdContentDownloadOperation::InternalizeL( RReadStream& aStream )

    {

    DLTRACEIN((""));

    iIsOk = EFalse;

    CNcdNodeIdentifier* nodeId = CNcdNodeIdentifier::NewLC( aStream );

    DLINFO(( _L("Internalized nodeid: %S::%S"), &nodeId->NodeNameSpace(),

        &nodeId->NodeId() ));

    CNcdNodeIdentifier* metadataId = CNcdNodeIdentifier::NewLC( aStream );

    DLINFO(( _L("Internalized nodeid: %S::%S"), &metadataId->NodeNameSpace(),

        &metadataId->NodeId() ));

    InternalizeDesL( iStorageUid, aStream );

    CNcdNodeFactory::TNcdNodeType nodeType( CNcdNodeFactory::ENcdNodeItem );

    InternalizeEnumL( nodeType, aStream );

    CNcdNodeManager::TNcdTemporaryNodeType tempNodeType( 

        CNcdNodeManager::ENcdTemporaryNodeItem );

    switch( nodeType ) 

        {

        case CNcdNodeFactory::ENcdNodeItem:

            {

            tempNodeType = CNcdNodeManager::ENcdTemporaryNodeItem;

            break;

            }

        case CNcdNodeFactory::ENcdNodeFolder:

            {

            tempNodeType = CNcdNodeManager::ENcdTemporaryNodeFolder;

            break;

            }

        default:

            {

            DLERROR(("Corrupt data, leave"));

            User::Leave( KErrCorrupt );

            }

        };

    // Get node pointer and NodeDownload-pointer

    DLINFO(( "Node was not found. Must create a temp node" ));

    // Create temp node and update temp node usage status

    // nodeId is a temp node id because content downloads always use

    // temp nodes so we don't have to create a new temp node id from metadata id

    iNode = &iNodeManager->CreateTemporaryNodeL( 

            *nodeId, tempNodeType, ETrue );

    DLTRACE(("Updating access point"));

    UpdateAccessPointsL( *nodeId );

    CleanupStack::PopAndDestroy( 2, nodeId ); // metadataId, nodeId

    DLTRACE(("Getting metadata reference"));

    // Notice that the node has always some kind of metadata

    // when content is available

    CNcdNodeMetaData& metaData( iNode->NodeMetaDataL() );

    iNodeDownload = &metaData.DownloadL();