/*

* Copyright (c) 2006-2007 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:  Engine to fetch the logos 

*

*/

#include <aknnotewrappers.h> 

#include "irlogodownloadengine.h"

#include "irnetworkcontroller.h"

#include "ircachemgmt.h"

#include "irhttprequestdata.h"

#include "irdebug.h"

#include "irdataproviderconstants.h"

#include "iractivenetworkobserver.h"

_LIT(KLogoX, "?x=");

_LIT(KLogoY, "&y=");

const TInt KPresetsArrayMaxLength = 50;

const TInt KLogoSize = 59;

const TInt KParameterSize = 12;

const TInt KTen = 10;

const TInt KCacheAvailable = 4;

const TInt KLogo = 4;

const TInt KStatusOK = 200;

const TInt KStatusMultipleChoices = 300;

const TInt KStatusNotModified = 304;

const TInt KStatusGatewayTimeout = 504;

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

// CIRLogoDownloadEngine::NewL()

// Creates instance of CIRLogoDownloadEngine.

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

//

EXPORT_C CIRLogoDownloadEngine* CIRLogoDownloadEngine::NewL()

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::NewL - Entering" );

    CIRLogoDownloadEngine* self = new(ELeave) CIRLogoDownloadEngine();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    IRLOG_DEBUG( "CIRLogoDownloadEngine::NewL - Exiting" );

    return self;

	}

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

// CIRLogoDownloadEngine::CIRLogoDownloadEngine()

// Standard C++ constructor

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

//

CIRLogoDownloadEngine::CIRLogoDownloadEngine()

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::CIRLogoDownloadEngine " );

	//code here, if needed

	}

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

// CIRLogoDownloadEngine::~CIRLogoDownloadEngine()

// Destructs instance of CIRLogoDownloadEngine.

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

//

EXPORT_C CIRLogoDownloadEngine::~CIRLogoDownloadEngine()

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::~CIRLogoDownloadEngine - Entering" );

    if(iReqBody)

    	{

    	delete iReqBody;

    	iReqBody = NULL;

    	}

    if(iRespBody)

    	{

    	delete iRespBody;

    	iRespBody = NULL;

    	}

	CancelTransaction();

	iLogoSession.Close();

	if(iCopyPreset)

		{

		delete iCopyPreset;

		}

	if(iCacheTempPreset)

		{

		delete iCacheTempPreset;			

		}

	if(iTempPreset)

		{

		delete iTempPreset;			

		}

	if(iPresetArray)

		{

		iPresetArray->ResetAndDestroy();

		}

	delete iPresetArray;

	if(iObserverArray)

		{

		delete iObserverArray;

		iObserverArray = NULL;

		}

	if(iReqFromArray)

		{

		delete iReqFromArray;

		iReqFromArray = NULL;

		}

	if(iCachePresetArray)

		{

		iCachePresetArray->ResetAndDestroy();

		}

	delete iCachePresetArray;

	if(iCacheObserverArray)

		{

		delete iCacheObserverArray;

		iCacheObserverArray = NULL;

		}

	if(iCacheReqFromArray)

		{

		delete iCacheReqFromArray;

		iCacheReqFromArray = NULL;

		}

	if(iIRNetworkControllerHandle)

    	{

    	iIRNetworkControllerHandle->DeleteActiveNetworkObserver(*this);

    	iIRNetworkControllerHandle->Close();

        }		

    if (iCache)

	    {

	    iCache->RemoveObserver(this);

	    iCache->Close();

	    }

	if( iResponseHeaders )

		{

        delete iResponseHeaders;

		}

	IRLOG_DEBUG( "CIRLogoDownloadEngine::~CIRLogoDownloadEngine - Exiting" );

	}

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

// CIRLogoDownloadEngine::ConstructL()

// 2nd phase construction

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

//

void CIRLogoDownloadEngine::ConstructL()

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::ConstructL - Entering" );

	iPresetArray = new (ELeave) CArrayPtrFlat<CIRIsdsPreset>(KPresetsArrayMaxLength);

	iObserverArray = new (ELeave) CArrayPtrFlat<MLogoDownloadObserver>(KPresetsArrayMaxLength);

	iReqFromArray = new (ELeave) CArrayFixFlat<TInt>(KPresetsArrayMaxLength);

	iCachePresetArray = new (ELeave) CArrayPtrFlat<CIRIsdsPreset>(KPresetsArrayMaxLength);

	iCacheObserverArray = new (ELeave) CArrayPtrFlat<MLogoDownloadObserver>(KPresetsArrayMaxLength);

	iCacheReqFromArray = new (ELeave) CArrayFixFlat<TInt>(KPresetsArrayMaxLength);

	iPresetArrayPos = 0;

	iReqFromArrayPos = 0;

	iObserverArrayPos = 0;

	iCachePresetArrayPos = 0;

	iCacheReqFromArrayPos = 0;

	iCacheObserverArrayPos = 0;

	iImageIndex = 0; //using temporarily till the isds provides urls

	iPresetModifiedStatus = EFalse;

	iFirstTime = ETrue;

	iIRNetworkControllerHandle = CIRNetworkController::OpenL();

	iIRNetworkControllerHandle->RegisterActiveNetworkObserverL(*this);

	iCache = CIRCacheMgmt::OpenL(*this);

	iCache->AddObserverL(this);

	iResponseHeaders = new ( ELeave ) CIRHttpResponseData;

	//change to use the new session for logo downloading

	TRAPD( LeaveValue, iLogoSession.OpenL() );

    if ( LeaveValue != KErrNone )

        {

        // Most common error; no access point configured, and session creation

        // leaves with KErrNotFound.

        // Load a string from the resource file and add the error code to string

        User::Leave( LeaveValue );

        }

    IRLOG_DEBUG( "CIRLogoDownloadEngine::ConstructL - Exiting" );

	}

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

// CIRLogoDownloadEngine::IsRunning()

// To know the status of downloading logo

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

//

EXPORT_C TBool CIRLogoDownloadEngine::IsRunning() const

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::IsRunning" );

    return iRunning;

	}

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

// CIRLogoDownloadEngine::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField,

//                              const TDesC8& aHdrValue)

// to set the headers of the http transaction

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

//

void CIRLogoDownloadEngine::SetHeaderL(RHTTPHeaders aHeaders, TInt aHdrField,

					 const TDesC8& aHdrValue) const

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SetHeaderL - Entering" );

	RStringF valStr = iLogoSession.StringPool().OpenFStringL(aHdrValue);

	CleanupClosePushL(valStr);

	THTTPHdrVal val(valStr);

	aHeaders.SetFieldL(iLogoSession.StringPool().StringF(aHdrField, RHTTPSession::GetTable()), val);

	CleanupStack::PopAndDestroy(&valStr); // valStr

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SetHeaderL - Exiting" );

	}

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

// CIRLogoDownloadEngine::SendRequestL(CIRIsdsPreset* aPreset,TInt aXValue,TInt aYValue)

// API is called from the SearchResultsView for to download logo while doing Add to Favorites

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

//

EXPORT_C void CIRLogoDownloadEngine::SendRequestL(CIRIsdsPreset* aPreset,TInt aXValue,TInt aYValue)

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Entering" );

	if(!iCheckingCache)

		{

		++iImageIndex;

		iCheckingCache = ETrue;

		iCacheReqFrom = 0;

		if(iCacheTempPreset)

			{

			delete iCacheTempPreset;				

			}

		iCacheTempPreset = NULL;

		iCacheTempPreset = CIRIsdsPreset::NewL();

		*iCacheTempPreset = *aPreset;

		if(iCacheTempPreset->GetImgUrl().Length() != 0)

			{

			if((aXValue > 0)&&(aYValue > 0))

				{

				//Append the parameters(width,height) of the logo size to imgUrl

				TInt size = iCacheTempPreset->GetImgUrl().Length() + KParameterSize;

				RBuf urlWithSize;

				urlWithSize.Create(size);

				urlWithSize.Copy(iCacheTempPreset->GetImgUrl());

				urlWithSize.Append(KLogoX);

				urlWithSize.AppendNum(aXValue);

				urlWithSize.Append(KLogoY);

				urlWithSize.AppendNum(aYValue);

				//set the imgUrl with parameters to the preset

				iCacheTempPreset->SetImgUrl(urlWithSize);

				urlWithSize.Close();

				}

			//This method checks whether the logo is available

 			// for the request made

			iForceGet = EFalse; 			

			CheckCacheForLogoL(0);

			}

		else

			{

			//imgUrl doesnt exist in the Preset

		    iCheckingCache = EFalse;

			return;			

			}

		iCheckingCache = EFalse;

		if(!iLogoCached)	

			{

			FetchLogoDataL(iCacheTempPreset);				

			}

		}

	else

		{

		CIRIsdsPreset* tempPreset;

		tempPreset = CIRIsdsPreset::NewL();

		*tempPreset = *aPreset;

		if(tempPreset->GetImgUrl().Length() != 0)

			{

			if((aXValue > 0)&&(aYValue > 0))

				{

				//Append the parameters(width,height) of the logo size to imgUrl

				TInt size = tempPreset->GetImgUrl().Length() + KParameterSize;

				RBuf urlWithSize;

				urlWithSize.Create(size);

				urlWithSize.Copy(tempPreset->GetImgUrl());

				urlWithSize.Append(KLogoX);

				urlWithSize.AppendNum(aXValue);

				urlWithSize.Append(KLogoY);

				urlWithSize.AppendNum(aYValue);

				//set the imgUrl with parameters to the preset

				tempPreset->SetImgUrl(urlWithSize);

				urlWithSize.Close();				

				}

			}

		iCachePresetArray->AppendL(tempPreset);

 		iCacheReqFromArray->AppendL(0);	

		}	

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Exiting" );

	}

EXPORT_C TBool CIRLogoDownloadEngine::isLogoCachedL(CIRIsdsPreset* aPreset, TInt aXValue, TInt aYValue)

{

    TInt cached = 0;

    if(iCacheTempPreset)

    {

        delete iCacheTempPreset;

        iCacheTempPreset = NULL;

    }

    iCacheTempPreset = CIRIsdsPreset::NewL();

    *iCacheTempPreset = *aPreset;

    iCacheReqMade = EFalse;

    if (iCacheTempPreset->GetImgUrl().Length() != 0)

    {

        if ((aXValue > 0) && (aYValue > 0))

        {

            //Append the parameters(width,height) of the logo size to imgUrl

            TInt size = iCacheTempPreset->GetImgUrl().Length() + KParameterSize;

            RBuf urlWithSize;

            urlWithSize.Create(size);

            urlWithSize.Copy(iCacheTempPreset->GetImgUrl());

            urlWithSize.Append(KLogoX);

            urlWithSize.AppendNum(aXValue);

            urlWithSize.Append(KLogoY);

            urlWithSize.AppendNum(aYValue);

            //set the imgUrl with parameters to the preset

            iCacheTempPreset->SetImgUrl(urlWithSize);

            urlWithSize.Close();

        }

    }

    iCache->CheckCacheL(KLogo,iCacheTempPreset->GetImgUrl(),EFalse,cached);

    return (CIRCacheMgmt::ECacheUseable == cached)?ETrue:EFalse;     

}

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

// CIRLogoDownloadEngine::SendRequestL(CIRIsdsPreset* aPreset,MLogoDownloadObserver* aLogoHandle,

//													TInt aNPVReq,TInt aXValue,TInt aYValue)

// API is called from several views for to download logo 

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

//

EXPORT_C void CIRLogoDownloadEngine::SendRequestL(CIRIsdsPreset* aPreset,

			MLogoDownloadObserver* aLogoHandle,TInt aNPVReq,TInt aXValue,TInt aYValue)

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Entering" );

	if(aPreset->GetChannelType()==0)

		{

		aLogoHandle->PresetLogoDownloadedL(aPreset);

		}

	else if(!iCheckingCache)

		{

		++iImageIndex;

		iCheckingCache = ETrue;

		if(aNPVReq==2)

			{

			iCacheReqFrom=2;			

			}

		else

			{

			iCacheReqFrom=1;			

			}

		if(iCacheTempPreset)

			{

			delete iCacheTempPreset;

			iCacheTempPreset = NULL;				

			}

		iCacheTempPreset = CIRIsdsPreset::NewL();

		*iCacheTempPreset = *aPreset;

		iCacheTempLogoHandle = aLogoHandle;

		if(iCacheTempPreset->GetImgUrl().Length() != 0)

			{

			if((aXValue > 0)&&(aYValue > 0))

				{

				//Append the parameters(width,height) of the logo size to imgUrl

				TInt size = iCacheTempPreset->GetImgUrl().Length() + KParameterSize;

				RBuf urlWithSize;

				urlWithSize.Create(size);

				urlWithSize.Copy(iCacheTempPreset->GetImgUrl());

				urlWithSize.Append(KLogoX);

				urlWithSize.AppendNum(aXValue);

				urlWithSize.Append(KLogoY);

				urlWithSize.AppendNum(aYValue);

				//set the imgUrl with parameters to the preset

				iCacheTempPreset->SetImgUrl(urlWithSize);

				urlWithSize.Close();

				}

			if(iCacheReqFrom==1 || iCacheReqFrom==2)

				{

				//This method checks whether the logo is available

		 		// for the request made

				iForceGet = EFalse;		 		

				CheckCacheForLogoL(0);	

				}

/*			else if(iCacheReqFrom==2)

				{

				//the request has come from NowPlayingView(NPV)

				//dont check for logo availability in cache

				//download the logo freshly

				iLogoCached=EFalse;								

				}

*/			}

		else

			{

			//imgUrl doesnt exist in the Preset

		    iCheckingCache = EFalse;

			return;			

			}

		iCheckingCache = EFalse;

		if(!iLogoCached)	

			{

			FetchLogoDataL(iCacheTempPreset,aLogoHandle,iCacheReqFrom);				

			}

		}

	else

		{

		CIRIsdsPreset* tempPreset;

		tempPreset = CIRIsdsPreset::NewL();

		*tempPreset = *aPreset;

		if(tempPreset->GetImgUrl().Length() != 0)

			{

			if((aXValue > 0)&&(aYValue > 0))

				{

				//Append the parameters(width,height) of the logo size to imgUrl

				TInt size = tempPreset->GetImgUrl().Length() + KParameterSize;

				RBuf urlWithSize;

				urlWithSize.Create(size);

				urlWithSize.Copy(tempPreset->GetImgUrl());

				urlWithSize.Append(KLogoX);

				urlWithSize.AppendNum(aXValue);

				urlWithSize.Append(KLogoY);

				urlWithSize.AppendNum(aYValue);

				//set the imgUrl with parameters to the preset

				tempPreset->SetImgUrl(urlWithSize);

				urlWithSize.Close();				

				}

			}

		iCachePresetArray->AppendL(tempPreset);

 		iCacheObserverArray->AppendL(aLogoHandle);

 		if(aNPVReq == 2)

	 		{

	 		iCacheReqFromArray->AppendL(2);		

	 		}

 		else

	 		{

	 		iCacheReqFromArray->AppendL(1);		

	 		}

		}

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SendRequestL - Exiting" );

	}

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

// CIRLogoDownloadEngine::GetCacheLogoL(TDesC& aUrl,TInt& aStatus)

// takes the url as a parameter and returns the logo data which is in cache

// this API is called form the search results for to display logo on the view

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

//

EXPORT_C void CIRLogoDownloadEngine::GetCacheLogoL(const TDesC& aUrl,TInt& aStatus)

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::GetCacheLogoL - Entering" );

	iSendingLogo=2;

	iResult = 0;

	iForceGet = EFalse;

	//2 means, this API is called for the search results view

	iCacheReqMade = ETrue;

	iCache->CheckCacheL(KLogo,aUrl,iForceGet,iResult);		

	aStatus = iResult;

	IRLOG_DEBUG( "CIRLogoDownloadEngine::GetCacheLogoL - Exiting" );

	}

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

// CIRLogoDownloadEngine::SendCacheLogo()

// sends the logo which is cached

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

//

EXPORT_C TDesC8& CIRLogoDownloadEngine::SendCacheLogo()

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::SendCacheLogo" );

	return iCache->iLogoData;

	}

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

// CIRLogoDownloadEngine::FetchLogoDataL(CIRIsdsPreset* aPreset)

// API is used to download logo from isds/internet

// called in the API SendRequestL(CIRIsdsPreset* aPreset)

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

//

void CIRLogoDownloadEngine::FetchLogoDataL(CIRIsdsPreset* aPreset)

	{

	IRLOG_DEBUG( "CIRLogoDownloadEngine::FetchLogoDataL - Entering" );

 	if(!iRunning)

	 	{

	  	iTempReqFrom = 0;//which means the request came from SearchView while doing Add to Favorite

	 	if( iReqBody )

		 	{

		 	delete iReqBody;