/*

* Copyright (c) 2006-2010 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 "catalogshttpdownload.h"

#include <bautils.h>

#include <e32err.h>

#include <DocumentHandler.h>

#include <apmstd.h> // TDataType

#include <escapeutils.h>

#include <downloadmanager.h>

#include <QtGlobal>

#include "catalogshttpdownloadmanagerimpl.h"

#include "catalogshttpobserver.h"

#include "catalogshttpconfigimpl.h"

#include "catalogskeyvaluepair.h"

#include "catalogshttpheadersimpl.h"

#include "catalogsutils.h"

#include "catalogsdebug.h"

#include "catalogsconstants.h"

#include "catalogserrors.h"

#include "catalogshttpconnectionmanager.h"

#include "catalogsconnectionmethod.h"

#include "catalogsconnection.h"

#include "catalogshttputils.h"

// Number of retries before giving up the download

const TInt KReconnectAttempts = 3;

const TInt KHttpErrorStatus = 400;

const TInt KGenericSymbianHttpError = -20000;

#define CATALOGS_DISABLE_DOWNLOAD_RESPONSE_HEADERS

// HTTP header strings

_LIT8( KHttpRequestAcceptHeader, "Accept" );

_LIT8( KHttpRequestAcceptCharSetHeader, "Accept-Charset" );

_LIT8( KHttpRequestAcceptLanguageHeader, "Accept-Language" );

_LIT8( KHttpRequestExpectHeader, "Expect" );

_LIT8( KHttpRequestFromHeader, "From" );

_LIT8( KHttpRequestHostHeader, "Host" );

_LIT8( KHttpRequestMaxForwardsHeader, "Max-Forwards" );

_LIT8( KHttpRequestPragmaHeader, "Pragma" );

_LIT8( KHttpRequestRefererHeader, "Referer" );

_LIT8( KHttpRequestUserAgentHeader, "User-Agent" );

_LIT8( KHttpRequestVaryHeader, "Vary" );

_LIT8( KHttpGeneralCacheControlHeader, "Cache-Control" );

_LIT8( KHttpGeneralDateHeader, "Date" );

_LIT8( KHttpGeneralPragmaHeader, "Pragma" );

_LIT8( KHttpGeneralViaHeader, "Via" );

_LIT8( KHttpGeneralWarningHeader, "Warning" );

_LIT8( KHttpEntityAllowHeader, "Allow" );

_LIT8( KHttpEntityContentEncodingHeader, "Content-Encoding" );

_LIT8( KHttpEntityContentLanguageHeader, "Content-Language" );

_LIT8( KHttpEntityContentLocationHeader, "Content-Location" );

_LIT8( KHttpEntityExpiresHeader, "Expires" );

_LIT8( KHttpEntityLastModifiedHeader, "Last-Modified" );

#ifndef CATALOGS_DISABLE_DOWNLOAD_RESPONSE_HEADERS

    _LIT8( KHttpResponseCharSet, "Charset" );

    _LIT8( KHttpResponseAge, "Age" );

    _LIT8( KHttpResponseETag, "ETag" );

    _LIT8( KHttpResponseLocation, "Location" );

    _LIT8( KHttpResponseRetryAfter, "Retry-After" );

    _LIT8( KHttpResponseServer, "Server" );

    _LIT8( KHttpResponseVary, "Vary" );

#endif    

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

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

// Creator

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

//	

CCatalogsHttpDownload* CCatalogsHttpDownload::NewLC( 

    CCatalogsHttpDownloadManager& aOwner, 

    Download* aDownload,

    const CCatalogsHttpConfig& aConfig )

    {

    CCatalogsHttpDownload* self = new( ELeave ) CCatalogsHttpDownload( 

        aOwner,

        aDownload );

    CleanupStack::PushL( self );

    self->ConstructL( &aConfig );    

    return self;

    }

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

// Destructor

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

//	

CCatalogsHttpDownload::~CCatalogsHttpDownload()

    {    

    DLTRACEIN(( "this-ptr: %X", this ));

    SetTransferring( EFalse );

    if ( iTransaction ) 

        {

        DLTRACE(("Cancelling transaction"));

        iTransaction->Cancel();

        }

    // Normally, iDownload is not deleted since it would also remove the

    // incomplete files etc.

    if ( iDownload )     

        {

        DLTRACE(("RHttpDownload-ptr: %x", iDownload ));

        if ( iNormalDelete && 

             iState.iOperationState != ECatalogsHttpOpCompleted &&

             iState.iOperationState != ECatalogsHttpOpFailed ) 

            {

            DLTRACE(("Setting download as paused"));

            SetDeleteState( EDownloadPaused );

            }

        else 

            {

            DLTRACE(( "Deleting download" ));

             iOwner.GetDownloadManager()->removeOne(iDownload);                      

            if ( iState.iOperationState != ECatalogsHttpOpCompleted ) 

                {

                // Ensure that temp files are really deleted

                DeleteFiles();

                }

            }                   

        }

    ReleasePtr( iConnection );

    DLTRACE(( "Removing from owner" ));

    if ( iState.iOperationState != ECatalogsHttpOpCompleted &&

         iState.iOperationState != ECatalogsHttpOpFailed ) 

        {

        iOwner.CompleteOperation( this );

        }

    else if ( iState.iOperationState == ECatalogsHttpOpFailed

        && iState.iProgressState != ECatalogsHttpDone )

        {

        iOwner.CompleteOperation( this );

        }

    iOwner.RemoveDownload( this );        

    delete iConfig;

    delete iResponseHeaders;

    delete iAddedRequestHeaders;   

    delete iUri;

    delete iEncodedUri;

    delete iTempFilename;

    iDdFile.Close();

    }

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

// Add a reference

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

//

TInt CCatalogsHttpDownload::AddRef()

    {

    iRefCount++;

    return iRefCount;    

    }

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

// Release a reference

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

//

TInt CCatalogsHttpDownload::Release()

    {

    DLTRACEIN(( "" ));

    iRefCount--;

    if ( !iRefCount ) 

        {

        // Ensures that iDownload is not deleted and therefore paused/ongoing

        // downloads will be handled as determined by the quit operation

        iNormalDelete = ETrue;

        delete this;

        return 0;

        }

    return iRefCount;

    }

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

// Reference count

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

//        

TInt CCatalogsHttpDownload::RefCount() const

    {

    return iRefCount;

    }

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

// Cancel download

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

//	

TInt CCatalogsHttpDownload::Cancel()

    {

    DLTRACEIN( ( "this: %x, ID: %d, Operation state: %i, Progress state: %d",

        this, iId.Id(), 

        iState.iOperationState, iState.iProgressState ) );

    iTransferredSize = 0;

    if ( iTransaction ) 

        {

        iTransaction->Cancel();

        iTransaction = NULL;                        

        }

#ifdef __SERIES60_31__

    // Have to pause downloads before deleting. Otherwise progress events

    // will stop coming because DL manager's event queue gets stuck in 3.1.

    iCancelled = ETrue;

    if ( iDownload )

        {

        iObserver = NULL;

        TInt32 state = 0;

         state = (Download::State)iDownload->attribute(State).toInt();

        if ( IsOneOf( 

                static_cast<THttpDownloadState>( state ), 

                EHttpDlCreated,

                EHttpDlPaused,

                EHttpDlCompleted,

                EHttpDlFailed ) )

            {

            DLTRACE(("Deleting download"));

            DeletePlatformDownload();

            }

        else

            {

            DLTRACE(("Pausing download"));

            iDownload->Pause();

            return RefCount();

            }

        }

    DLTRACE(("No iDownload"));

    ReleasePtr( iConnection );

    SetTransferring( EFalse );

    DeleteFiles();

    iOwner.CompleteOperation( this );

    iState.iOperationState = ECatalogsHttpOpDeleting;

    iState.iProgressState = ECatalogsHttpDone;

    return Release();                    

#else    

    // DLMAIN-546, if the download was completed before cancel

    // was executed then DL manager's download has already been deleted

    DeletePlatformDownload();

    ReleasePtr( iConnection );

    SetTransferring( EFalse );

    DeleteFiles();

    // call CancelOperation only if the download had been started (or at least

    // tried)

    if ( iState.iProgressState != ECatalogsHttpNone && 

         iState.iProgressState != ECatalogsHttpDone ) 

        {     

        DLTRACE(("Cancelling the operation"));                   

        iOwner.CompleteOperation( this );

        iState.iOperationState = ECatalogsHttpOpDeleting;

        iState.iProgressState = ECatalogsHttpDone;

        }

    return Release();

#endif    

    }

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

// Download progress

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

//	

TCatalogsTransportProgress CCatalogsHttpDownload::Progress() const

    {

    if ( iState.iOperationState == ECatalogsHttpOpInProgress ) 

        {

        TInt32 contentSize = ContentSize();

        if ( !contentSize ) 

            {

            // Prevent division by zero problems

            contentSize = 1;

            }

        return TCatalogsTransportProgress( iState.iOperationState, TransferredSize(), 

            contentSize );

        }

    return TCatalogsTransportProgress( iState.iOperationState, 0, 1 );

    }

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

// Start download

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

//	

TInt CCatalogsHttpDownload::Start( TResumeStartInformation aResumeOrigin )

    {

    DLTRACEIN(( "op state: %d, prog state: %d", iState.iOperationState,

        iState.iProgressState ));    

    TInt err = KErrNone;

    if ( iState.iProgressState == ECatalogsHttpNone ) 

        {

        DLTRACE(("Updating dl config"));

        TRAP( err, UpdateDownloadConfigurationL() );

        if ( err != KErrNone ) 

            {

            return err;

            }

        }    

    if ( aResumeOrigin == EAutomaticResume && iPaused )

        {

        // Download is continued automatically but

        // it is paused, and we do not resume it

        }

    else if( iPausePending )

        {

        // Pausing is an asynchronous operation therefore we need to enqueue

        // resume while pause is pending (we get an event from dlmgr when pause is done)

        DLTRACE(("Enqueuing resume"));

        iQueuedResume = ETrue;

        }

    // Start from the beginning or continue from paused

    else if ( ( iState.iProgressState == ECatalogsHttpNone || 

         iState.iOperationState == ECatalogsHttpOpPaused ||

         iState.iOperationState == ECatalogsHttpOpQueued ) && 

         !iTransaction ) 

        {        

        DLTRACE(("Starting the operation"));

        // Check if the download can be started or put it to queue

        err = iOwner.StartOperation( this ); 

        if ( err == KErrNone ) 

            {                        

            DLTRACE(("Starting the actual download"));         

            err = StartDownload();

            if ( err == KErrNone ) 

                {

                DLTRACE(("DL started"));

                iState.iOperationState = ECatalogsHttpOpInProgress;

                iState.iProgressState = ECatalogsHttpStarted;

                iPaused = EFalse;

    		    if ( iObserver ) 

    		        {		        

        		    TRAP( err, iObserver->HandleHttpEventL( 

        		        *this, 

        		        iState ) );

    		        }

                }

            else 

                {

                DLTRACE(( "Start failed with: %i", err ));

                }

            }

        else if ( err == KCatalogsHttpOperationQueued ) 

            {            

            // Set state as queued and notify the observer

            err = KErrNone;

            iState.iOperationState = ECatalogsHttpOpQueued;

            iPaused = EFalse;

            if ( iObserver ) 

                {

                TRAP( err, iObserver->HandleHttpEventL( *this, iState ) );

                }

            }        

        }

    return err;

    }

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

// Pause download

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

//	

TInt CCatalogsHttpDownload::Pause()

    {

    DLTRACEIN( ( "" ) );    

    if( iQueuedResume )

        {

        DLTRACE(("Removing queued resume"));

        iQueuedResume = EFalse;

        return KErrNone;

        }

    else if ( iTransaction ) 

        {

        DLTRACE(("Was getting the headers"));

        iTransaction->Cancel();

        iTransaction = NULL;

        if ( iDdDownload ) 

            {

            DLTRACE(("DD download. Cannot really pause but we fake it"));

            TFileName name;

            iDdFile.FullName( name );

            iDdFile.Close();

            iFs.Delete( name ); 

            // Reseting filename so that HTTP headers are taken again

            // and DD download is restarted correctly.

            //

            // This is not the optimal solution but otherwise we would need

            // to handle DD download resuming after client restart 

            // differently from resuming normal downloads

            //

            // SetFilenameL can't actually leave here because it just deletes

            // the old filename without any new memory allocations

            TRAP_IGNORE( iConfig->SetFilenameL( KNullDesC() ) );

            iDdDownload = EFalse;           

            }

        ReleasePtr( iConnection );

        // Notify the session manager that there's room for executing

        // another operation

        iOwner.PauseOperation( this );

        iState.iOperationState = ECatalogsHttpOpPaused;

        iState.iProgressState = ECatalogsHttpNone;

        iPaused = ETrue; 

        SetTransferring( EFalse );           

        return KErrNone;

        }

    else 

        {

        // Set pending flag

        if( iState.iOperationState == ECatalogsHttpOpInProgress)

            {

            DLTRACE(("Set pause pending flag"));

            iPausePending = ETrue;

            }

        // It's possible that pause is not supported but then the download is

        // just restarted when it's resumed

        DLTRACE(("Thread semaphore count: %d", RThread().RequestCount() ));

        TInt err = KErrNone;

        if ( iDownload ) 

            {

					    try

							{

							iDownload->pause();

							}

			        catch(const std::exception& exception)

			        	{

							 err = qt_symbian_exception2Error(exception);

			        	}

            }

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

        if ( err == KErrNone ) 

            {

            ReleasePtr( iConnection );

            if ( !iPaused )

                {

                // Notify the session manager that there's room for executing

                // another operation

                iOwner.PauseOperation( this );

                }

            iState.iOperationState = ECatalogsHttpOpPaused;

            iPaused = ETrue;            

            SetTransferring( EFalse );

            }

        DLTRACEOUT(("Operation paused"));

        return err;

        }

    }

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

// 

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

//	

void CCatalogsHttpDownload::NotifyCancel()

    {

    DLTRACEIN((""));

    if ( iObserver )

        {

        iObserver->HandleHttpError( *this, TCatalogsHttpError(

            ECatalogsHttpErrorGeneral, KErrCancel ) );

        }

    else 

        {

        DLINFO(("No observer"));

        }