/*

* 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 <bautils.h>

#include "irbrowsecatagoryitems.h"

#include "irbrowsechannelitems.h"

#include "ircachecleanup.h"

#include "ircachemgmt.h"

#include "ircacheobserver.h"

#include "irdebug.h"

#include "irhttprequestdata.h"

#include "irisdspreset.h"

#include "irotaupdate.h"

#include "irsettings.h"

//Default trust period value.24 hrs in secs with which the object is to be initialised

const TInt KDefaultInterval = 24*60*60;

//granualarity for the arrays

//the granualarity value is based on superficial observation of the amount of 

//data recieved for a particular request

const TInt KBrowseGranualarity = 32;

const TInt KChannelArrayGranualarity = 32;

const TInt KPresetGranualarity = 12;

//http length format length

// "Sun, 06 Nov 1994 08:49:37 GMT" format

const TInt KHttpDateLength = 25;

//Max size(critical size) in Bytes(90% of the max size)

//critical size is the size that triggers cleanup action

const TInt KCacheCriticalSizeLimit = KCacheLimitSize*9/10;

//No of rows deleted will be one fourth of the total number of rows

const TInt KPercentRowsDeleted = 4;  

//The indexing size for the column DataId is set to 100 

const TInt KDataIdIndexSize = 100;

//database file name

_LIT(KCacheDbFile,"cacheDb.db");

//Table Name CacheTable

_LIT(KCacheTable,"CacheTable");

//CacheTable columns

_LIT(KRowIndexCol,     "RowIndex");  

_LIT(KDataTypeCol,     "DataType");            

_LIT(KDataIdCol,       "DataId");       

_LIT(KTrustPeriodCol,  "TrustPeriod");       

_LIT(KLastModifiedCol, "LastModified"); 

_LIT(KLastAccessedCol, "LastAccessed"); 

_LIT(KTimeCreation,    "Created");

_LIT(KItemCount,       "ItemCount");

_LIT(KCachedDataCol,   "CachedData");

_LIT(KETagHeader,      "ETagHeader"); 

//Table Index Names

_LIT(KRowIndexColIndex,     "IndexRowIndex");  

_LIT(KDataTypeColIndex,     "IndexDataType");            

_LIT(KDataIdColIndex,       "IndexDataId");  

_LIT(KLastAccessedColIndex, "IndexLastAccessed"); 

_LIT(KTimeCreationIndex,    "IndexCreated");

//Field Lengths

const TInt KIRObserverArrayGranularity( 2 );

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

// Function : OpenL

// Standard two phased construction

// calls ConstructL()

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

//

EXPORT_C CIRCacheMgmt* CIRCacheMgmt::OpenL(MIRCacheObserver &aObserver)

	{

	IRLOG_DEBUG( "IRCacheMgmt::OpenL - Entering." );

	CIRCacheMgmt* self = reinterpret_cast<CIRCacheMgmt*>(Dll::Tls());

	if (self)

		{

		User::LeaveIfError(self->Open());

		}

    else

		{

		self = new (ELeave) CIRCacheMgmt(aObserver);

		CleanupClosePushL(*self);

		self->ConstructL();

		User::LeaveIfError(Dll::SetTls(self));

		CleanupStack::Pop(self);

		}

	IRLOG_DEBUG( "IRCacheMgmt::OpenL - Exiting." );

	return self;

	}

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

// Function : CIRCacheMgmt::~CIRCacheMgmt()

// Standard C++ destructor

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

//

CIRCacheMgmt::~CIRCacheMgmt() 

	{	

	IRLOG_DEBUG( "IRCacheMgmt::~CIRCacheMgmt - Entering." );

	//array destruction

	if (iPtrPreset)

		{

		iPtrPreset->ResetAndDestroy();

        delete iPtrPreset;

        iPtrPreset = NULL;

		}

    if (iPtrCategory)

        {

        iPtrCategory->ResetAndDestroy();

        }

    delete iPtrCategory;

    iPtrCategory = NULL;

    if (iPtrChannel)

        {

        iPtrChannel->ResetAndDestroy();

        }

    delete iPtrChannel;

    iPtrChannel = NULL;

    if (iSettings)

        {

        iSettings->Close();

        }

	if(iOTA)

		{

		delete iOTA;

		iOTA = NULL;

		}

	iLogoData.Close();		

    CloseDb();

    iCacheDb.Close();

    delete iCleanup;

    iFsSession.Close();

    iCacheObservers.Close();

    Dll::FreeTls();

    IRLOG_DEBUG( "IRCacheMgmt::~CIRCacheMgmt - Exiting." );

	}

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

// Function : CIRCacheMgmt::CIRCacheMgmt()

// Standard C++ constructor

// sets the trust period to 24hrs(default)

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

//

CIRCacheMgmt::CIRCacheMgmt (MIRCacheObserver &aObserver)

			:iCacheObserver(aObserver),

			 iCacheObservers( KIRObserverArrayGranularity )

	{

	IRLOG_DEBUG( "IRCacheMgmt::CIRCacheMgmt - Entering." );

	//default trust period initially set to 24 hrs

	//to be fetched from central repository

	iTrustPeriod = TTimeIntervalSeconds(KDefaultInterval);	

	IRLOG_DEBUG( "IRCacheMgmt::CIRCacheMgmt - Exiting." );

	}

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

// Function : CIRCacheMgmt::ConstructL()

// Standard two phased construction

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

//

void CIRCacheMgmt::ConstructL() 

	{

	IRLOG_DEBUG( "IRCacheMgmt::ConstructL - Entering." );

	User::LeaveIfError(iFsSession.Connect());

	//array construction

	iPtrPreset = new (ELeave) CArrayPtrFlat<CIRIsdsPreset>(

				KPresetGranualarity);

    iPtrCategory = new (ELeave) CArrayPtrFlat<CIRBrowseCatagoryItems>(

    	KBrowseGranualarity);

	iPtrChannel = new (ELeave) CArrayPtrFlat<CIRBrowseChannelItems>(

		KChannelArrayGranualarity);

	iOTA = CIROTAUpdate::NewL();

	iSettings = CIRSettings::OpenL();

	iDatabaseFileName = iSettings->PrivatePath();

	iDatabaseFileName.Append(KCacheDbFile);

	CreateDbConditionalL();

	iCleanup = CIRCacheCleanup::NewL(*this);

	RemoveOtaInfoL();

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

    }

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

// Function : CIRCacheMgmt::CreateDbConditionalL(

// Creates dbms conditionally(only if not yet created)

// calls CreateDb()

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

//

void CIRCacheMgmt::CreateDbConditionalL()

	{

	IRLOG_DEBUG( "IRCacheMgmt::CreateDbConditionalL - Entering." );

	TInt err=KErrNone;

	if(!BaflUtils::FileExists(iFsSession, iDatabaseFileName))

		{

		err=CreateDb();

		if(KErrNone != err)

			{

			User::Leave(err);	

			}

		}

	IRLOG_DEBUG( "IRCacheMgmt::CreateDbConditionalL - Exiting." );

	}

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

// Function : CIRCacheMgmt::CreateDb()

// Creates the tables

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

//

TInt CIRCacheMgmt::CreateDb()

	{

	IRLOG_DEBUG( "IRCacheMgmt::CreateDb - Entering." );

	CloseDb();

	TInt err=iCacheDb.Replace(iFsSession,iDatabaseFileName);

	if((err!=0))

		{

		return err; //unable to create file	

		}																		

	TRAP(err,//trap start

		CreateCacheTableL();

		CreateCacheIndexL();

		)//trap end

		IRLOG_DEBUG( "IRCacheMgmt::CreateDb - Exiting." );

	return err;

	}

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

// Function : CIRCacheMgmt::OpenCacheDb()

// Opens both the databases 

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

//

TInt CIRCacheMgmt::OpenCacheDb()

	{

	IRLOG_DEBUG( "CIRCacheMgmt::OpenCacheDb - Entering" );

	CloseDb();

	TInt error = KErrNone;

	if(!BaflUtils::FileExists(iFsSession, iDatabaseFileName))

	    {

	    //if file doesn't exist function leaves with error code

	    //KErrNotFound

	     return KErrNotFound;

	    }

	//try and open the db	

	error = iCacheDb.Open(iFsSession,iDatabaseFileName);

	//return if error

	if(KErrNone != error )

		{

		return error;

		}

	//check if damaged

	if( iCacheDb.IsDamaged() )

		{

		//if data base is damaged then 

		//try to recover

		error = iCacheDb.Recover();

		return error;

		}

	iOpen = ETrue;

	IRLOG_DEBUG( "CIRCacheMgmt::OpenCacheDb - Exiting." );

	return KErrNone;

	}

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

// Function : CIRCacheMgmt::CloseDb()

// Closes the database 

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

//

void CIRCacheMgmt::CloseDb()

	{

	IRLOG_DEBUG( "IRCacheMgmt::CloseDb - Entering." );

	iCacheDb.Close();

	iOpen = EFalse;

	IRLOG_DEBUG( "IRCacheMgmt::CloseDb - Exiting." );

	}

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

// Function : CIRCacheMgmt::CheckCache()

// API Exposed to Isds Client to check and get the cached items. 

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

//

EXPORT_C void CIRCacheMgmt::CheckCacheL(TInt aType,const TDesC& aName,

					TBool aForceGet,TInt& aReturn)   

	{

	IRLOG_DEBUG( "CIRCacheMgmt::CheckCacheL - Entering" );

	//opens the db if not open already

	if(!iOpen)

		{

		TInt error = OpenCacheDb();

		if(KErrNone != error)

			{

			aReturn = ENotCached;

			return;	

			}

		}

    //calls the function FetchCacheIfAvailable() passing the appropriate type and id

	switch(aType)

	{

	case ECatagory:	

	case EChannels:

	case EPresets:

	case EOtaInfo:

	case ELogo:

		{

		TRAP_IGNORE(FetchCacheIfAvailableL(aType,aName,aForceGet,aReturn))

		break;	

		}

	default:

		{

	    for (TInt i = 0 ; i < iCacheObservers.Count() ; i++ )

	        {

	        iCacheObservers[i]->CacheFailed();

	        }

		aReturn = ENotCached;

		break;	

		}

	}

	CloseDb();

	IRLOG_DEBUG( "CIRCacheMgmt::CheckCacheL - Exiting." );

	}

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

// Function : CIRCacheMgmt::FetchCacheIfAvailable()

// Fetches the cache if available 

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

//

//generic function to check the validity of the cache	

void CIRCacheMgmt::FetchCacheIfAvailableL(TInt aType,const TDesC& aId,

	TBool aForceGet,TInt& aReturnVal)

	{

	//Algo****

	//1.check the cache table for a request type

	//2.if the query returns a row,check for validity

	//3.if invalid(stale) do a conditional get

	//4.if valid use cache

	IRLOG_DEBUG( "CIRCacheMgmt::FetchCacheIfAvailableL - Entering" );

	//SELECT * FROM KCacheTable WHERE KDataTypeCol = aType AND KDataIdCol=aId

	_LIT( query, "SELECT * FROM %S WHERE %S = %d AND %S = '%S'" );

	HBufC* sqlQuery = HBufC::NewLC(query().Length() + KCacheTable().Length() +

								    KDataTypeCol().Length() + KDataIdCol().Length() +

								    KDefaultRealWidth + aId.Length());

	sqlQuery->Des().Format(query,&KCacheTable,&KDataTypeCol,aType,&KDataIdCol,&aId);

	IRLOG_DEBUG2( "CIRCacheMgmt::FetchCacheIfAvailableL - Going to evaluate SQL query: %S", sqlQuery );

	RDbView cacheView;

	User::LeaveIfError(cacheView.Prepare(iCacheDb,*sqlQuery));

	CleanupStack::PopAndDestroy(sqlQuery);

	CleanupClosePushL(cacheView);

    User::LeaveIfError( cacheView.EvaluateAll() );

    //if no row match the query there is no cahche available for that particular 

    //request

    if(cacheView.IsEmptyL())

	    {

	    //Return ENotCached

	    aReturnVal = ENotCached;

	    }

	else

		{

		cacheView.FirstL();

		cacheView.GetL();

		CDbColSet* columns = cacheView.ColSetL();

		TTime creationTime = cacheView.ColTime(columns->ColNo( KTimeCreation));

		TInt cacheValidityTime = cacheView.ColInt(columns->ColNo( KTrustPeriodCol));

		TInt countItems=cacheView.ColInt(columns->ColNo( KItemCount));

		IRLOG_DEBUG( "CIRCacheMgmt::FetchCacheIfAvailableL - can check validity." );

		//check if cache is valid

		//get it any way if it is "forcedget"

		if( aForceGet || CheckValidity(creationTime,cacheValidityTime))

			{

			//Fetch the cached data

			//FetchCachedData(type,count,&view )

			TRAPD(err,FetchCachedDataL(aType,countItems,cacheView));

			if(err!=KErrNone)

				{

				//something goes wrong ,return not cached and fetch new data

				aReturnVal = ENotCached;

				}

			else

				{

				//cache usable

				aReturnVal = ECacheUseable;

				}

			}

		else

			{

			iLastModified = cacheView.ColTime(columns->ColNo( KLastModifiedCol));

			iETag = cacheView.ColDes8(columns->ColNo( KETagHeader ));			

			aReturnVal = ECacheNotValid;

			cacheView.Close();

		    for (TInt i = 0 ; i < iCacheObservers.Count() ; i++ )

		        {

		        iCacheObservers[i]->CacheInvalid();

		        }

			}

	    delete columns;	

		}

	CleanupStack::PopAndDestroy(&cacheView);

	IRLOG_DEBUG( "CIRCacheMgmt::FetchCacheIfAvailableL - Exiting." );

	}

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

// Function : CIRCacheMgmt::FetchCachedDataL()

// fetches the cached data from the table into the cached structures

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

//

void CIRCacheMgmt::FetchCachedDataL(TInt aType,TInt aCountItems,RDbView& aCacheView)

	{

	//Algo****

	//fetch the data and internalize into appropriate structure

	IRLOG_DEBUG( "CIRCacheMgmt::FetchCachedDataL - Entering" );

    CDbColSet* columns = aCacheView.ColSetL();

    TInt columnNo = columns->ColNo( KCachedDataCol );

    delete columns;

	switch(aType)

		{

		case ECatagory:

			{

			//Internalize the category items into the CIRBrowseCatagoryItems array

	        RDbColReadStream instream;

	        instream.OpenLC( aCacheView, columnNo );

			CIRBrowseCatagoryItems* ptr;

			if (iPtrCategory)

				{

				iPtrCategory->ResetAndDestroy();

				}

			for(TInt iter=0;iter<aCountItems;iter++)

				{

				ptr=CIRBrowseCatagoryItems::NewL();

				CleanupStack::PushL(ptr);

				instream>>*ptr;

			    if (iPtrCategory)

				    {				

				    iPtrCategory->AppendL(ptr);

				    }

				CleanupStack::Pop(ptr);

				}

	        CleanupStack::PopAndDestroy( &instream );

	        //update the last accessed time

	        UpdateLastAccessedTimeL(aCacheView);

	        aCacheView.Close();

		    for (TInt i = 0 ; i < iCacheObservers.Count() ; i++ )

		        {

		        iCacheObservers[i]->CachedStructureL(ECatagory);

		        }

	        break;

			}

		case EChannels:

			{

			//Internalize the channel items into the CIRBrowseChannelItems array

	        RDbColReadStream instream;

	        instream.OpenLC( aCacheView, columnNo );

	        if (iPtrChannel)

				{

				iPtrChannel->ResetAndDestroy();

				}

			CIRBrowseChannelItems *ptr;

			for(TInt iter=0;iter<aCountItems;iter++)

				{

				ptr = CIRBrowseChannelItems::NewL();

				CleanupStack::PushL(ptr);

				instream>>*ptr;

	            if (iPtrChannel)

				    {				

        		    iPtrChannel->AppendL(ptr);

	        		}

				CleanupStack::Pop(ptr);

				}

	        CleanupStack::PopAndDestroy( &instream );

	        //update the last accessed time

	        UpdateLastAccessedTimeL(aCacheView);

	        aCacheView.Close();

		    for (TInt i = 0 ; i < iCacheObservers.Count() ; i++ )

		        {

		        iCacheObservers[i]->CachedStructureL(EChannels);

		        }

	        break;

			}

		case EPresets:

			{

			//Internalize the preset  into the CIRIsdsPreset object

	        RDbColReadStream instream;

	        instream.OpenLC( aCacheView, columnNo );

	        if(iPtrPreset)

		        {

		        iPtrPreset->ResetAndDestroy();

		        }

		    CIRIsdsPreset *ptr;

		    for(TInt iter=0;iter<aCountItems;iter++)

		    	{

		    	ptr = CIRIsdsPreset::NewL();

		    	CleanupStack::PushL(ptr);

		    	instream>>*ptr;

	            if(iPtrPreset)

		            {		    	

		    	    iPtrPreset->AppendL(ptr);

		            }

		    	CleanupStack::Pop(ptr);

		        }

	        CleanupStack::PopAndDestroy( &instream );

	        //update the last accessed time

	        UpdateLastAccessedTimeL(aCacheView);