/*
* 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 <f32file.h>

#include "ncddownloadsuboperation.h"
#include "catalogsbasemessage.h"
#include "catalogshttpsession.h"
#include "catalogshttpconfig.h"
#include "catalogshttpoperation.h"
#include "ncdhttpheaders.h"
#include "catalogsutils.h"
#include "catalogshttpheaders.h"
#include "catalogscontext.h"
#include "ncdproviderdefines.h"
#include "ncdgeneralmanager.h"

#include "catalogsdebug.h"

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

// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CNcdDownloadSubOperation* CNcdDownloadSubOperation::NewL( 
    CNcdGeneralManager& aGeneralManager,
    MCatalogsHttpSession& aHttpSession,
    const TDesC& aUri,
    const TDesC& aDestination,
    MNcdOperationObserver& aObserver,
    MCatalogsSession& aSession )
    {
    CNcdDownloadSubOperation* self = new( ELeave ) CNcdDownloadSubOperation( 
        aGeneralManager, 
        aHttpSession, 
        aSession );
    CleanupClosePushL( *self );
    self->ConstructL( aUri, aDestination, aObserver );

    CleanupStack::Pop();
    return self;
    }


// ---------------------------------------------------------------------------
// NewL
// ---------------------------------------------------------------------------
//
CNcdDownloadSubOperation* CNcdDownloadSubOperation::NewL( 
    CNcdGeneralManager& aGeneralManager,
    MCatalogsHttpSession& aHttpSession,
    MNcdOperationObserver& aObserver,
    RReadStream& aStream,
    MCatalogsSession& aSession )
    {
    CNcdDownloadSubOperation* self = new( ELeave ) CNcdDownloadSubOperation( 
        aGeneralManager,
        aHttpSession, 
        aSession );
    CleanupClosePushL( *self );
    self->ConstructL( aObserver );
    self->InternalizeL( aStream );

    CleanupStack::Pop();
    return self;
    }


// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CNcdDownloadSubOperation::~CNcdDownloadSubOperation()
    {
    DLTRACEIN( ( "" ) );
    if ( iDownload ) 
        {
        iDownload->Release();
        iDownload = NULL;
        }
        
    DLTRACEOUT((""));
    }


// ---------------------------------------------------------------------------
// Download config getter
// ---------------------------------------------------------------------------
//
MCatalogsHttpConfig& CNcdDownloadSubOperation::Config()
    {
    DASSERT( iDownload );
    return iDownload->Config();
    }


// ---------------------------------------------------------------------------
// Download request header getter
// ---------------------------------------------------------------------------
//
MCatalogsHttpHeaders& CNcdDownloadSubOperation::RequestHeaders()
    {
    DASSERT( iDownload );
    return iDownload->Config().RequestHeaders();    
    }

// ---------------------------------------------------------------------------
// Download response header getter
// ---------------------------------------------------------------------------
//
const MCatalogsHttpHeaders& CNcdDownloadSubOperation::ResponseHeadersL()
    {
    DASSERT( iDownload );
    return iDownload->ResponseHeadersL();
    }


// ---------------------------------------------------------------------------
// HttpOperation
// ---------------------------------------------------------------------------
//
MCatalogsHttpOperation& CNcdDownloadSubOperation::HttpOperation()
    {
    DASSERT( iDownload );
    return *iDownload;
    }


// ---------------------------------------------------------------------------
// Start
// ---------------------------------------------------------------------------
//
TInt CNcdDownloadSubOperation::Start()
    {
    DLTRACEIN((""));
    TInt ret = iDownload->Start();
        
    if ( ret >= KErrNone ) 
        {
        DLTRACEOUT((""));
        return KErrNone;
        }
    DLTRACEOUT((""));
    return ret;
    }


// ---------------------------------------------------------------------------
// Pause
// ---------------------------------------------------------------------------
//
TInt CNcdDownloadSubOperation::Pause()
    {
    DLTRACEIN((""));
    TInt err = iDownload->Pause();              
    if ( err == KErrNone ) 
        {
        iDownloadState = ENcdDownloadPaused;
        }
    
    DLTRACEOUT((""));
    return err;
    }
    
    
// ---------------------------------------------------------------------------
// Resume
// ---------------------------------------------------------------------------
//
TInt CNcdDownloadSubOperation::Resume()
    {
    DLTRACEIN((""));
    TInt err = KErrNone; 
    
    if ( iDownload->State() == ECatalogsHttpOpPaused ) 
        {
        err = iDownload->Start();                
        if ( err == KErrNone ) 
            {
            iDownloadState = ENcdDownloadInProgress;
            }
    
        }    
    DLTRACEOUT((""));
    return err;
    }


// ---------------------------------------------------------------------------
// Cancel
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::Cancel() 
    {    
    DLTRACEIN(( "" ));
    if ( iDownload ) 
        {
        // Cancel also releases the dl
        iDownload->Cancel();
        iDownload = NULL;
        }
    DLTRACEOUT(( "" ));
    }


// ---------------------------------------------------------------------------
// HandleHttpEventL
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::HandleHttpEventL( 
    MCatalogsHttpOperation& aOperation, 
    TCatalogsHttpEvent aEvent )
    {
    DLTRACEIN((( "Event op state: %d, progress state: %d" ), aEvent.iOperationState, aEvent.iProgressState ));
    (void) aOperation; // suppresses compiler warning
    DASSERT( &aOperation == iDownload );
    DASSERT( aOperation.OperationType() == ECatalogsHttpDownload );

    TCatalogsTransportProgress progress( iDownload->Progress() );
    
    iProgress = TNcdSendableProgress( iDownloadState,
        iDownload->OperationId().Id(), progress.iProgress,
        progress.iMaxProgress );

    switch( aEvent.iOperationState ) 
        {
        // Handle completed operation
        case ECatalogsHttpOpCompleted:
            {
            DLTRACE(("ECatalogsHttpOpCompleted"));
            iDownloadState = ENcdDownloadComplete;
            NotifyObserversComplete( KErrNone );            
            break;
            }
        
        // Handle operation in progress
        case ECatalogsHttpOpInProgress:
            {
            iDownloadState = ENcdDownloadInProgress;
            switch( aEvent.iProgressState ) 
                {
                case ECatalogsHttpResponseBodyReceived:
                    {            
                    iOperationState = EStateRunning;
                    DLTRACE(("Inform observer about progress"));
                    NotifyObserversProgress();
                    break;
                    }
                case ECatalogsHttpDisconnected: 
                    {
                    DLTRACE(("ECatalogsHttpDisconnected"));
                    
                    iError = KErrDisconnected;
                    iDownloadState = ENcdDownloadFailed;
                    iOperationState = EStateComplete;   
                    NotifyObserversComplete( iError );
                    break;
                    }
                
                case ECatalogsHttpStarted:
                    {
                    DLTRACE(("ECatatalogsHttpStarted"));
                    iOperationState = EStateRunning;
                    iProgress.iState = ENcdDownloadStarted;
                    NotifyObserversProgress();
                    break;
                    }
                    
                default:
                    {
                    break;
                    }
                }
            break;
            }
                
        default:
            {
            break;
            }
        }
    DLTRACEOUT((""));
    }
    
    
// ---------------------------------------------------------------------------
// HandleHttpError
// ---------------------------------------------------------------------------
//
TBool CNcdDownloadSubOperation::HandleHttpError(
    MCatalogsHttpOperation& aOperation,
    TCatalogsHttpError aError )
    {    
    DLTRACEIN( ( "Error type: %i, id: %i", aError.iType, aError.iError ) );
    DASSERT( &aOperation == iDownload );
    
    if ( aError.iError == KErrCancel ) 
        {
        aOperation.Cancel();
        }
    else
        {        
        aOperation.Release();
        }
    iDownload = NULL;
    iError = aError.iError;
    iDownloadState = ENcdDownloadFailed;
    iOperationState = EStateComplete;   

    // notify observer
    NotifyObserversComplete( iError );
    return ETrue;
    }



// ---------------------------------------------------------------------------
// Externalize
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::ExternalizeL( RWriteStream& aStream ) const
    {
    DLTRACEIN((""));

    aStream.WriteInt32L( iDownloadState );
    if ( iDownload && 
         // don't save the download if there's no platform download 
         // because we can't restore it from download manager anyway
         iDownload->OperationId().SecondaryId() != KErrNotFound )
        {
        // Download exists
        aStream.WriteInt8L( 1 );

        // Write operation id so that it can be retrieved from Transport
        iDownload->OperationId().ExternalizeL( aStream );
        
        iDownload->ExternalizeL( aStream );
        }
    else
        {
        aStream.WriteInt8L( 0 );
        }
            
    }


// ---------------------------------------------------------------------------
// Internalize
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::InternalizeL( RReadStream& aStream )
    {
    DLTRACEIN((""));
    
    iDownloadState = static_cast<TNcdDownloadState>( aStream.ReadInt32L() );
    if ( iDownloadState == ENcdDownloadInProgress ) 
        {
        DLTRACE(("State was set to in progress, setting as paused"));
        iDownloadState = ENcdDownloadPaused;
        }
        
    TInt8 downloadExists = aStream.ReadInt8L();
    if ( downloadExists )
        {        
        TCatalogsTransportOperationId opId;
        opId.InternalizeL( aStream );
        
        // Search through restored downloads
        const RCatalogsHttpOperationArray& downloads = 
            iHttpSession.RestoredDownloads();
            
        for ( TInt i = 0; i < downloads.Count(); ++i )
            {
            TCatalogsTransportOperationId compId( downloads[i]->OperationId() );
            if ( compId.SecondaryId() == opId.SecondaryId() && 
                 compId.SessionId() == opId.SessionId() ) 
                {
                DLINFO(("Found a matching download"));
                iDownload = downloads[i];
                iDownload->InternalizeL( aStream );
                iDownload->Config().SetObserver( this );                
                                
                // Move dl from restored to current dls so that the restored
                // dl list can be purged from unnecessary dls afterwards
                User::LeaveIfError( iHttpSession.MoveRestoredDlToCurrentDls( 
                    *iDownload ) );
                return;
                }
            }                
        }        
    DLERROR(("Download was not found!"));
    // Download was not found though it should have existed
    User::Leave( KErrNotFound );
    
    }


// ---------------------------------------------------------------------------
// RunOperation
// ---------------------------------------------------------------------------
//
TInt CNcdDownloadSubOperation::RunOperation()
    {
    DLTRACEIN(( "Pending message: %X", iPendingMessage ));
    return KErrNone;
    }
    
    
// ---------------------------------------------------------------------------
// Constructor
// ---------------------------------------------------------------------------
//
CNcdDownloadSubOperation::CNcdDownloadSubOperation(
    CNcdGeneralManager& aGeneralManager,
    MCatalogsHttpSession& aHttpSession,
    MCatalogsSession& aSession ) :
        CNcdBaseOperation( aGeneralManager, NULL, EDownloadSubOperation, aSession ),
        iHttpSession( aHttpSession )
    {
    }


// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::ConstructL( const TDesC& aUri, 
    const TDesC& aDestination, MNcdOperationObserver& aObserver )
    {
    DLTRACEIN(( _L("URI: %S, Destination: %S"), &aUri, &aDestination ));
    
    AddObserverL( &aObserver );
    
    // Call ConstructL for the base class
    CNcdBaseOperation::ConstructL();    
    
    // Create the download
    iDownload = iHttpSession.CreateDownloadL( aUri, EFalse, this );
    
    TParsePtrC parse( aDestination );
        
    iDownload->Config().SetDirectoryL( parse.DriveAndPath() );
    
    TPtrC filename( parse.NameAndExt() );
    if ( filename.Length() ) 
        {
        DLTRACE(( _L("Destination filename: %S"), &filename ));
        iDownload->Config().SetFilenameL( filename );
        }
 
    iProgress.iProgress = -1;
    iProgress.iMaxProgress = -1;
    DLTRACEOUT(( "" ));
    }


// ---------------------------------------------------------------------------
// ConstructL
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::ConstructL( MNcdOperationObserver& aObserver )
    {
    DLTRACEIN(( "" ));
    
    AddObserverL( &aObserver );
    
    // Call ConstructL for the base class
    CNcdBaseOperation::ConstructL();    
     
    iProgress.iProgress = -1;
    iProgress.iMaxProgress = -1;
    DLTRACEOUT(( "" ));
    }
    
    
// ---------------------------------------------------------------------------
// NotifyObserversComplete
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::NotifyObserversComplete( TInt aError )
    {
    Open(); // increase ref count in CCatalogsCommunicable
    for( TInt i = 0; i < iObservers.Count(); ++i ) 
        {
        iObservers[i]->OperationComplete( this, aError );
        }
    Close();
    }


// ---------------------------------------------------------------------------
// NotifyObserversProgress
// ---------------------------------------------------------------------------
//
void CNcdDownloadSubOperation::NotifyObserversProgress()
    {
    Open(); // increase ref count in CCatalogsCommunicable
    for( TInt i = 0; i < iObservers.Count(); ++i ) 
        {
        iObservers[i]->Progress( *this );
        }
    Close();
    }