/*

* Copyright (c) 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:  This class is responsible for managing all of music collection

*                databases.

*

*/

#ifndef MPXDBMANAGER_H

#define MPXDBMANAGER_H

// INCLUDES

#include <e32base.h>

#include <f32file.h>

#include <sqldb.h>

#include <badesca.h>

// FORWARD DECLARATIONS

class MMPXTable;

class RSqlStatement;

// CONSTANTS

const TInt KDbManagerAllDrives = 0;

// CLASS DECLARATION

/**

* Generic class responsible for managing databases on multiple drives.

*

* @lib MPXDbPlugin.lib

*/

class CMPXDbManager :

    public CBase

    {

    protected: //   Constructors

        /**

        * C++ default constructor

        * @param aFs file server session

        */

        IMPORT_C CMPXDbManager(RFs& aFs);

        /**

        * The second phase constructor to safely construct things

        * that can leave

        * @param aDatabaseFile database filename

        */

        IMPORT_C void ConstructL(const TFileName& aDatabaseFile);

    public:

        /**

        * Destructor

        */

        IMPORT_C virtual ~CMPXDbManager();

    public: // New methods

        /**

        * Checks if all databases have been initialized.

        * @return ETrue if initialized, EFalse otherwise

        */

        IMPORT_C TBool IsInitialized();

        /**

        * Begins a transaction on all databases.

        */

        IMPORT_C void BeginL();

        /**

        * Commits a transaction on all databases.

        */

        IMPORT_C void CommitL();

        /**

        * Rolls back a transaction on all databases.

        */

        IMPORT_C void RollbackL();

        /**

        * Checks if the database is currently in a transaction

        *

        * @return ETrue if database is currently in a transaction, EFalse otherwise

        */

        IMPORT_C TBool InTransaction();

        /**

        * Tries to create and open the databases on all specified drives.

        * If a drive is not valid (like an MC not plugged in) it will be skipped.

        * @param aDrives array of drives to create and open databases on.

        */

        IMPORT_C void InitDatabasesL(RArray<TInt> aDrives);

        /**

        * Opens a specified database.

        * @param aDrive identifies the drive index of the database to open

        */

        IMPORT_C void OpenDatabaseL(TInt aDrive);

        /**

        * Closes a specified database.

        * @param aDrive identifies the drive index of the database to close

        */

        IMPORT_C void CloseDatabaseL(TInt aDrive);

        /**

        * Closes all open databases.

        */

        IMPORT_C void CloseAllDatabases();

        /**

        * Opens all open databases.

        */

        IMPORT_C void OpenAllDatabasesL();

        /**

        * Checks if the database on a specified drive is open.

        * @param aDrive identifies the drive index of the database to check

        * @return ETrue if the database is open, EFalse otherwise

        */

        IMPORT_C TBool IsOpen(TInt aDrive) const;

        /**

        * Returns the number of currently open databases.

        * @return Number of databases

        */

        IMPORT_C TInt DatabaseCount() const;

        /**

        * Returns the drive corresponding to a give index.

        * @param aIndex identifies the index in the list of drives the database uses

        * @return Drive index the database uses.

        */

        IMPORT_C TInt DbDrive(TInt aIndex) const;

        /**

        * Recreate a specified database.

        * @param aDrive identifies the drive index ro recreate the database

        */

        IMPORT_C void RecreateDatabaseL(TInt aDrive);

        /**

        * Recreate all databases.

        */

        IMPORT_C void RecreateAllDatabasesL();

        /**

        * Return current DB version

        * @return the version of db structure

        */

        IMPORT_C TVersion Version() const;

        /**

        * Return current DB version

        * @return the version of db structure

        */

        IMPORT_C void RegisterTableL(MMPXTable& aTable);

        /**

        * Executes a select query with variable number of parameters on all

        * available drives.

        * @param aFmt query format string

        * @return resulted result set

        */

        IMPORT_C RSqlStatement ExecuteSelectQueryL(TRefByValue<const TDesC> aFmt, ...);

        /**

        * Executes a select query with variable number of parameters

        * against a specified drive

        * @param aDrive to execute query on

        * @param aFmt query format string

        * @return resulted result set

        */

        IMPORT_C RSqlStatement ExecuteSelectQueryL(TInt aDrive, TRefByValue<const TDesC> aFmt,

            ...);

        /**

        * Executes a select query with variable number of parameters

        * on all available drives. Two values will be bound to the statement

        * @param aStatementId unique id of a statement to bind to

        *                     creates a new statement if the id is not found

        * @param aFirstValue TInt Value to bind as first argument

        * @param aSecondValue TInt Value to bind as second argument

        * @param aFmt query format string

        * @return resulted result set. The ownership is not passed so the caller should

        *         not destroy this as it may be reused in future calls.

        */

        IMPORT_C RSqlStatement& ExecuteSelectQueryL( TUint aStatementId,

                                                     TInt aFirstValue, TInt aSecondValue,

                                                     TRefByValue<const TDesC> aFmt, ...);

        /**

        * Executes a select query with variable number of parameters

        * on all available drives. Two values will be bound to the statement

        * @param aStatementId unique id of a statement to bind to

        *                     creates a new statement if the id is not found

        * @param aFirstValue TDesC Value to bind as first argument

        * @param aSecondValue TInt Value to bind as second argument

        * @param aFmt query format string

        * @return resulted result set. The ownership is not passed so the caller should

        *         not destroy this as it may be reused in future calls.

        */

        IMPORT_C RSqlStatement& ExecuteSelectQueryL( TUint aStatementId,

                                                     const TDesC& aFirstValue,

                                                     TInt aSecondValue,

                                                     TRefByValue<const TDesC> aFmt, ...);

        /**

        * Executes a query that does not return a record set

        * @param aDrive to execute query on

        * @param aFmt query format string

        */

        IMPORT_C void ExecuteQueryL(TInt aDrive, TRefByValue<const TDesC> aFmt, ...);

        /**

        * Prints the contents of all the databases to the log file

        * @param aDrive to execute query on

        */

        IMPORT_C void PrintDatabaseL();

        /**

        * Returns the file server session.

        * @return file server session

        */

        IMPORT_C RFs& Fs();

        /**

        * Checks if the space on the specified drive(s) is above the critical level

        * @param aDrive drive ID or KDbManagerAllDrives

        * @leave KErrDiskFull if the space on the specified drive(s) is below the

        *        critical level

        */

        IMPORT_C void CheckDiskSpaceL(TInt aDrive);

        /**

        * Completely recreate all databases.

        */

        IMPORT_C void RegenerateAllDatabasesL();

        /**

         * Checks if the spefified drive is a remove drive

         */      

        IMPORT_C TBool IsRemoteDrive(TDriveNumber aDrive);

    protected:

        /**

        * Creates a database on a specified drive.

        * @param aDrive identifies the database

        */

        IMPORT_C void CreateDatabaseL(TInt aDrive);

        /**

        * Remove the database

        * @param aDrive identifies the database

        */

        IMPORT_C void RemoveDatabaseL(TInt aDrive);

        /**

        * Create the all tables

        * @param aDatabase the database to add tables to

        */

        IMPORT_C void CreateTablesL(RSqlDatabase& aDatabase);

        /**

        * Drop all tables

        * @param aDatabase the database to drop tables from

        */

        IMPORT_C void DropTablesL(RSqlDatabase& aDatabase);

    public:

        /**

        * Executes a select query with variable number of parameters

        * against a specified drive

        * @param aDrive to execute query on

        * @param aFmt query format string

        * @return resulted result set

        */

        IMPORT_C RSqlStatement ExecuteSelectQueryOnAllDrivesL(TInt aDrive, TRefByValue<const TDesC> aFmt,

            ...);

        /**

        * Copy all databases from RAM disk back to normal drive, E, F,...

        * 

        * @return none

        */

        IMPORT_C void CopyDBsFromRamL(); 

        /**

        * Copy all databases to RAM disk back from normal drive, E, F,...

        * 

        * @return none

        */

        IMPORT_C void CopyDBsToRamL( TBool aIsMTPInUse = EFalse);

        /**

        * Check if RAM disk is enough to operatte. If not, DBs will be copied back to drives.

        *

        * @return TInt index to the database handler

        */

        IMPORT_C void EnsureRamSpaceL() ;

        /**

        *  Move DBs from RAMDisk to disks

        */

        //IMPORT_C void BackupDBsL();

    private:

        /**

        * Find available RAMDISK

        * @return error code

        */

        TInt GetRAMDiskPath();

        /**

        * Check if RAM disk is available to copy.

        *

        * @return ETrue if there is enough space, EFalse otherwise

        */

        TBool IsRamDiskSpaceAvailable();

        /**

        * To block a diskspace so that it can gurantee for a write back from RAM disk

        *

        * @return ETrue if the dummy file is created successfully, EFalse otherwise

        */

        TBool BlockDiskSpace( TInt aIndex, TBool aIsMTPInUse = EFalse );

        /**

        * To copy db from regular drive to RAM

        *

        * @return ETrue if succeed 

        * 

        * No-operation if fails

        */

        TBool DoCopyDBToRam( TInt aIndex, TBool aIsMTPInUse );

        /**

        * To copy db back regular drive from RAM

        *

        */

        void DoCopyDBFromRam( TInt aIndex );

        /**

        * To replace dummy file with new content

        * Writes over previous dummy file without freeing disk space

        */

        void ReplaceFileL( const TDesC& aSrcName, const TDesC& aDstName );

        /**

        * To calculate necessary file size of the dummy file

        *

        * @return TInt64 estimated file size

        */

        TInt64 CalculateInitalDummyDBSize( const TVolumeInfo& aVol, TInt aOrigDbSize, TBool aIsMTPInUse = EFalse);

        /**

        * Get database index by giving drive index

        *

        * @return TInt index to the database handler

        */

        TInt GetDatabaseIndex(TInt aDrive);

        /**

         * Sum up the total size in bytes of the databases.

         * 

         * @param aSize - On return, the total size of the databases.

         * @return TInt System error.

         */

        TInt GetTotalDatabasesSize(TInt& aSize);

        /**

         * Sum up the total size in bytes of the databases on the RAM drive.

         * 

         * @param aSize - On return, the total size of the databases on the RAM drive.

         * @return TInt System error.

         */

        TInt GetTotalRamDatabasesSizeL(TInt& aSize);

        /**

        * Remove dummy file

        *

        * @return TInt index to the database handler

        */

        void RemoveDummyFile( TInt index );

        /**

        * Check if disksapce is enough to operatte. If not, it leaves with KErrDiskFull

        *

        */

        void EnsureDiskSpaceL(TInt aDrive) ;

        /** 

         * Begin transaction, leaves on error

         */

        void DoBeginL();

        /** 

         * Commit transaction, leaves on error

         */

        void DoCommitL();

        /**

        * Create full path and filename on a specified drive unit.

        * @param aDrive identifies the drive unit

        */

        HBufC* CreateFullFilenameL(TDriveUnit aDrive);

    protected:  // Types

        typedef struct

            {

            TInt iDrive;

            TBool iOpen;

            HBufC* iAliasname;

#ifdef __RAMDISK_PERF_ENABLE 

            TBool iUseRAMdb;

            HBufC* iOrigFullFilePath;

            HBufC* iTargetFullFilePath;

            TFileName iDummyFilePath;

#endif //__RAMDISK_PERF_ENABLE 

            } DatabaseHandle;

    protected:  // Data

        HBufC* iDbFile;

        RArray<MMPXTable*> iTables;

        RSqlDatabase iDatabase;

        RArray<DatabaseHandle> iDatabaseHandles;

    private:

        /**

        * Create the all tables

        * @param aDatabase the database to add tables to

        * @param aCorrupt specifies whether the database is corrupted or not

        */

        void CreateTablesL(RSqlDatabase& aDatabase, TBool aCorrupt);

        /**

        * Opens root database at C-drive.

        */

        void OpenRootDatabaseL();

        /**

        * Creates a specified database.

        * @param aDrive identifies the drive unit of the database to create

        */

        void CreateDatabaseL(TDriveUnit aDrive);

        /**

        * Attached a specified database.

        * @param aIndex  Index to iDatabaseHandles

        */

        void AttachDatabaseL(TInt aIndex);

        /**

        * Detach a specified database.

        * @param aIndex  Index to iDatabaseHandles

        */

        void DetachDatabaseL(TInt aIndex);

        /**

        * Open database

        * @param aIndex Index to iDatabaseHandles

        */

        void OpenDatabaseAtIndexL( TInt aIndex );

        /**

        * Close database

        * @param aIndex Index to iDatabaseHandles

        */

        void CloseDatabaseAtIndexL(TInt aIndex);

        /**

        * Create filename on a specified drive unit.

        * @param aDrive identifies the drive unit

        */

        HBufC* CreateFilenameL(TDriveUnit aDrive);

        /**

        * Replaces specially formatted query symbols with a specified alias.

        * @param aAlias identifies the alias name to use in query

        */

        void ReplaceDriveAlias(TDes& aQuery, const TDesC& aAlias);

        /**

        * Replaces specially formatted query symbols with a specified alias.

        * @param aAlias identifies the alias name to use in query

        * @param aToKen replace by aAlias

        */

        void ReplaceDriveAlias(TDes& aQuery, const TDesC& aAlias, const TDesC& aToKen);

        /**

        * Removes specially formatted query symbols from the query

        * @param aQuery identifies the query to remove specially formatted symbols

        */

        void RemoveDriveAlias(TDes& aQuery);

        /**

        * Removes specially formatted query symbols from the query

        * @param aQuery identifies the query to remove specially formatted symbols

        * @param aToKen identifies need remove string

        */

        void RemoveDriveAlias(TDes& aQuery, const TDesC& aToKen);