/*

* Copyright (c) 2006 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:    Database where to store scheduled events.*

*/

// INCLUDE FILES

#include "CCseScheduleDB.h"         // Header file for this class

#include <bautils.h>

#include "CseDebug.h"               // Debug macros

#include <babackup.h>

// EXTERNAL DATA STRUCTURES

// None

// EXTERNAL FUNCTION PROTOTYPES  

// None

// CONSTANTS

_LIT( KCseCDiskPrefix,  "c:"                         );

_LIT( KCseSqlGetAll,    "SELECT * FROM ScheduleEvent");

_LIT( KCseSelectFromDb, "SELECT * FROM "             );

_LIT( KCseWhere,        " WHERE "                    );

_LIT( KCseEqual,        " = "                        );

_LIT( KCseOrderBy,      " ORDER BY "                 );

_LIT( KCseAnd,          " AND "                      );

_LIT( KCseLess,         " < "                        );

_LIT( KCseMore,         " > "                        );

static TUint KScheduleNameMaxLength = 255;

static TUint KCseDatbaseVersionNumber = 1;

// MACROS

// None

// LOCAL CONSTANTS AND MACROS

// None

// MODULE DATA STRUCTURES

// None

// LOCAL FUNCTION PROTOTYPES

// None

// FORWARD DECLARATIONS

// None

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

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

// CCseScheduleDB::CCseScheduleDB()

//

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

CCseScheduleDB::CCseScheduleDB() : iDbAccess( ECseDbOpen )

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::CCseScheduleDB");

	// Default C++ Constructor		

	CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::CCseScheduleDB");

	}

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

// CCseScheduleDB::~CCseScheduleDB()

//

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

CCseScheduleDB::~CCseScheduleDB()

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::~CCseScheduleDB");

	iScheduleDb.Close();

	delete iScheduleFileStore;

	iFsSession.Close(); 

	if( iCompactTimer )

        {

        iCompactTimer->Cancel();

        delete iCompactTimer;

        }

    delete iBackupWrapper;

    CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::~CCseScheduleDB");

	}

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

// CCseScheduleDB::NewL()

//

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

CCseScheduleDB* CCseScheduleDB::NewL()

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::NewL");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );    

    CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::NewL");

    return self;

	}

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

// CCseScheduleDB::ConstructL()

//

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

void CCseScheduleDB::ConstructL()

	{

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::ConstructL");

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

    iCompactTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iBackupWrapper = CBaBackupSessionWrapper::NewL();

	TRAPD( err, OpenOrCreateDbL() );

    if ( err != KErrNone )

        {

		CSELOGSTRING2_HIGH_LEVEL( "CCseScheduleDB::ConstructL - Opening or creating the database FAILED: %d", err );

        if ( err != KErrNoMemory && 

             err != KErrLocked && 

             err != KErrDisMounted &&

             err != KErrDiskFull &&

             err != KErrNotReady )

            {

            // Delete and recreate database file. Cannot recover other way. 

    		CSELOGSTRING_HIGH_LEVEL( "CCseScheduleDB::ConstructL - deleting database" );

            RemoveDbL();

    		CSELOGSTRING_HIGH_LEVEL( "CCseScheduleDB::ConstructL - recreating database" );

            TRAPD( err, OpenOrCreateDbL() );

            if ( err != KErrNone )

                {

                CSELOGSTRING2_HIGH_LEVEL( "CCseScheduleDB::ConstructL couldnt recreate database (%d), leaving", err );

                User::Leave( err );

                }

            }

        else

            {

            CSELOGSTRING2_HIGH_LEVEL( "CCseScheduleDB::ConstructL leaving (%d)", err );

            User::Leave( err );

            }

        }

	CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::ConstructL");	

	}

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

// CCseScheduleDB::RemoveDbL()

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

void CCseScheduleDB::RemoveDbL()

    {

    delete iBackupWrapper;

	iBackupWrapper = NULL;

    iScheduleDb.Close();

	delete iScheduleFileStore;

	iScheduleFileStore = NULL;

    if ( BaflUtils::FileExists( iFsSession, iDbFile ) )

        {

        TInt err( iFsSession.Delete( iDbFile ) );

		CSELOGSTRING2_HIGH_LEVEL("CCseScheduleDB:: deleting database file, err = %d", err);

        }

	}

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

// CCseScheduleDB::GetApplicationSchedulesL()

//

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

void CCseScheduleDB::GetApplicationSchedulesL( const TInt32 aAppUid,

								RPointerArray<CCseScheduledProgram>& aArray )

	{

	CSELOGSTRING2_HIGH_LEVEL(">>>CCseScheduleDB::GetApplicationSchedulesL - AppUid: %d",

	                          aAppUid);

	LeaveIfDbLockedL();

	ResetCompactTimer();

	// Gets program occurence(s) that are going to happen next

	// from database

	TBuf<KCseCustomSqlLength> sqlStatement;

	sqlStatement.Append( KCseSelectFromDb );	

	sqlStatement.Append( KCseScheduleTable );

	sqlStatement.Append( KCseWhere );

	sqlStatement.Append( KCseScheduleApplicationUIDCol );

	sqlStatement.Append( KCseEqual );

	sqlStatement.AppendNum( aAppUid );

	sqlStatement.Append( KCseOrderBy );

	sqlStatement.Append( KCseScheduleStartTimeCol );

	// Order table based on start time

	RDbView view;

	CleanupClosePushL( view );

	User::LeaveIfError( view.Prepare( iScheduleDb, 

						TDbQuery( sqlStatement ) ) );

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

	view.FirstL();

	CDbColSet* colSetOrder = view.ColSetL();

	CleanupStack::PushL( colSetOrder );

	// Get the SQL table indexes.

	TDbColNo keyIndex = colSetOrder->ColNo( KCseScheduleDbKeyCol );

	TDbColNo nameIndex = colSetOrder->ColNo( KCseScheduleNameCol );

	TDbColNo startTimeIndex = colSetOrder->ColNo( KCseScheduleStartTimeCol );

	TDbColNo endTimeIndex = colSetOrder->ColNo( KCseScheduleEndTimeCol );

	TDbColNo applicationUidIdIndex = colSetOrder->ColNo( KCseScheduleApplicationUIDCol );

	TDbColNo plugInUidIndex = colSetOrder->ColNo( KCseSchedulePlugInUIDCol );

	TDbColNo applicationSpecificIndex = colSetOrder->ColNo( KCseScheduleApplicationSpecificCol );

	TDbColNo scheduleTypeIndex = colSetOrder->ColNo( KCseScheduleTypeCol );

	TDbColNo pluginTypeIndex = colSetOrder->ColNo( KCseSchedulePluginTypeCol );

	CleanupStack::PopAndDestroy( colSetOrder );

	// Loop through the tables

	while ( view.AtRow() )

		{

		// Create new CCseSceduledProgram to be added to array

		CCseScheduledProgram* prog = CCseScheduledProgram::NewL();

		CleanupStack::PushL( prog );			

		// Fill created schedule with DB information

		view.GetL();

		prog->SetDbIdentifier( view.ColUint32( keyIndex ) );

		prog->SetName( view.ColDes8( nameIndex ) );

		prog->SetStartTime( view.ColTime( startTimeIndex ) );

		prog->SetEndTime( view.ColTime( endTimeIndex ) );

		prog->SetAppUid( view.ColInt32( applicationUidIdIndex ) );

		prog->SetPluginUid( view.ColInt32( plugInUidIndex ) );

		prog->SetScheduleType( view.ColInt32( scheduleTypeIndex ) );

		prog->SetPluginType( view.ColInt32( pluginTypeIndex ) );

		TInt streamLen( 0 );

		streamLen = view.ColLength( applicationSpecificIndex );

		HBufC8* appDataBuffer = HBufC8::NewL( streamLen );

		CleanupStack::PushL( appDataBuffer );

		TPtr8 buffPtr( appDataBuffer->Des() );

		RDbColReadStream readStream;

		readStream.OpenLC( view, applicationSpecificIndex );

		readStream.ReadL( buffPtr, streamLen );

		readStream.Release();

		CleanupStack::PopAndDestroy(); // readStream

		prog->SetApplicationDataL( *appDataBuffer );

		CleanupStack::PopAndDestroy( appDataBuffer );

		User::LeaveIfError( aArray.Append( prog ) );

		CleanupStack::Pop( prog );

		view.NextL();

		}

	CleanupStack::PopAndDestroy( &view ); // Closes view

	CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::GetApplicationSchedulesL");	

	}

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

// CCseScheduleDB::OpenOrCreateDbL()

//

// Create a new database. 

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

void CCseScheduleDB::OpenOrCreateDbL()

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::OpenOrCreateDbL");

	TBuf<KMaxFileName> path;

	// Get path to CSE's private directory

	TInt err( iFsSession.PrivatePath( path ) );

	if ( err != KErrNone )

		{

		CSELOGSTRING2_HIGH_LEVEL("iFsSession.PrivatePath() failed: %d", err );

		User::Leave( err );

		}

	iDbFile.Zero();

	iDbFile.Append( KCseCDiskPrefix );

	iDbFile.Append( path );

	if ( BaflUtils::CheckFolder( iFsSession, iDbFile ) != KErrNone ) 

		{

		err = iFsSession.CreatePrivatePath( EDriveC );

		if ( err != KErrNone )

			{

			CSELOGSTRING2_HIGH_LEVEL( "CreatePrivatePath failed! %d", err );

			User::Leave( err );

			}

		}

	iDbFile.Append( KCseScheduleDBName() );

	// If file doesn't exist create it

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

        {

        CSELOGSTRING_HIGH_LEVEL("CCseScheduleDB::OpenOrCreateDbL Create New");

        iScheduleDb.Close();

        if( iScheduleFileStore )

            {

            delete iScheduleFileStore;

            iScheduleFileStore = NULL;

            }

		iScheduleFileStore = CPermanentFileStore::ReplaceL( iFsSession,

                                                            iDbFile,

                                                            EFileRead|EFileWrite );

		// Set file store type

		iScheduleFileStore->SetTypeL( iScheduleFileStore->Layout() ); 

    	// Create stream object

	    TStreamId id = iScheduleDb.CreateL( iScheduleFileStore );   

		// Keep database id as root of store  

    	iScheduleFileStore->SetRootL( id ); 

		// Complete creation by commiting

    	iScheduleFileStore->CommitL();                              

        CreateDatabaseTableL( iScheduleDb );        

        CreateScheduleTableL( iScheduleDb );

        SetDatabaseVersionL( );

        }

    // Or if it exists then just open it.

	else

		{

		iScheduleDb.Close();

	    delete iScheduleFileStore;

		iScheduleFileStore = NULL;

		iScheduleFileStore = CPermanentFileStore::OpenL( iFsSession, iDbFile,

														EFileRead|EFileWrite );

		iScheduleFileStore->SetTypeL( iScheduleFileStore->Layout() );

		iScheduleDb.OpenL( iScheduleFileStore, iScheduleFileStore->Root() );

    	CheckDbVersionL();    	

		User::LeaveIfError( iScheduleDb.Compact() );

		}

	if ( !iBackupWrapper )

	    {

	    iBackupWrapper = CBaBackupSessionWrapper::NewL();

	    }

	iBackupWrapper->RegisterFileL( iDbFile, *this );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::OpenOrCreateDbL");

    }

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

// CCseScheduleDB::CheckDbVersionL

//

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

void CCseScheduleDB::CheckDbVersionL( )

	{	

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::CheckDbVersionL");

	TInt dbVersion( 0 );	

	TRAPD( leave, dbVersion = GetDbVersionL() );

	if ( dbVersion != KCseDatbaseVersionNumber || leave != KErrNone )

	    {

    	CSELOGSTRING3_HIGH_LEVEL(

    	    "CCseScheduleDB::CheckDbVersionL Not ok, version: %d, error: %d",

    	    dbVersion, leave );

	    // Destroy the old one

	    iScheduleDb.Close();

	    delete iScheduleFileStore;

	    iScheduleFileStore = NULL;

	    // Create new one

	    iScheduleFileStore = CPermanentFileStore::ReplaceL( iFsSession,

                                                            iDbFile,

                                                            EFileRead|EFileWrite );

		// Set file store type

		iScheduleFileStore->SetTypeL( iScheduleFileStore->Layout() ); 

    	// Create stream object

	    TStreamId id = iScheduleDb.CreateL( iScheduleFileStore );   

		// Keep database id as root of store  

    	iScheduleFileStore->SetRootL( id ); 

		// Complete creation by commiting

    	iScheduleFileStore->CommitL();                              

    	CreateDatabaseTableL( iScheduleDb );

        CreateScheduleTableL( iScheduleDb );

	    SetDatabaseVersionL( );

	    }

	CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::CheckDbVersionL");		

	}

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

// CCseScheduleDB::GetDbVersionL

//

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

TInt CCseScheduleDB::GetDbVersionL( )

	{	

	CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::GetDbVersionL");

	LeaveIfDbLockedL();

	ResetCompactTimer();

	TInt dbVersion(0);

	TBuf<KCseCustomSqlLength> sqlStatement;

	sqlStatement.Append( KCseSelectFromDb );

	sqlStatement.Append( KCseDatabaseTable );

	// Order table based on start time

	RDbView view;

	CleanupClosePushL( view );

	User::LeaveIfError( view.Prepare( iScheduleDb, 

						TDbQuery( sqlStatement ) ) );

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

	// Get the next reminder

	view.FirstL();

	CDbColSet* colSetOrder = view.ColSetL();

	CleanupStack::PushL( colSetOrder );

	TDbColNo versionIndex = colSetOrder->ColNo( KCseDatabaseVersionCol );

	CleanupStack::PopAndDestroy( colSetOrder );

	if ( view.AtRow() )

		{				

		view.GetL();

		dbVersion = view.ColInt32( versionIndex );		

		}

	CleanupStack::PopAndDestroy( &view ); // Closes view

	CSELOGSTRING2_HIGH_LEVEL(

	    "<<<CCseScheduleDB::GetDbVersionL, version: %d",

	    dbVersion );

	return dbVersion;

	}

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

// CCseScheduleDB::CreateScheduleTableL

//

// Creates Schedule table.

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

void CCseScheduleDB::CreateScheduleTableL( RDbStoreDatabase& aDatabase ) const

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::CreateScheduleTableL");

    // Create columns for the database.     

    TDbCol keyCol( KCseScheduleDbKeyCol, EDbColUint32 );

    keyCol.iAttributes = TDbCol::EAutoIncrement;

	TDbCol nameCol( KCseScheduleNameCol, EDbColText8, KScheduleNameMaxLength );		

	TDbCol startTimeCol( KCseScheduleStartTimeCol, EDbColDateTime );

	TDbCol endTimeCol( KCseScheduleEndTimeCol, EDbColDateTime );

    TDbCol applicationUidCol( KCseScheduleApplicationUIDCol, EDbColInt32 );   

	TDbCol plugInUidCol( KCseSchedulePlugInUIDCol, EDbColInt32 );    

	TDbCol typeCol( KCseScheduleTypeCol, EDbColInt32 );    	

	TDbCol applicationSpecificCol( KCseScheduleApplicationSpecificCol, EDbColLongBinary );

	TDbCol runCountCol( KCseScheduleRunCountCol, EDbColInt32 );	

	TDbCol stateCol( KCseScheduleStateCol, EDbColInt32 );	

	TDbCol pluginTypeCol( KCseSchedulePluginTypeCol, EDbColInt32 );	

	TDbCol reserved1Col( KCseScheduleReserved1Col, EDbColInt32 );	

	TDbCol reserved2Col( KCseScheduleReserved2Col, EDbColInt32 );	

	// Create column set and add defined columns in to the set

    CDbColSet* scheduleColSet = CDbColSet::NewLC();

    scheduleColSet->AddL( keyCol );

	scheduleColSet->AddL( nameCol );

	scheduleColSet->AddL( startTimeCol );

	scheduleColSet->AddL( endTimeCol );

    scheduleColSet->AddL( applicationUidCol );

    scheduleColSet->AddL( plugInUidCol );

	scheduleColSet->AddL( typeCol );

    scheduleColSet->AddL( applicationSpecificCol );	

    scheduleColSet->AddL( runCountCol );	

    scheduleColSet->AddL( stateCol );

    scheduleColSet->AddL( pluginTypeCol );

    scheduleColSet->AddL( reserved1Col );

    scheduleColSet->AddL( reserved2Col );

    // Create new table to the database with created columnset

    User::LeaveIfError( aDatabase.CreateTable( KCseScheduleTable, 

										      *scheduleColSet ) ); 

    CleanupStack::PopAndDestroy( scheduleColSet );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::CreateScheduleTableL");

    }

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

// CCseScheduleDB::CreateDatabaseTableL

//

// Creates Database table.

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

void CCseScheduleDB::CreateDatabaseTableL( RDbStoreDatabase& aDatabase )

    {

    CSELOGSTRING_HIGH_LEVEL(">>>CCseScheduleDB::CreateDatabaseTableL");

    // Create columns for the database.     

    TDbCol versionCol( KCseDatabaseVersionCol, EDbColInt32 );

    TDbCol reserved1Col( KCseDatabaseReserved1Col, EDbColInt32 );

    TDbCol reserved2Col( KCseDatabaseReserved2Col, EDbColInt32 );

	// Create column set and add defined columns in to the set

    CDbColSet* databaseColSet = CDbColSet::NewLC();

    databaseColSet->AddL( versionCol );

    databaseColSet->AddL( reserved1Col );

    databaseColSet->AddL( reserved2Col );

    // Create new table to the database with created columnset

    User::LeaveIfError( aDatabase.CreateTable( KCseDatabaseTable, 

										      *databaseColSet ) ); 

    CleanupStack::PopAndDestroy( databaseColSet );

    CSELOGSTRING_HIGH_LEVEL("<<<CCseScheduleDB::CreateDatabaseTableL");

    }

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

// CCseScheduleDB::SetDatabaseVersionL

//