/*
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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 FILES

#include <e32base.h>
#include <f32file.h>
#include <DownloadMgrClient.h>
#include <HttpDownloadMgrCommon.h>

#include "IptvTestDownloadManager.h"
#include "VCXTestLog.h"
#include "CIptvTestTimer.h"

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

// ---------------------------------------------------------------------------
// CTestUtilConnection::NewL()
//
// Constructs CTestUtilConnection object
// ---------------------------------------------------------------------------
//
EXPORT_C CIptvTestDownloadManager* CIptvTestDownloadManager::NewL(MTestUtilDownloadObserver *aObs)
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::NewL");
    CIptvTestDownloadManager* self = NewLC(aObs);
    CleanupStack::Pop(self);
    VCXLOGLO1("<<<CIptvTestDownloadManager::NewL");
    return self;
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::NewLC()
//
// Constructs CTestUtilConnection object
// ---------------------------------------------------------------------------
//
EXPORT_C CIptvTestDownloadManager* CIptvTestDownloadManager::NewLC(MTestUtilDownloadObserver *aObs)
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::NewLC");
    CIptvTestDownloadManager* self = new (ELeave) CIptvTestDownloadManager(aObs);
    CleanupStack::PushL(self);
    self->ConstructL();
    VCXLOGLO1("<<<CIptvTestDownloadManager::NewLC");
    return self;
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::CTestUtilConnection()
//
// Constructor
// ---------------------------------------------------------------------------
//
CIptvTestDownloadManager::CIptvTestDownloadManager(MTestUtilDownloadObserver *aObs)
: iObserver(aObs)
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::CIptvTestUtilConnection");

    VCXLOGLO1("<<<CIptvTestDownloadManager::CIptvTestUtilConnection");
    }

// ---------------------------------------------------------------------------
// CTestUtilConnection::~CTestUtilConnection()
//
// Destructor
// ---------------------------------------------------------------------------
//
EXPORT_C CIptvTestDownloadManager::~CIptvTestDownloadManager()
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::~CIptvTestDownloadManager");

	iDownloadMgr.DeleteAll();
	iDownloadMgr.RemoveObserver(*this);
	iDownloadMgr.Close();

	if( iDownload )
		{
		iDownload->Delete();
		iDownload = NULL;
		}

    if( iTimer )
        {
        delete iTimer;
        iTimer = NULL;
        }

    VCXLOGLO1("<<<CIptvTestDownloadManager::~CIptvTestDownloadManager");
    }

// ---------------------------------------------------------------------------
// CIptvTestDownloadManager::ConstructL()
//
// Second phase constructor
// ---------------------------------------------------------------------------
//
EXPORT_C void CIptvTestDownloadManager::ConstructL()
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::ConstructL");

	iDownloadRunning = EFalse;
	TUid uid;
	uid.iUid = 0x101FB3E3;
	iDownloadMgr.ConnectL(uid, *this, ETrue);

    iTimer = CIptvTestTimer::NewL(*this, 0);

   	VCXLOGLO1("<<<CIptvTestDownloadManager::ConstructL");
    }


// ---------------------------------------------------------------------------
// CIptvTestDownloadManager::HandleDMgrEventL()
//
// ---------------------------------------------------------------------------
//
void CIptvTestDownloadManager::HandleDMgrEventL( RHttpDownload& aDownload, THttpDownloadEvent aEvent )
	{
	VCXLOGLO1(">>>CIptvTestDownloadManager::HandleDMgrEventL");

	TInt32 downloadId;
	aDownload.GetIntAttribute(EDlAttrId, downloadId);

	VCXLOGLO3("CIptvTestDownloadManager:: downloadId: %d, aEvent: %d", downloadId, aEvent);

    switch (aEvent.iProgressState)
        {
        case EHttpContentTypeReceived:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpContentTypeReceived");
            User::LeaveIfError(aDownload.Start());
            break;
        case EHttpProgNone:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgNone");
            break;
        case EHttpStarted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpStarted");
            break;
        case EHttpProgCreatingConnection:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCreatingConnection");
            break;
        case EHttpProgConnectionNeeded:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnectionNeeded");
            break;
        case EHttpProgConnected:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnected");
            break;
        case EHttpProgConnectionSuspended:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgConnectionSuspended");
            break;
        case EHttpProgDisconnected:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDisconnected");
            break;
        case EHttpProgDownloadStarted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDownloadStarted");
            break;
        case EHttpContentTypeRequested:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpContentTypeRequested");
            break;
        case EHttpProgSubmitIssued:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgSubmitIssued");
            break;
        case EHttpProgResponseHeaderReceived:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgResponseHeaderReceived");
            break;
        case EHttpProgResponseBodyReceived:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgResponseBodyReceived");
            break;
        case EHttpProgRedirectedPermanently:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgRedirectedPermanently");
            break;
        case EHttpProgRedirectedTemporarily:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgRedirectedTemporarily");
            break;
        case EHttpProgDlNameChanged:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgDlNameChanged");
            break;
        case EHttpProgContentTypeChanged:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgContentTypeChanged");
            break;
        case EHttpProgCodDescriptorDownloaded:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDescriptorDownloaded");
            break;
        case EHttpProgCodDownloadStarted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDownloadStarted");
            break;
        case EHttpProgCodDescriptorAccepted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodDescriptorAccepted");
            break;
        case EHttpProgCodLoadEnd:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgCodLoadEnd");
            break;
        case EHttpProgSupportedMultiPart:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgSupportedMultiPart");
            break;
        case EHttpProgMovingContentFile:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgMovingContentFilep");
            break;
        case EHttpProgContentFileMoved:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpProgContentFileMoved");
            break;
        default:
            VCXLOGLO1("CIptvTestDownloadManager:: Unknown state");
            break;
        }

    switch (aEvent.iDownloadState)
        {
        case EHttpDlCompleted:
            {
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCompleted");

			DeleteDownloadAsync( KErrNone );
            }
            break;

        case EHttpDlFailed:
            {
			TInt32 err;
			GetError( aDownload, err );
			VCXLOGLO2("CIptvTestDownloadManager:: Download failed, err: %d", err);
			if( err == KErrNone )
			    {
			    err = KErrGeneral;
			    }
			DeleteDownloadAsync( err );
            }
            break;

        case EHttpDlCreated:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCreated");
            iDownloadRunning = ETrue;
            break;

        case EHttpDlInprogress:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlInprogress");
            break;

        case EHttpDlPaused:
            {
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlPaused");

			TInt32 err;
			GetError(aDownload, err);
			VCXLOGLO2("CIptvTestDownloadManager:: Download is paused, err: %d", err);
			if(err == KErrNone) err = KErrGeneral;

			DeleteDownloadAsync( err );
            }
	        break;

        case EHttpDlMoved:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMoved");
            break;

        case EHttpDlMediaRemoved:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMediaRemoved");
            break;

        case EHttpDlMediaInserted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlMediaInserted");
            break;

        case EHttpDlPausable:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlPausable");
            break;

        case EHttpDlNonPausable:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlNonPausable");
            break;

        case EHttpDlDeleted:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlDeleted");

            if( !iDownloadFinishInformed )
                {
                VCXLOGLO1("CIptvTestDownloadManager:: Informing observer.");
                iDownloadFinishInformed = ETrue;
                iObserver->DownloadFinished( iError );
                iDownloadRunning = EFalse;
                }
            break;

        case EHttpDlAlreadyRunning:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlAlreadyRunning");
            break;

        case EHttpDlDeleting:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlDeleting");
            if( !iDownloadFinishInformed )
                {
                VCXLOGLO1("CIptvTestDownloadManager:: Informing observer.");
                iDownloadFinishInformed = ETrue;
                iObserver->DownloadFinished( iError );
                iDownloadRunning = EFalse;
                }
            break;

        case EHttpDlCancelTransaction:
            VCXLOGLO1("CIptvTestDownloadManager:: EHttpDlCancelTransaction");
            break;

        default:
            VCXLOGLO1("CIptvTestDownloadManager:: Unknown state");
            break;
        }


	VCXLOGLO1("<<<CIptvTestDownloadManager::HandleDMgrEventL");
	}

// ---------------------------------------------------------------------------
// CIptvTestDownloadManager::DownloadL()
//
// ---------------------------------------------------------------------------
//
EXPORT_C TInt CIptvTestDownloadManager::DownloadL( TDesC& aAddress, TDesC16& aOutFile, TDesC& aUserName, TDesC& aPassword, TInt32 aIapId, TInt aTimeoutSeconds)
	{
	VCXLOGLO1(">>>CIptvTestDownloadManager::DownloadL");

	TBool result;

	if( iDownload )
		{
		VCXLOGLO1("Download already ongoing.");
		VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");
		return KErrNone;
		}

	iDownloadFinishInformed = EFalse;
	iTimerStartedForDownloadDeletion = EFalse;
	iError = KErrNone;

    iTimer->After(aTimeoutSeconds * 1000000);

    TBuf8<3000> address;
    TBuf8<256> username;
	TBuf8<256> password;

	address.Copy(aAddress);
	username.Copy(aUserName);
	password.Copy(aPassword);

	VCXLOGLO3("CIptvTestDownloadManager:: Starting downloading: %S -> %S", &aAddress, &aOutFile);
	VCXLOGLO3("CIptvTestDownloadManager:: User: %S, PW %S", &aUserName, &aPassword);
	VCXLOGLO2("CIptvTestDownloadManager:: Timeout: %d", aTimeoutSeconds);

	TInt err = KErrNone;

	err = iDownloadMgr.SetIntAttribute( EDlMgrIap, aIapId );
    if ( err != KErrNone )
        {
        VCXLOGLO2("CIptvTestDownloadManager:: Could not set AP! err: %d", err);
        return err;
        }

	RHttpDownload& download = iDownloadMgr.CreateDownloadL( address, result );

	iDownload = &download;

    err = iDownload->SetStringAttribute( EDlAttrDestFilename, aOutFile);
    if(err != KErrNone)
    	{
    	VCXLOGLO1("Setting destfilename failed.");
    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");
    	return err;
    	}

    download.SetBoolAttribute(EDlAttrNoContentTypeCheck, ETrue);
    download.SetIntAttribute(EDlAttrUserData, 0);

    err = download.SetStringAttribute(EDlAttrUsername, username);
    if(err != KErrNone)
    	{
    	VCXLOGLO1("Setting download username failed.");
    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");
    	return err;
    	}

    err = download.SetStringAttribute(EDlAttrPassword, password);
    if(err != KErrNone)
    	{
    	VCXLOGLO1("Setting download password failed.");
    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");
    	return err;
    	}

	err = iDownload->Start();
    if(err != KErrNone)
    	{
    	VCXLOGLO1("Starting download failed.");
    	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");
    	return err;
    	}

	VCXLOGLO1("<<<CIptvTestDownloadManager::DownloadL");

	return err;
	}

// ---------------------------------------------------------
// CIptvTestDownloadManager::GetError
// ---------------------------------------------------------
//
EXPORT_C void CIptvTestDownloadManager::GetError(RHttpDownload& aDownload,
                                          TInt32& aDownloadError)
    {
    TInt32 errorId;
    TInt32 globalErrorId;
    aDownload.GetIntAttribute(EDlAttrErrorId, errorId);
    aDownload.GetIntAttribute(EDlAttrGlobalErrorId, globalErrorId);
    VCXLOGLO2("CIptvTestDownloadManager:: DL error ID: %d", errorId);
    VCXLOGLO2("CIptvTestDownloadManager:: DL global error ID: %d", globalErrorId);

    switch(errorId)
        {
        case EConnectionFailed:
            aDownloadError = EConnectionFailed;
            VCXLOGLO1("CIptvTestDownloadManager::  EConnectionFailed -> EIptvDlConnectionFailed");
            if(globalErrorId == KErrServerBusy)
                {
                VCXLOGLO1("CIptvTestDownloadManager:: server busy -> EIptvDlGeneral");
                aDownloadError = KErrServerBusy;
                }
            break;
        case EHttpAuthenticationFailed:
            VCXLOGLO1("CIptvTestDownloadManager::  EHttpAuthenticationFailed -> EIptvDlAuthFailed");
            aDownloadError = EHttpAuthenticationFailed;
            break;
        case EProxyAuthenticationFailed:
            VCXLOGLO1("CIptvTestDownloadManager::  EProxyAuthenticationFailed -> EIptvDlProxyAuthFailed");
            aDownloadError = EProxyAuthenticationFailed;
            break;
        case EDestFileInUse:
            VCXLOGLO1("CIptvTestDownloadManager::  EDestFileInUse -> EIptvDlDestFileInUse");
            aDownloadError = EDestFileInUse;
            break;
        case EBadUrl:
            VCXLOGLO1("CIptvTestDownloadManager::  EBadUrl -> EIptvDlBadUrl");
            aDownloadError = EBadUrl;
            break;
        case EMMCRemoved:
            VCXLOGLO1("CIptvTestDownloadManager::  EMMCRemoved -> EIptvDlMmcRemoved");
            aDownloadError = EMMCRemoved;
            break;
        case EDiskFull:
            VCXLOGLO1("CIptvTestDownloadManager::  EDiskFull -> EIptvDlDiskFull");
            aDownloadError = EDiskFull;
            break;
        case EObjectNotFound:
            VCXLOGLO1("CIptvTestDownloadManager::  EObjectNotFound -> EIptvDlContentNotFound");
            aDownloadError = EObjectNotFound;
            break;

        default:
            VCXLOGLO1("CIptvTestDownloadManager::  unknown -> EIptvDlGeneral");
            aDownloadError = KErrGeneral;
            break;
        }
    }

// ---------------------------------------------------------
// CIptvTestDownloadManager::DeleteDownloadAsync
// ---------------------------------------------------------
//
void CIptvTestDownloadManager::DeleteDownloadAsync( TInt aErrorToObserver )
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::DeleteDownloadAsync");
    if( iDownload )
        {
        iTimer->After( 1000000 ); // 1 second
        iTimerStartedForDownloadDeletion = ETrue;
        iError = aErrorToObserver;
        }
    VCXLOGLO1("<<<CIptvTestDownloadManager::DeleteDownloadAsync");
    }

void CIptvTestDownloadManager::TimerComplete( TInt aTimerId, TInt aError )
    {
    VCXLOGLO1(">>>CIptvTestDownloadManager::TimerComplete");

    VCXLOGLO3("CIptvTestDownloadManager:: aTimerId: %d, aError: %d", aTimerId, aError);

    if( iTimerStartedForDownloadDeletion )
        {
        iTimerStartedForDownloadDeletion = EFalse;
        VCXLOGLO1("IptvTestDownloadManager:: Deleting the download.");

        if( iDownload )
            {
            iDownload->Delete();
            iDownload = NULL;
            }

        // Obsever is informed at DL deletion.
        }
    else
        {
        iObserver->DownloadFinished(KErrTimedOut);
        }

    VCXLOGLO1("<<<CIptvTestDownloadManager::TimerComplete");
    }

//  End of File