#ifdef __RAMDISK_PERF_ENABLE

#include <centralrepository.h>

#include <BAUTILS.H>  

#include <mpxinternalcrkeys.h>

#endif //__RAMDISK_PERF_ENABLE

#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

    iFs(aFs), 

    iRAMDiskPerfEnabled(EFalse),

    iMaximumAllowedRAMDiskSpaceToCopy(0),

    iRAMInUse(EFalse)

#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

#ifdef __RAMDISK_PERF_ENABLE

    TInt count(iDatabaseHandles.Count());

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

        {

        RemoveDummyFile(i);

        }    

#endif //__RAMDISK_PERF_ENABLE

    iDatabaseHandles.Close();

        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;

                }

            iDatabaseHandles[i].iUseRAMdb = ETrue;

            TRAPD(err, ret = DoCopyDBToRamL( iDatabaseHandles[i].iDrive, aIsMTPInUse ))

            if ( err != KErrNone )

                {

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

                // remove dymmy file

                RemoveDummyFile(i);

                // try to close database that is opened from RAM disk

                TRAP_IGNORE(CloseDatabaseL( iDatabaseHandles[i].iDrive ));

                iDatabaseHandles[i].iUseRAMdb = EFalse;

                // reopen database from drive not from RAM

                OpenDatabaseL( iDatabaseHandles[i].iDrive );

                continue; // continue to copy for next drive

                }

            if ( !ret )

                {

                iDatabaseHandles[i].iUseRAMdb = EFalse;

                }

            }

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

    iRAMInUse = ETrue;

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

#endif //__RAMDISK_PERF_ENABLE

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

// CMPXDbManager::DoCopyDBsToRamL

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

//

TBool CMPXDbManager::DoCopyDBToRamL( TDriveUnit aDrive, TBool aIsMTPInUse )

    {

#ifdef __RAMDISK_PERF_ENABLE

    MPX_DEBUG2("-->CMPXDbManager::DoCopyDBsToRamL drive=%d", (TInt)aDrive);

    TFileName dst;

    TFileName src;

    dst.Append(iRAMFolder);

    src.Append(aDrive.Name());

    src.Append(KDBFilePath);

    TRAPD( err, BaflUtils::EnsurePathExistsL( iFs, dst ));

    if ( err != KErrNone )

        {

        return EFalse;

        }

    TFileName filename;            

    filename.Format(KSecurePath, User::Identity().iUid, iDbFile); //x:\private\10281e17\[sldfdsf]mpxv2_5.db

    src.Append(filename);

    MPX_DEBUG2("RAMDisk src path=%S", &src);

    TEntry entry;

    iFs.Entry( src, entry );

    if (!BlockDiskSpace( aDrive, entry.iSize, aIsMTPInUse ) )

        {

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

        return EFalse; // continue for next drive

        }

    TBuf<2> d;

    d.Append(aDrive.Name());

    HBufC* temp = HBufC::NewLC(KMaxFileName);

    temp->Des().Append(d.Left(1));

    temp->Des().Append(iDbFile->Des());

    filename.Format(KSecurePath, User::Identity().iUid, temp);

    CleanupStack::PopAndDestroy(temp);

    dst.Append(filename);

    MPX_DEBUG2("RAMDisk dst path=%S", &dst);

    TInt index( GetDatabaseIndex((TInt)aDrive) );

    delete iDatabaseHandles[index].iOrigFullFilePath;

    iDatabaseHandles[index].iOrigFullFilePath = 0;

    delete iDatabaseHandles[index].iTargetFullFilePath;

    iDatabaseHandles[index].iTargetFullFilePath = 0;

    // Save these path so it is convenient to copy back

    iDatabaseHandles[index].iOrigFullFilePath = HBufC::NewL(src.Length());

    iDatabaseHandles[index].iTargetFullFilePath = HBufC::NewL(dst.Length());

    iDatabaseHandles[index].iOrigFullFilePath->Des().Append(src);

    iDatabaseHandles[index].iTargetFullFilePath->Des().Append(dst);

    TRAP(err, CloseDatabaseL(aDrive));

    if ( err != KErrNone )

        {

        MPX_DEBUG2("<--CMPXDbManager::DoCopyDBsToRamL error=%d", err);

        TInt index(GetDatabaseIndex((TInt)aDrive));

        if ( index >= 0 )

            {

            RemoveDummyFile( index );

            }

        return EFalse;

        }

    User::LeaveIfError( BaflUtils::CopyFile(iFs, src, dst ));

    OpenDatabaseL((TInt)aDrive);

    MPX_DEBUG2("RAMDisk Database opened=%d", (TInt)aDrive);

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

    return ETrue;    

#endif //__RAMDISK_PERF_ENABLE

    }

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

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

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

//

EXPORT_C void CMPXDbManager::CopyDBsFromRamL()

    {

#ifdef __RAMDISK_PERF_ENABLE

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

    if( iRAMDiskPerfEnabled )

       {

        TInt transactionCount = iTransactionCount;

        if (iTransactionCount > 0) 

            {

            iTransactionCount = 0;

            DoCommitL();

            }

        TInt count(iDatabaseHandles.Count());

        for (TInt i = 0; i < count && iDatabaseHandles[i].iUseRAMdb; ++i)

            {

            TRAPD(err, DoCopyDBFromRamL(i));

            if ( err != KErrNone )

                {

                MPX_DEBUG2("<--CMPXDbManager::CopyDBsFromRamL error=%d", err);                

                //anyting wrong, delete the temp file and open database from drive

                RemoveDummyFile(i);

                // delete Db on RAM

                User::LeaveIfError( BaflUtils::DeleteFile(iFs, 

                    *iDatabaseHandles[i].iTargetFullFilePath));

                }

            iDatabaseHandles[i].iUseRAMdb = EFalse;

            // open db from drive

            OpenDatabaseL( iDatabaseHandles[i].iDrive );      

            }

        if (transactionCount > 0) 

            {

            DoBeginL();

            iTransactionCount = transactionCount;

            }

        }

    iRAMInUse = EFalse;

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

#endif //__RAMDISK_PERF_ENABLE

    }

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

// CMPXDbManager::DoCopyDBsToRamL

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

//

void CMPXDbManager::DoCopyDBFromRamL( TInt aIndex )

    {

#ifdef __RAMDISK_PERF_ENABLE

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

    MPX_DEBUG2("-->CMPXDbManager::DoCopyDBsFromRamL Drive %d will be closed before copying db from RAM.",

         iDatabaseHandles[aIndex].iDrive);

    CloseDatabaseL(iDatabaseHandles[aIndex].iDrive);            

    // Delete existing DB on drive

    User::LeaveIfError( BaflUtils::DeleteFile(iFs, 

        *iDatabaseHandles[aIndex].iOrigFullFilePath));

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

    // Rename dummy file to be orignal file name

    User::LeaveIfError( BaflUtils::RenameFile(iFs, 

        iDatabaseHandles[aIndex].iDummyFilePath, 

        *iDatabaseHandles[aIndex].iOrigFullFilePath) );

    MPX_DEBUG1("CMPXDbManager::CopyDBsFromRamL RAMDisk renamed.");

    //Copy Db from RAM to replace dummy file

    ReplaceFileL( *iDatabaseHandles[aIndex].iTargetFullFilePath, *iDatabaseHandles[aIndex].iOrigFullFilePath);

    MPX_DEBUG1("CMPXDbManager::CopyDBsFromRamL RAMDisk copied back.");

    // Delete existing DB on RAM

    User::LeaveIfError( BaflUtils::DeleteFile(iFs, *iDatabaseHandles[aIndex].iTargetFullFilePath));

    MPX_DEBUG1("CMPXDbManager::DoCopyDBsFromRamL RAMDisk deleted");

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

#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 files already exist

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

    User::LeaveIfError( dstFile.Open(iFs, aDstName, EFileWrite|EFileWriteDirectIO|EFileShareExclusive) );

    CleanupClosePushL( dstFile );

    // resize destination file

    TInt remainingBytes;

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

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