/*

* Copyright (c) 2002-2007 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:    Offers interface to Epg database*

*/

#include <badesca.h>    // CDesCArrayFlat

#include <s32file.h>    // CFileStore & CPermanentFileStore

#include <bautils.h>    // file helpers

#include <eikenv.h>

#include <sysutil.h>    // SysUtil

#include <centralrepository.h>

#include "IptvLiveDataStructures.h" // CleanupResetAndDestroyPushL

#include "CIptvMediaContent.h"

#include "CIptvEpgCategory.h"

#include "CIptvEpgContent.h"

#include "CIptvUtil.h"

#include "IptvDebug.h"

#include "CIptvServer.h"

#include "CIptvService.h"

#include "CIptvEpgSession.h"

#include "CIptvVodContentCategoryBriefDetails.h"

#include "CIptvVodContentContentBriefDetails.h"

#include "CIptvVodContentContentFullDetails.h"

#include "CIptvMyVideosGlobalFileId.h"

#include "CIptvEpgDb.h"

#include "IptvServer.pan"

#include "CIptvServiceManager.h"

_LIT( KSqlAll, "*" );

_LIT( KHyp, "'" );

_LIT( KSqlSelect, "SELECT " );

_LIT( KSqlDot, ", " );

_LIT( KSqlFrom, " FROM " );

_LIT( KSqlWhere, " WHERE " );

_LIT( KSqlIs, " = " );

_LIT( KSqlAnd, " AND " );

_LIT( KSqlNot, " <> " );

_LIT( KSqlOr, " OR " );

_LIT( KSqlOrderBy, " ORDER BY " );

_LIT( KIptvTmp, ".tmp" );

_LIT( KEmptyString, "" );

const TInt KIptvDbVersion( 9 );

const TUint32 KIptvRootParent( 0xFFFFFFF );

const TInt KMaxCountOfFullDetails( 1 );

const TInt KMaxCountOfParentCategories( 1 );

const TInt KIptvFileId( 0 );

const TInt KIptvDrive( 0 );

const TInt KValueNotSet( -1 );

const TInt KIptvEpgManagerFreeSpace = 512000; // 500 KB

const TInt KParentalControlOff( 0 );

const TIptvContentId KIptvInvalidContentId(

    static_cast<TIptvContentId>( KErrNotFound ) );

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

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

// CIptvEpgDb::CIptvEpgDb

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIptvEpgDb::CIptvEpgDb(

    const TUint32& aServiceId,

    CIptvServer& aServer ) :

    iTmpDbOpen( EFalse ),

    iServiceId( aServiceId ),

    iServer( aServer ),

    iParentalControl( KParentalControlOff )

    {

    }

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

// CIptvEpgDb::ConstructL

// Second phase construction. Leaves, if RFs session cannot be created.

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

//

void CIptvEpgDb::ConstructL( const TFileName& aEpgFile )

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::ConstructL" );

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

    iEpgFile = aEpgFile;

    MakeSqlStrings();

    TBool created = EFalse;

    CreateDbL( iEpgFile, created );

    OpenDatabaseL( iEpgDb, iEpgFile );

    // If new database created -> Set service information

    if ( created )

        {

        TTime a( TInt64( 0 ) );

        SetServiceInformationL( iEpgDb, a, a );

        CreateRootCategoryL( iEpgDb );

        created = EFalse;

        }

    // Read versio information from database

    iEpgDb.Compact();

    TInt version = 0;

    version = GetVersionL();

    if ( version != KIptvDbVersion )

        {

        iEpgDb.Close();

        // Delete old database.

        CFileMan* fileMan = CFileMan::NewL( iFsSession );

        CleanupStack::PushL( fileMan );

        fileMan->Delete( iEpgFile );

        CleanupStack::PopAndDestroy( fileMan );

        // Create new database with current version of database tables.

        CreateDbL( iEpgFile, created );

        OpenDatabaseL( iEpgDb, iEpgFile );

        // If new database created -> Set service information

        if ( created )

            {

            TTime a( TInt64( 0 ) );

            SetServiceInformationL( iEpgDb, a, a );

            CreateRootCategoryL( iEpgDb );

            }

        }

    TRAPD( ret, iCenRepSession = CRepository::NewL( KIptvCenRepUid ) );

    if ( ret == KErrNone && iCenRepSession )

        {

        // Register CenRep change notifier.

        iCenRepNotifyHandler = CCenRepNotifyHandler::NewL(

            *this,

            *iCenRepSession,

            CCenRepNotifyHandler::EIntKey,

            KIptvCenRepParentControlKey );

        iCenRepNotifyHandler->StartListeningL();

        // Read settings from CenRep.

        ReadCenRepData();

        }

    }

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

// CIptvEpgDb::GetVersionL()

//

// Get database version

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

//

TInt CIptvEpgDb::GetVersionL()

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::GetVersionL" );

    TInt version = 0;

    HBufC* sql = HBufC::NewLC( KCustomSqlMaxLength );

    TPtr16 sqlPtr = sql->Des();

    sqlPtr.Append( KSqlSelect );

    sqlPtr.Append( KSqlAll );

    sqlPtr.Append( KSqlFrom );

    sqlPtr.Append( KIptvEpgServiceTable );

    RDbView view;

    TBool found = EFalse;

    TInt error = view.Prepare(

        iEpgDb, TDbQuery( sqlPtr ), TDbWindow::EUnlimited );

    CleanupStack::PopAndDestroy( sql );

    if ( error == KErrNone )

        {

        TInt count = view.ColCount();

        if ( count > 0 )

            {

            for ( TInt i = 1; i <= count; i++ )

                {

                TDbCol col = view.ColDef( i );

                if ( col.iName.Compare( KIptvEpgServiceVersion ) == 0 )

                    {

                    found = ETrue;

                    }

                }

            }

        }

    if ( found )

        {

        view.EvaluateAll();

        view.FirstL();

        CDbColSet* colSet = view.ColSetL();

        CleanupStack::PushL( colSet );

        TInt versionCol = colSet->ColNo( KIptvEpgServiceVersion );

        CleanupStack::PopAndDestroy( colSet );

        TRAPD( getError, view.GetL() );

        if ( getError != KErrNone )

            {

            view.Close();

            }

        version = view.ColUint32( versionCol );

        }

    view.Close();

    return version;

    }

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

// CIptvEpgDb::OpenDatabaseL()

//

// Open database

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

//

void CIptvEpgDb::OpenDatabaseL( RDbNamedDatabase& aDb, const TDesC& aFile )

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::OpenDatabaseL" );

    TInt error = aDb.Open( iFsSession, aFile );

    if ( error != KErrNone )

        {

        if ( error != KErrNoMemory &&

             error != KErrLocked &&

             error != KErrDisMounted &&

             error != KErrDiskFull &&

             error != KErrNotReady )

            {

            // Delete the database file. Cannot recover.

            CFileMan* fileMan = CFileMan::NewL( iFsSession );

            CleanupStack::PushL( fileMan );

            fileMan->Delete( aFile );

            CleanupStack::PopAndDestroy( fileMan );

            User::Leave( error );

            }

        else

            {

            User::Leave( error );

            }

        }

    }

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

// CIptvEpgDb::NewL

// Two-phased constructor.

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

//

CIptvEpgDb* CIptvEpgDb::NewL(

    const TFileName& aEpgFile,

    const TUint32& aServiceId,

    CIptvServer& aServer )

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::NewL" );

    CIptvEpgDb* self = new ( ELeave ) CIptvEpgDb( aServiceId, aServer );

    CleanupStack::PushL( self );

    self->ConstructL( aEpgFile );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIptvEpgDb::~CIptvEpgDb()

// Destructor

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

//

CIptvEpgDb::~CIptvEpgDb()

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::~CIptvEpgDb" );

    iEpgDb.Close();

    if ( iDeleteDatabaseFiles )

        {

        TRAP_IGNORE( DeleteDatabaseL() )

        }

    if ( iTmpDbOpen )

        {

        iTmpDb.Close();

        }

    iFsSession.Close();

    if ( iCenRepNotifyHandler )

        {

        iCenRepNotifyHandler->StopListening();

        delete iCenRepNotifyHandler;

        }

    delete iCenRepSession;

    }

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

// CIptvEpgDb::CreateDbL()

//

// Create a new database.

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

//

void CIptvEpgDb::CreateDbL( const TDesC& aFile, TBool& aCreated )

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateDbL" );

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

        {

        // Before creating any new databases, check that there is enough disk space.

        TBool checkResult = EFalse;

        TRAPD(

            checkError, checkResult = SysUtil::DiskSpaceBelowCriticalLevelL(

                &iFsSession, KIptvEpgManagerFreeSpace, EDriveC ) );

        if ( checkError != KErrNone || checkResult )

            {

            // Not enough space on disk, return immediately and do not create databases.

            User::Leave( KErrDiskFull );

            }

        TRAPD( error,

            {

            RDbNamedDatabase database;

            User::LeaveIfError( database.Create( iFsSession, aFile ) );

            CleanupClosePushL( database );

            CreateCategoryTableL( database );

            CreateCategoryIndexL( database );

            CreateContentTableL( database );

            CreateContentIndexL( database );

            CreateCategoryContentTableL( database );

            CreateCategoryContentIndexL( database );

            CreateServiceTableL( database );

            CreateContentAccessTableL( database );

            CleanupStack::PopAndDestroy(); // database

            aCreated = ETrue;

            } );

        if ( error != KErrNone )

            {

            // Delete the database file. Cannot recover.

            CFileMan* fileMan = CFileMan::NewL( iFsSession );

            CleanupStack::PushL( fileMan );

            fileMan->Delete( aFile );

            CleanupStack::PopAndDestroy( fileMan );

            IPTVLOGSTRING_LOW_LEVEL(

                "CIptvEpgDb::CreateDbL --- PANIC --- Failed to create epg database" );

            User::Panic( KIptvEpgDb, EFailedToCreateEpgDatabase );

            }

        }

    }

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

// CIptvEpgDb::CreateRootCategoryL()

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

//

void CIptvEpgDb::CreateRootCategoryL( RDbNamedDatabase& aDb ) const

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateRootCategoryL" );

    CIptvEpgCategory* root = CIptvEpgCategory::NewL();

    root->iName = KEmptyString;

    root->iParentKey = KIptvRootParent;

    CleanupStack::PushL( root );

    TUint32 key;

    AddCategoryL( aDb, *root, key );

    if ( key != KIptvVodContentCategoryRootId )

        {

        IPTVLOGSTRING_LOW_LEVEL(

            "CIptvEpgDb::CreateRootCategoryL --- PANIC --- Failed to create root category" );

        User::Panic( KIptvEpgDb, EIptvFailedToCreateRootCategory );

        }

    CleanupStack::PopAndDestroy( root );

    }

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

// CIptvEpgDb::CreateContentAccessTableL()

//

// Creates ContentAccess table. Leaves, if the table cannot be created.

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

//

TInt CIptvEpgDb::CreateContentAccessTableL(

    RDbNamedDatabase& aDatabase ) const

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateContentAccessTableL" );

    // Content key

    TDbCol contentKeyCol(

        KIptvCAContentKey, EDbColUint32 );

    // Content URL

    TDbCol contentUrlCol(

        KIptvCAContentUrl, EDbColLongText, KIptvCAContentUrlLength );

    // Download type

    TDbCol dlTypeCol( KIptvCADlType, EDbColUint32 );

    // Language

    TDbCol languageCol( KIptvCALanguage, EDbColText, KIptvCALanguageLength );

    // Price

    TDbCol priceCol( KIptvCAPrice, EDbColText, KIptvCAPriceLength );

    // Purchase type

    TDbCol purchaceTypeCol( KIptvCAPurchaseType, EDbColUint32 );

    // Purchase URL

    TDbCol purchaseUrlCol(

        KIptvCAPurchaseUrl, EDbColLongText, KIptvCAPurchaseUrlLength );

    // Last play position

    TDbCol lastPlayPositionCol( KIptvCALastPlayPosition, EDbColUint32 );

    // Mime type

    TDbCol mimeTypeCol( KIptvCAMimeType, EDbColText, KIptvCAMimeTypeLength );

    // FileSize

    TDbCol fileSizeCol( KIptvCAFileSize, EDbColUint32 );

    // Duration

    TDbCol durationCol( KIptvCADuration, EDbColUint32 );

    // File id

    TDbCol fileIdCol( KIptvCAFileId, EDbColUint32 );

    // Drive id

    TDbCol driveIdCol( KIptvCADriveId, EDbColUint32 );

    // Index

    TDbCol indexCol( KIptvCAIndex, EDbColUint32 );

    // Expression

    TDbCol expressionCol( KIptvCAExpression, EDbColUint32 );

    CDbColSet* colSet = CDbColSet::NewLC();

    colSet->AddL( contentKeyCol );

    colSet->AddL( contentUrlCol );

    colSet->AddL( dlTypeCol );

    colSet->AddL( languageCol );

    colSet->AddL( priceCol );

    colSet->AddL( purchaceTypeCol );

    colSet->AddL( purchaseUrlCol );

    colSet->AddL( lastPlayPositionCol );

    colSet->AddL( mimeTypeCol );

    colSet->AddL( fileSizeCol );

    colSet->AddL( durationCol );

    colSet->AddL( fileIdCol );

    colSet->AddL( driveIdCol );

    colSet->AddL( indexCol );

    colSet->AddL( expressionCol );

    TInt error = aDatabase.CreateTable( KIptvCATable, *colSet );

    CleanupStack::PopAndDestroy( colSet );

    return error;

    }

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

// CIptvEpgDb::CreateServiceTableL()

//

// Creates Service table. Leaves, if the table cannot be created.

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

//

TInt CIptvEpgDb::CreateServiceTableL( RDbNamedDatabase& aDatabase ) const

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateServiceTableL" );

    // Last update key

    TDbCol lastUpdateKeyCol( KIptvEpgServiceLastUpdate, EDbColDateTime );

    // Next update

    TDbCol nextUpdateKeyCol( KIptvEpgServiceNextUpdate, EDbColDateTime );

    // ETag

    TDbCol eTagCol( KIptvEpgServiceETag, EDbColText, KIptvEpgDbLastModifiedMaxLength );

    // LastModifiedSince

    TDbCol lastModifiedSinceCol(KIptvEpgServiceLastModifiedSince, EDbColText, KIptvEpgDbLastModifiedMaxLength);

    // Hash string from service XML file

    TDbCol xmlFileHashCol( KIptvEpgServiceXmlFileHash, EDbColText, KIptvEpgDbXmlFileHashMaxLength );

    // Version

    TDbCol versionKeyCol( KIptvEpgServiceVersion, EDbColUint32 );

    CDbColSet* colSet = CDbColSet::NewLC();

    colSet->AddL( lastUpdateKeyCol );

    colSet->AddL( nextUpdateKeyCol );

    colSet->AddL( eTagCol );

    colSet->AddL( lastModifiedSinceCol );

    colSet->AddL( xmlFileHashCol );

    colSet->AddL( versionKeyCol );

    TInt error = aDatabase.CreateTable( KIptvEpgServiceTable, *colSet );

    CleanupStack::PopAndDestroy( colSet );

    return error;

    }

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

// CIptvEpgDb::CreateCategoryContentTableL()

//

// Creates CategoryContent table. Leaves, if the table cannot be created.

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

//

void CIptvEpgDb::CreateCategoryContentTableL(

    RDbNamedDatabase& aDatabase ) const

    {

    IPTVLOGSTRING_LOW_LEVEL( "CIptvEpgDb::CreateCategoryContentTableL" );

    // Category key

    TDbCol categoryKeyCol( KIptvEpgCategoryContentCategoryKeyCol, EDbColUint32 );