/*

* 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();

                }

            else

                {

                break;

                }

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

                {

                ptr=CIRBrowseCatagoryItems::NewL();

                CleanupStack::PushL( ptr );

                instream>>*ptr;

                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 )

                {