/*

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

*

*/

#include <escapeutils.h>

#include <tinternetdate.h>

#include <utf.h>

#include "irbrowsecatagoryitems.h"

#include "irbrowsechannelitems.h"

#include "ircachemgmt.h"

#include "irdataprovider.h"

#include "irdataproviderconstants.h"

#include "irdebug.h"

#include "irhttprequestdata.h"

#include "irotaupdate.h"

#include "irsessionlogger.h"

#include "irsettings.h"

#include "irxmlcontenthandler.h"

#include "isdsclientdll.h"

#include "misdsresponseobserver.h"

#include "irisdspreset.h"

const TInt KChannelidMaxLength = 25;

const TInt KTwo = 2;

/*const TInt KDays = 7;

const TInt KHour = 24;

const TInt KMinute = 60;

const TInt KSecond = 60;*/

const TInt KUrlPassMaxLength = 124;

const TInt KChidMaxLength = 6;

const TInt KCopyOfTimeMaxLength = 32;

const TInt KMaxLength = 256;

const TInt KFour = 4;

_LIT(KBrowseUrl,"/do/directory/browse?type=");

_LIT(KChannelnSearchUrl,"/do/directory/browse?type=channels&searchText=");

_LIT(KGetIRIDUrl,"/do/service/getIrid");

_LIT(KGenres,"genres");

_LIT(KLanguages,"languages");

_LIT(KCountries,"countries");

_LIT(KHotpicks,"hotpicks");

_LIT(KOtaUpdateUrl,"/do/service/otaUpdate?irid=");

_LIT(KLogUsageUrl,"/do/service/logUsage");

_LIT(KSearchUrl,"&start=1&size=50");

_LIT(KMultiSearchUrl, "/do/directory/browse?type=channels&genreID=%S&countryID=%S&languageID=%S&searchText=");

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

// CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver)

// Used by UI to create instance of CIRIsdsClient.

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

//

EXPORT_C CIRIsdsClient* CIRIsdsClient::NewL(MIsdsResponseObserver& aobserver,

	const TDesC& aISDSBaseUrl)

    {

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

	CIRIsdsClient* self = CIRIsdsClient::NewLC(aobserver,aISDSBaseUrl);

	CleanupStack::Pop( self );

	IRLOG_DEBUG( "CIRIsdsClient::NewL - Exiting." );

	return self;

    }

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

// CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver)

// Creates instance of CIRIsdsClient.

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

//

CIRIsdsClient* CIRIsdsClient::NewLC(MIsdsResponseObserver& aobserver,

									const TDesC& aISDSBaseUrl)

    {

    IRLOG_DEBUG( "CIRIsdsClient::NewLC - Entering" );

    CIRIsdsClient* self = new ( ELeave ) CIRIsdsClient(aobserver);

    CleanupStack::PushL( self );

    self->ConstructL(aISDSBaseUrl);

    IRLOG_DEBUG( "CIRIsdsClient::NewLC - Exiting." );

    return self;

    }

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

// CIRIsdsClient::ConstructL()	

// Symbian two phased constructor

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

//	

void CIRIsdsClient::ConstructL(const TDesC& aISDSBaseUrl)

	{

	//!	Construsting the DataproviderDLL instance

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

	iSettings=CIRSettings::OpenL();	

	iISDSBaseUrl=aISDSBaseUrl.AllocL();

//Base URL required to browse through the category

	iCatgoryURL.Zero();

	iCatgoryURL.Copy(*iISDSBaseUrl);

	iCatgoryURL.Append(KBrowseUrl);

	//Base URL required to search isds 

	iSearchURL.Zero();

	iSearchURL.Copy(*iISDSBaseUrl);

	iSearchURL.Append(KChannelnSearchUrl);	

	//Base URL required to get IRID

	iGetIridUrl.Zero();

	iGetIridUrl.Copy(*iISDSBaseUrl);

	iGetIridUrl.Append(KGetIRIDUrl);

	//creates DataProvider

	iDataProvider=CIRDataProvider::NewL(*this);

	//creates XML Parser

	iXmlReader=CIRXMLContentHandler::NewL(*this,*this);

	//creates Cache manager

	iCache=CIRCacheMgmt::OpenL(*this);

	iCache->AddObserverL(this);

	//Session Log

    iBrowseReport = CIRReportGenerator::OpenL();

        // Retrive the current language and set it as an Accept Language

	TLanguage currentLanguage = User::Language();

	iShortLanguageCode = IRLanguageMapper::MapLanguage(currentLanguage);

	IRLOG_DEBUG( "IRIsdsClient::ConstructL - Exiting." );

    }

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

// CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver)	

// Default constructor

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

//	

CIRIsdsClient::CIRIsdsClient(MIsdsResponseObserver& aobserver):

	iIsdsResponseObserver(aobserver)

	{

	IRLOG_DEBUG( "CIRIsdsClient::CIRIsdsClient" );

	//No implementation

	}	

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

// CIRIsdsClient::~CIRIsdsClient()

// Destructor

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

//	

CIRIsdsClient::~CIRIsdsClient()

	{

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

	delete iDataProvider;

	delete 	iXmlReader;

	if(iSendPreset)

		{

		iSendPreset->ResetAndDestroy();

		}

	delete iSendPreset;

    if (iCache)

        {

        iCache->RemoveObserver(this);

        iCache->Close();

        }

	if(iSettings)

		{

		iSettings->Close();

		}

	delete iISDSBaseUrl;

	if(iBrowseReport)

        {

		iBrowseReport->Close();

		}

	if(iTempRequestObject)

		{

		delete iTempRequestObject;

		iTempRequestObject = NULL;			

		}

	IRLOG_DEBUG( "CIRIsdsClient::~CIRIsdsClient - Exiting." );

	}

EXPORT_C TBool CIRIsdsClient::IRIsdsIsCategoryCachedL(

             TIRIsdsclientInterfaceIDs aISDSClientRequest)

{ 

    iForceGet=EFalse;  

    TInt res = 0;

    iCacheReqMade = EFalse;

    switch(aISDSClientRequest)

        {

            //When genre data is requested by user

        case EGenre:

            {

            //set the request type for subsiquent Use           

            iCachePath.Zero();

            iCachePath.Copy(KGenres);            

            iCache->CheckCacheL(0,KGenres,iForceGet,res);       

            }

        break;

        //When Language data is requested by user                       

        case ELanguages:

            {

            iCachePath.Zero();

            iCachePath.Copy(KLanguages);            

            iCache->CheckCacheL(0,KLanguages,iForceGet,res);          

            }

        break;

        //When Country data is requested by user                                                    

        case  ECountries:

            {

            iCachePath.Zero();

            iCachePath.Copy(KCountries);          

            iCache->CheckCacheL(0,KCountries,iForceGet,res);          

            }

        break;

            //When hotpics data is requested by user                                                        

        case  Ehotpicks:

            {

            //set the request type for subsiquent Use            

            iCachePath.Zero();

            iCachePath.Copy(KHotpicks);

            iCache->CheckCacheL(1,KHotpicks,iForceGet,res);

            }

        break;   

		default:

		break;    

    }

    if (res == CIRCacheMgmt::ECacheUseable)

    {

        return ETrue;

    }

    return EFalse; 

}

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

// void CIRIsdsClientInteface(TIRIsdsclientInterfaceIDs aISDSClientRequest)

// Called by UI to make request to ISDS for catogories

// @param :ENUM value depending on catogory which user wants to explore

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

//

EXPORT_C TBool CIRIsdsClient::IRIsdsClientIntefaceL(TIRIsdsclientInterfaceIDs 

	aISDSClientRequest)

	{  

	//cancels any pending request

	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Entering" );

	CIRHttpRequestData * requestData= new(ELeave) CIRHttpRequestData;

	CleanupStack::PushL(requestData);

	requestData->iAcceptLanguage.Copy( iShortLanguageCode );

	//Sets the Htpp method to GET

	requestData->iMethod = EIRHttpGET;

	//check for valid cache

	iForceGet=EFalse;  

	TInt res=0;

	switch(aISDSClientRequest)

		{

            //When genre data is requested by user

		case EGenre:

			{

			//set the request type for subsiquent Use

			iRequestType=0;

			iDataFrom=EFalse;

			iCachePath.Zero();

			iCachePath.Copy(KGenres);

			iCacheReqMade = ETrue;

			iCache->CheckCacheL(0,KGenres,iForceGet,res);

			if(res==0)//if cache is not available

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KGenres);

				iConditonalGet=EFalse;

				//issues request for Genre data

				IRHttpIssueRequestL(*requestData);

				iBrowseUrl.Zero();		

				iBrowseUrl.Copy(requestData->iUri);

				iBrowseReport->BrowseUrl(iBrowseUrl,0);    

				iDataFrom=ETrue;				

				}

			if(res ==-1)//i cache is stale

				{

				iConditonalGet=ETrue;

				requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

				requestData->isIfModifiedSet = ETrue;

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KGenres);

				IRHttpIssueRequestL(*requestData);

				iBrowseUrl.Zero();		

		        iBrowseUrl.Copy(requestData->iUri);

		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    

				iDataFrom=ETrue;	

				}

			if (res == 1)

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KGenres);

				iBrowseUrl.Zero();		

		        iBrowseUrl.Copy(requestData->iUri);

		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

				}

			}

		break;

        //When Language data is requested by user			 			

		case ELanguages:

			{

	        //set the request type for subsiquent Use

	        iRequestType=0;

			iDataFrom=EFalse;

			iCachePath.Zero();

			iCachePath.Copy(KLanguages);

    		iCacheReqMade = ETrue;

    		iCache->CheckCacheL(0,KLanguages,iForceGet,res);

			if(res==0)//if cache is not available

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KLanguages);

				//Isuues request for language data

				IRHttpIssueRequestL(*requestData);

				iConditonalGet=EFalse;	

				iBrowseUrl.Zero();

				iBrowseUrl.Copy(requestData->iUri);	

				iBrowseReport->BrowseUrl(iBrowseUrl,0);

				iDataFrom=ETrue;					

				}			

			if(res ==-1)//i cache is stale

				{

				iConditonalGet=ETrue;

				requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

				requestData->isIfModifiedSet=ETrue;

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KLanguages);

				//Isuues request for language data if cache isnt valid

				IRHttpIssueRequestL(*requestData);	

				iBrowseUrl.Zero();

				iBrowseUrl.Copy(requestData->iUri);	

				iBrowseReport->BrowseUrl(iBrowseUrl,0);

				iDataFrom=ETrue;					

				}

			if (res == 1)

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KLanguages);

				iBrowseUrl.Zero();		

		        iBrowseUrl.Copy(requestData->iUri);

		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

				}			

			}

		break;

        //When Country data is requested by user			 						      			

    	case  ECountries:

			{

			//set the request type for subsiquent Use

			iRequestType=0;

			iDataFrom=EFalse;

			iCachePath.Zero();

			iCachePath.Copy(KCountries);

			iCacheReqMade = ETrue;

			iCache->CheckCacheL(0,KCountries,iForceGet,res);

			if(res==0)//if cache is not available

                {

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KCountries);	

				//Isuues request for country data			

				IRHttpIssueRequestL(*requestData);	

				iConditonalGet=EFalse;

				iBrowseUrl.Zero();

				iBrowseUrl.Copy(requestData->iUri);

				iBrowseReport->BrowseUrl(iBrowseUrl,0);

				iDataFrom=ETrue;					

				}

			if(res ==-1)//i cache is stale

				{

				iConditonalGet=ETrue;

			    requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

				requestData->isIfModifiedSet = ETrue;

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KCountries);

				//Isuues request for country data if cache isnt valid

				IRHttpIssueRequestL(*requestData);

				iBrowseUrl.Zero();		

			    iBrowseUrl.Copy(requestData->iUri);

				iBrowseReport->BrowseUrl(iBrowseUrl,0);

				iDataFrom=ETrue;					

				}

			if (res == 1)

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KCountries);

				iBrowseUrl.Zero();		

		        iBrowseUrl.Copy(requestData->iUri);

		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

				}

			}

		break;

    		//When hotpics data is requested by user			 						      				

    	case  Ehotpicks:

			{

			//set the request type for subsiquent Use

			iRequestType=1;

			iCacheReqMade = ETrue;

			iCache->CheckCacheL(1,KHotpicks,iForceGet,res);

			iCachePath.Zero();

			iCachePath.Copy(KHotpicks);

			iDataFrom=EFalse;

			if(res==0)//if cache is not available

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KHotpicks);

				//Isuues request for hotpics data

				IRHttpIssueRequestL(*requestData);

				iConditonalGet=EFalse;

				iBrowseUrl.Zero();

			    iBrowseUrl.Copy(requestData->iUri);

			        iBrowseReport->BrowseUrl(iBrowseUrl,0);     

				iDataFrom=ETrue;					

				}	

			if(res ==-1)//i cache is stale

			 	{

				 iConditonalGet=ETrue;

				 requestData->iIfModifiedSince = iLastModifiedTime.DateTime();

				 requestData->isIfModifiedSet=ETrue;

				 requestData->iUri.Copy(iCatgoryURL);

				 requestData->iUri.Append(KHotpicks);

				 //Isuues request for hotpics data if cache isnt valid

				 IRHttpIssueRequestL(*requestData);

				 iBrowseUrl.Zero();		

		         iBrowseUrl.Copy(requestData->iUri);

				 iBrowseReport->BrowseUrl(iBrowseUrl,0);     

				 iDataFrom=ETrue;					

				 }	

			if (res == 1)

				{

				requestData->iUri.Copy(iCatgoryURL);

				requestData->iUri.Append(KHotpicks);

				iBrowseUrl.Zero();		

		        iBrowseUrl.Copy(requestData->iUri);

		        iBrowseReport->BrowseUrl(iBrowseUrl,0);    						

				}

			}

		break;

	    }

	CleanupStack::PopAndDestroy(requestData); 

	IRLOG_DEBUG( "CIRIsdsClient::IRIsdsClientIntefaceL - Exiting." );

	return iDataFrom;		

	}//end of function	

EXPORT_C CIRDataProvider* CIRIsdsClient::GetDataProvider()

{

	IRLOG_DEBUG( "CIRIsdsClient::GetDataProvider" );

	return iDataProvider;

}

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

// void IRHttpContentNotChanged()	

// this is call back funtion called by Dataprovider in case 

// HTTP content isnt changed by ISDS 

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

//	

void CIRIsdsClient::IRHttpResponseCodeReceived( TInt aResponseCode,

	CIRHttpResponseData& aResponseHeaders )

	{

	IRLOG_INFO2( "CIRIsdsClient::IRHttpResponseCodeReceived (%d)", aResponseCode );

	TInt res = KErrNotFound;

	switch (aResponseCode)

		{

		case KNotFound://404

			{

			//make channel user defined.

			if(iSyncRequest)

				{

				iSyncRequest = EFalse;

				//make the preset user-defined

				TRAP_IGNORE(iIsdsResponseObserver.IsdsPresetRemovedL(

													iPresetToBeSynced))	

				}

			/*if(iOtaReqFrom)

				{

				TRAP_IGNORE(PurgeOtaInfoL())

				}*/

			}

			break;

		case KNotModified://304

			{

			if(iConditonalGet)

				{

				//update the trust period 

				//no problem if it leaves

				TRAP_IGNORE(iCache->UpdateTrustPeriodL(iRequestType,iCachePath,

				aResponseHeaders))

				//do a forced get because the data is notmodifed in isds and 

				//trustable

				iForceGet=ETrue;

				iCacheReqMade = ETrue;

				TRAP_IGNORE(iCache->CheckCacheL(iRequestType,iCachePath,

					iForceGet,res))