/*

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

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

            {

            if ( ! iDatabaseHandles[i].iOpen )

                {

                MPX_DEBUG1("CMPXDbManager::CopyDBsToRamL DB not open (assuming drive is not present)");

                continue;

                }

            if ( iDatabaseHandles[i].iUseRAMdb )

                {

                // already used

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

                continue;

                }

            CloseDatabaseAtIndexL( i ); // let leave: not much we can do if we can't close the original DB

            DoCopyDBToRam( i, aIsMTPInUse ); // copies if it can

            TRAPD( err, OpenDatabaseAtIndexL( i ) );

            if ( err != KErrNone )

                {

                MPX_DEBUG2("CMPXDbManager::CopyDBsToRamL OpenDatabaseAtIndexL leave=%d", err);

                RemoveDummyFile(i);

                if ( iDatabaseHandles[i].iUseRAMdb ) 

                    {

                    // go back to disk DB

                    TRAP_IGNORE(CloseDatabaseAtIndexL( i ));

                    iDatabaseHandles[i].iUseRAMdb = EFalse;

                    OpenDatabaseAtIndexL( i );

                    continue;

                    }

                else

                    {

                    User::Leave( err );

                    }

                }

            }

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

            }

        }

    iRAMInUse = ETrue;

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

#endif //__RAMDISK_PERF_ENABLE

    }

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

// CMPXDbManager::DoCopyDBToRam

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

//

TBool CMPXDbManager::DoCopyDBToRam( TInt aIndex, TBool aIsMTPInUse )

    {

#ifdef __RAMDISK_PERF_ENABLE

    MPX_DEBUG2("-->CMPXDbManager::DoCopyDBsToRam drive=%d", (TInt)iDatabaseHandles[aIndex].iDrive);

    DatabaseHandle& database = iDatabaseHandles[aIndex];

    TInt err = KErrNone;

    delete database.iOrigFullFilePath;

    database.iOrigFullFilePath = 0;

    delete database.iTargetFullFilePath;

    database.iTargetFullFilePath = 0;

    TRAP (err, 

	      database.iOrigFullFilePath = CreateFullFilenameL( database.iDrive );

          database.iUseRAMdb = ETrue; // must turn this on to create RAM filename

          database.iTargetFullFilePath = CreateFullFilenameL( database.iDrive );

          BaflUtils::EnsurePathExistsL( iFs, *database.iTargetFullFilePath ));

    database.iUseRAMdb = EFalse;

    if (err != KErrNone)

        {

        MPX_DEBUG1("CMPXDbManager::DoCopyDBsToRamL() CreateFilenameL or EnsurePathExistsL failed");

        return EFalse;

        }

    MPX_DEBUG2("RAMDisk src path=%S", database.iOrigFullFilePath);

    MPX_DEBUG2("RAMDisk dst path=%S", database.iTargetFullFilePath);

    if (!BlockDiskSpace( aIndex, aIsMTPInUse ) )

        {

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

        return EFalse; // continue for next drive

        }

    if ( BaflUtils::CopyFile(iFs, *database.iOrigFullFilePath, *database.iTargetFullFilePath ) != KErrNone )

        {

        RemoveDummyFile( aIndex );

        return EFalse;

        }

    MPX_DEBUG2("RAMDisk Database copied=%d", (TInt)database.iDrive);

    database.iUseRAMdb = ETrue; // succeeded moving DB to RAM

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

    return ETrue;

#else

    return EFalse;

#endif //__RAMDISK_PERF_ENABLE

    }

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

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

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

//

EXPORT_C void CMPXDbManager::CopyDBsFromRamL()

    {

    MPX_FUNC("CMPXDbManager::CopyDBsFromRamL");

#ifdef __RAMDISK_PERF_ENABLE

    if( iRAMDiskPerfEnabled )

       {

        TInt transactionCount = iTransactionCount;

        if (iTransactionCount > 0) 

            {

            iTransactionCount = 0;

            TRAP_IGNORE( DoCommitL() );

            }

        TInt count(iDatabaseHandles.Count());

        TInt leaveError = KErrNone;

        iRAMInUse = EFalse;

        // Should not leave until all the databases have been copied from RAM drive. 

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

            {

            if ( !iDatabaseHandles[i].iUseRAMdb )

                {

                continue;

                }

            TRAPD( error, CloseDatabaseAtIndexL( i ) );

            if ( error )

                {

                // Can't close db on RAM drive, so cleanup.

                MPX_DEBUG2("CMPXDbManager::CopyDBsFromRamL CloseDatabaseAtIndexL fail: error = %d", error);

                // Delete database on RAM drive.

                BaflUtils::DeleteFile(iFs, *iDatabaseHandles[i].iTargetFullFilePath);

                // Delete dummy file

                RemoveDummyFile(i);

                }

            else

                {

                DoCopyDBFromRam(i);

                }

            iDatabaseHandles[i].iUseRAMdb = EFalse;

            // open db from drive

            TRAP( error, OpenDatabaseAtIndexL( i ) );      

            if ( error && !leaveError )

                {

                leaveError = error;

                }

            }

        // leave if error

        User::LeaveIfError(leaveError);

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

            }

        }

#endif //__RAMDISK_PERF_ENABLE

    }

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

// CMPXDbManager::DoCopyDBsToRam

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

//

void CMPXDbManager::DoCopyDBFromRam( TInt aIndex )

    {

#ifdef __RAMDISK_PERF_ENABLE

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

    DatabaseHandle& database = iDatabaseHandles[aIndex];

    //Copy Db from RAM to replace dummy file

    TRAPD(error, ReplaceFileL( *database.iTargetFullFilePath, database.iDummyFilePath));

    MPX_DEBUG2("CMPXDbManager::CopyDBsFromRam RAMDisk copied over dummy, error=%d", error);

    // done with RAM DB (whether copying succeeded or not) so can delete it

    // can ignore errors since we cannot do anything if this fails

    BaflUtils::DeleteFile(iFs, *database.iTargetFullFilePath);

    MPX_DEBUG1("CMPXDbManager::DoCopyDBsFromRam RAM DB deleted");

    if ( error == KErrNone )

        {

        // Delete old DB on drive

        // Can ignore error: either original does not exist or something is wrong and can't help it

        BaflUtils::DeleteFile(iFs, *database.iOrigFullFilePath);

        MPX_DEBUG1("CMPXDbManager::DoCopyDBsFromRam old DB on drive deleted");

        // Rename dummy file to be original file name

        error = BaflUtils::RenameFile(iFs, database.iDummyFilePath, *database.iOrigFullFilePath);

        MPX_DEBUG2("CMPXDbManager::CopyDBsFromRam dummy file renamed, error=%d", error);

        if ( error )

            {

            // Error renaming dummy file, delete dummy file.

            RemoveDummyFile(aIndex);

            }

        }

    else

        {

        RemoveDummyFile(aIndex);

        MPX_DEBUG1("CMPXDbManager::DoCopyDBsFromRam dummy file deleted");

        }

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

#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 can assume that source file already exists

//  - 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;

	TInt error = dstFile.Open(iFs, aDstName, EFileWrite|EFileWriteDirectIO|EFileShareExclusive);

	if (error == KErrNotFound)

	   {

	   error = dstFile.Create(iFs, aDstName, EFileWrite|EFileWriteDirectIO|EFileShareExclusive);

	   }

	User::LeaveIfError ( error );

    CleanupClosePushL( dstFile );

    // resize destination file

    TInt remainingBytes;

    User::LeaveIfError( srcFile.Size(remainingBytes) );

    User::LeaveIfError( dstFile.SetSize(remainingBytes) );

    // allocate buffer

   	const TInt KBigBufSize = 512 * 1024;

    const TInt KMediumBufSize = 32 * 1024;

    const TInt KSmallBufSize = 4 * 1024;

    HBufC8* bufPtr=HBufC8::New( Min(KBigBufSize, remainingBytes) );

    if (bufPtr==NULL)

        bufPtr=HBufC8::New(KMediumBufSize);

    if (bufPtr==NULL)

        bufPtr=HBufC8::New(KSmallBufSize);

    if (bufPtr == NULL)

        User::Leave(KErrNoMemory);

    CleanupStack::PushL(bufPtr);

    // copy

    TPtr8 copyBuf=bufPtr->Des();

    TInt pos=0;

    while( remainingBytes > 0 )

        {

        TInt s = Min( remainingBytes, copyBuf.MaxSize() );