/*

* 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 database access

*                databases.

*

*/

// INCLUDE FILES

#include <sqldb.h>

#include <badesca.h>

#include <f32file.h>

// PREQ2536 the files sqlrowsetutil.h and sqlrowsetutil.cpp has been removed

//#ifdef __WINSCW__    

//#include <sqlrowsetutil.h>

//#endif

#include <sysutil.h>

#ifdef __RAMDISK_PERF_ENABLE

#include <centralrepository.h>

#include <BAUTILS.H>  

#include <mpxinternalcrkeys.h>

#endif //__RAMDISK_PERF_ENABLE

#include <mpxlog.h>

#include "mpxdbcommondef.h"

#include "mpxtable.h"

#include "mpxdbmanager.h"

// CONSTANTS

// Version of   Database

const   TInt KMPXDbVersion[] = {6,0,0};

_LIT8( KMCSqlConfig, "cache_size=1024; page_size=16384; " );

_LIT(KSecureFilePath,   "%S[%x]%S");

_LIT(KRootDrive, "C:");

_LIT(KAliasName, "%1SDrive");

_LIT(KBeginTransaction, "BEGIN TRANSACTION");

_LIT(KCommitTransaction, "COMMIT TRANSACTION");

_LIT(KRollbackTransaction, "ROLLBACK TRANSACTION");

_LIT(KOrderByToken, "ORDER BY");

_LIT(KDBNameToken, ":dbname");

_LIT(KPlDBNameToken, ":pldbname");

_LIT(KUnionAllToken, " UNION ALL ");

_LIT(KSelectToken, "SELECT");

//for database deletion

_LIT( KDBFilePath, "\\private\\10281e17\\" );

_LIT( KDBFilePattern, "*.db*" );    

#ifdef _DEBUG

_LIT(KTableQuery, "SELECT * FROM %S");

_LIT(KAttachedTableQuery, "SELECT * FROM :dbname.%S");

_LIT(KFindAllCDriveTablesQuery, "SELECT name FROM   sqlite_master WHERE type = 'table' ORDER BY name");

_LIT(KFindAllAttachedTablesQuery, "SELECT name FROM :dbname.sqlite_master WHERE type = 'table' ORDER BY name");

_LIT(KNameColumn, "name");

#endif

const TInt KMaxLogQuery = 248;

const TInt KBufIncrement = 10;

#ifdef __RAMDISK_PERF_ENABLE

_LIT(KSecurePath,   "[%x]%S");

_LIT(KRAMAliasName, "%S");

_LIT( KDummyDbFile, "%c:\\private\\10281e17\\dummydb.dat" );

const TInt64 KMPMegaByte = 1048576;

const TInt64 KMPEstimatedSongInBytes = KMPMegaByte * 2; 

const TInt KMPEstimatedSizePerDBEntry = 3000; // worst scenario, can be lower if needed

const TInt KMPMinimumRAMSizeToRun = 6 * KMPMegaByte; 

// if RAM is lower than 5MB, doesn't seem enough for SQL as well.

// so we set this number to move back DBs before being kicked out

#endif //__RAMDISK_PERF_ENABLE

// Used to suppress overflow when appending formatted text to a buffer.

class TOverflowHandle :

    public TDesOverflow

    {

    public:

        TOverflowHandle() :

            iFlag(EFalse)

            {

            }

        virtual void Overflow(TDes& /* aDes */)

            {

            iFlag = ETrue;

            return;

            }

        TBool GetOverflowFlag()

            {

            TBool flag(iFlag);

            iFlag = EFalse;

            return flag;

            }

    protected:

        TBool iFlag;

    };

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

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

// Constructor

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

//

EXPORT_C CMPXDbManager::CMPXDbManager(

    RFs& aFs) :

    iFs(aFs), 

    iRAMDiskPerfEnabled(EFalse),

    iMaximumAllowedRAMDiskSpaceToCopy(0),

    iRAMInUse(EFalse)

    {

    MPX_FUNC("CMPXDbManager::CMPXDbManager");

    }

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

// Second phase constructor.

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

//

EXPORT_C void CMPXDbManager::ConstructL(

    const TFileName& aDatabaseFile)

    {

    MPX_FUNC("CMPXDbManager::ConstructL");

    iDbFile = aDatabaseFile.AllocL();

#ifdef __RAMDISK_PERF_ENABLE

    TInt flags( 0 );

    CRepository* repository = CRepository::NewLC( KCRUidMPXMPFeatures );

    User::LeaveIfError( repository->Get( KMPXMPLocalVariation, flags ));

    MPX_DEBUG2("CMPXDbManager::ConstructL KMPXMPLocalVariation %d", flags);        

    iRAMDiskPerfEnabled = static_cast<TBool>( flags & KMPXEnableRAMDisk );

    TInt temp;

    User::LeaveIfError( repository->Get( KMAXAllowedDiskSpaceToCopy, temp) );

    iMaximumAllowedRAMDiskSpaceToCopy = temp * KMPMegaByte;

    CleanupStack::PopAndDestroy(repository);

    if ( iRAMDiskPerfEnabled )

        {

        MPX_DEBUG1("CMPXDbManager::ConstructL RAMDisk performance is enabled.");

        MPX_DEBUG2("CMPXDbManager::ConstructL RAMDisk iMaximumAllowedRAMDiskSpaceToCopy=%Lu", iMaximumAllowedRAMDiskSpaceToCopy);

        if ( GetRAMDiskPath() != KErrNone )

            {

            // Error finding ram drive, disable ram disk

            iRAMDiskPerfEnabled = EFalse;

            }

        }

    else

        {

        MPX_DEBUG2("CMPXDbManager::ConstructL RAMDisk performance is NOT enabled flag=%d", flags);

        MPX_DEBUG2("CMPXDbManager::ConstructL RAMDisk iMaximumAllowedRAMDiskSpaceToCopy=%Lu", iMaximumAllowedRAMDiskSpaceToCopy);

        }

#endif //__RAMDISK_PERF_ENABLE

    }

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

// Destructor

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

//

EXPORT_C CMPXDbManager::~CMPXDbManager()

    {

    MPX_FUNC("CMPXDbManager::~CMPXDbManager");

    // Close the state array

    iPreparedStatements.Close();

    // Close and destroy all RSQLStatements

    TInt c( iStatements.Count() );

    for( TInt i=0; i<c; ++i )

        {

        iStatements[i]->Close();

        }

    iStatements.ResetAndDestroy();

    iTables.Close();

    CloseAllDatabases();

    delete iDbFile;

    iDatabaseHandles.Close();

    }

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

// Checks if all databases have been initialized.

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

//

EXPORT_C TBool CMPXDbManager::IsInitialized()

    {

    MPX_FUNC("CMPXDbManager::IsInitialized");

    return iInitialized;

    }

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

// Begins a transaction on all databases.

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

//

EXPORT_C void CMPXDbManager::BeginL()

    {

    MPX_FUNC("CMPXDbManager::BeginL");

    ASSERT(iTransactionCount >= 0);

    if (++iTransactionCount == 1)

        {

        DoBeginL();

        }

    }

void CMPXDbManager::DoBeginL()

    {

    MPX_FUNC("CMPXDbManager::DoBeginL");

    TInt err = iDatabase.Exec(KBeginTransaction);

    // transforms SQL error to KErrNotReady

    if( (err <= KSqlErrGeneral && err >= KSqlErrNotDb) || err == KSqlErrStmtExpired )

        {

        User::Leave(KErrNotReady);

        }

    else

        {

        User::LeaveIfError(err);

        }

    }

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

// Copy all DBs to RAM disk

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

//

EXPORT_C void CMPXDbManager::CopyDBsToRamL( TBool aIsMTPInUse )

    {

#ifdef __RAMDISK_PERF_ENABLE

    MPX_DEBUG1("-->CMPXDbManager::CopyDBsToRamL");

    if( iRAMDiskPerfEnabled )

        {

        if ( !IsRamDiskSpaceAvailable() )

            {

            return;

            }

        // Check if we are over the allowed ram space.

        TInt dbSize=0;

        TInt err = GetTotalDatabasesSize(dbSize);

        if ( err || (dbSize > iMaximumAllowedRAMDiskSpaceToCopy) )

            {

            MPX_DEBUG2("<--CMPXDbManager::CopyDBsToRamL Over the allowed Ram disk limit %Lu", iMaximumAllowedRAMDiskSpaceToCopy );

            return;

            }

        TInt transactionCount = iTransactionCount;

        if (iTransactionCount > 0) 

            {

            iTransactionCount = 0;

            DoCommitL();

            }

        TInt count(iDatabaseHandles.Count());

        TBool ret = EFalse;

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

            {

            if ( iDatabaseHandles[i].iUseRAMdb )

                {

                // already used

                MPX_DEBUG1("CMPXDbManager::CopyDBsToRamL iUseRAMdb already ETrue");

                continue;

                }

            if ( err != KErrNone )

                {

                RemoveDummyFile(i);

                }

            }

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

            }

        }

    iRAMInUse = ETrue;

    MPX_DEBUG1("<--CMPXDbManager::CopyDBsToRamL");

#endif //__RAMDISK_PERF_ENABLE

    }

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

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

//

    {

#ifdef __RAMDISK_PERF_ENABLE

        {

        return EFalse;

        }

        {

        MPX_DEBUG1("CMPXDbManager::DoCopyDBsToRamL() BlockDiskSpace failed");

        return EFalse; // continue for next drive

        }

        {

        return EFalse;

        }

    MPX_DEBUG1("<--CMPXDbManager::DoCopyDBsToRamL");

#endif //__RAMDISK_PERF_ENABLE

    }

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

// Copy all DBs from RAM disk back to normal drives

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

//

EXPORT_C void CMPXDbManager::CopyDBsFromRamL()

    {

#ifdef __RAMDISK_PERF_ENABLE

    if( iRAMDiskPerfEnabled )

       {

        TInt transactionCount = iTransactionCount;

        if (iTransactionCount > 0) 

            {

            iTransactionCount = 0;

            }

        TInt count(iDatabaseHandles.Count());

            {

                {

                RemoveDummyFile(i);

                }

            iDatabaseHandles[i].iUseRAMdb = EFalse;

            // open db from drive

            }

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

            }

        }

#endif //__RAMDISK_PERF_ENABLE

    }

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

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

//

    {

#ifdef __RAMDISK_PERF_ENABLE

    //Copy Db from RAM to replace dummy file

#endif //__RAMDISK_PERF_ENABLE

    } 

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

// CMPXDbManager::ReplaceFileL

//

// Replaces a file with another writing over the destination file.

// Leaves on error.

// Implementation follows CFileMan::Copy except that 

//  - we don't resize target file to zero

//  - we don't copy file attributes & timestamp

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

//

void CMPXDbManager::ReplaceFileL( const TDesC& aSrcName, const TDesC& aDstName )

    {

    // open files

    RFile srcFile;

    User::LeaveIfError( srcFile.Open(iFs, aSrcName, EFileRead|EFileShareReadersOnly) );

    CleanupClosePushL( srcFile );

    RFile dstFile;

    CleanupClosePushL( dstFile );

    // resize destination file