/*

* 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 "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:  Harvester database manager

*

*/

#include <e32base.h>

#ifdef RD_MULTIPLE_DRIVE

#include <pathinfo.h>

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#ifdef __RAMDISK_PERF_ENABLE

#include <centralrepository.h>

#include <mpxharvestercrkeys.h>

#include "mpxdbcommon.h"

#endif //__RAMDISK_PERF_ENABLE

#include <mpxlog.h>

#include "mpxharvesterdbmanager.h"

#include "mpxharvesterdb.h"

#include "mpxharvesterdbtable.h"

// CONSTANTS

#ifdef __RAMDISK_PERF_ENABLE

_LIT( KHarvesterDummyDBName, "harvesterDummy.dat" );

const TInt64 KMPMegaByte = 1048576;

const TInt64 KMPEstimatedSongInBytes = KMPMegaByte * 2; 

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

//const TInt KUpdateDBCount = 200;

const TInt KMPMinimumRAMSizeToRun = 6 * KMPMegaByte;

#endif //__RAMDISK_PERF_ENABLE

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

// C++ Constructor

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

//

CMPXHarvesterDatabaseManager::CMPXHarvesterDatabaseManager( RFs& aFs ):

        iFs( aFs )

#ifdef __RAMDISK_PERF_ENABLE

        ,iRAMDiskPerfEnabled(EFalse),

        iMaximumAllowedRAMDiskSpaceToCopy(0),

        //iUpdateCount(0),

        iMtpMode(EFalse)

        //iMtpAddCount(0)

#endif //__RAMDISK_PERF_ENABLE

    {

    }

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

// 2nd Phase Constructor

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

//

void CMPXHarvesterDatabaseManager::ConstructL()

    {

    MPX_FUNC("CMPXHarvesterDatabaseManager::ConstructL");

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

#ifdef __RAMDISK_PERF_ENABLE

    TInt temp;

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

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::ConstructL got repository");        

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

    iRAMDiskPerfEnabled = temp;

    MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL KMpxHarvesterEnableRamDisk %d", iRAMDiskPerfEnabled);        

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

    iMaximumAllowedRAMDiskSpaceToCopy = temp * KMPMegaByte;

    MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL KMpxHarvesterMaxAllowedRamDiskSpace %Lu", iMaximumAllowedRAMDiskSpaceToCopy);        

    CleanupStack::PopAndDestroy(repository);

    if ( iRAMDiskPerfEnabled )

        {

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

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

        if ( GetRAMDiskPath() != KErrNone )

            {

            // Error finding ram drive, disable ram disk

            iRAMDiskPerfEnabled = EFalse;

            }

        }

    else

        {

        MPX_DEBUG2("CMPXHarvesterDatabaseManager::ConstructL RAMDisk performance is NOT enabled iRAMDiskPerfEnabled=%d", iRAMDiskPerfEnabled);

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

        }

#endif //__RAMDISK_PERF_ENABLE

    }

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

// Two-Phased Constructor

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

//

CMPXHarvesterDatabaseManager* CMPXHarvesterDatabaseManager::NewL( RFs& aFs )

    {

    CMPXHarvesterDatabaseManager* self =

                             new( ELeave ) CMPXHarvesterDatabaseManager( aFs );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Destructor

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

//

CMPXHarvesterDatabaseManager::~CMPXHarvesterDatabaseManager()

    {

#ifdef __RAMDISK_PERF_ENABLE

    TInt count(iDatabases.Count());

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

        {

        RemoveDummyFile(i);

        }

#endif // __RAMDISK_PERF_ENABLE

    iDatabases.ResetAndDestroy();

    iDatabases.Close();

    iDBSession.Close();

    }

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

// CMPXHarvesterDatabaseManager::OpenAllDatabasesL

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

//

TInt CMPXHarvesterDatabaseManager::OpenAllDatabasesL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL <---");

    TInt rtn (KErrNone);

    // Open drives we are interested in.

    //

#ifdef RD_MULTIPLE_DRIVE

    TDriveList driveList;

    TInt driveCount(0);

    User::LeaveIfError( DriveInfo::GetUserVisibleDrives(

           iFs, driveList, driveCount ) );

    TInt check(KErrNone);

    for( TInt driveNum = EDriveA; driveNum <= EDriveZ; driveNum++ )

        {

        if (driveList[driveNum] && !IsRemoteDrive(static_cast<TDriveNumber>(driveNum)))

            {

            TFileName drivePath;

            User::LeaveIfError(

                PathInfo::GetRootPath( drivePath, driveNum ) );

            MPX_DEBUG2("CMPXHarvesterDatabaseManager::OpenAllDatabasesL: opening database in %S drive",

                &drivePath);

            TRAP( check, GetDatabaseL(static_cast<TDriveNumber>(driveNum)) );

            if( check == KErrNotFound )

                {

                CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL(

                    static_cast<TDriveNumber>(driveNum), iFs );

                CleanupStack::PushL( dB );

                TRAPD(openError, rtn |= dB->OpenL() );  //lint !e665

                if(openError == KErrNone)

                    {

                     iDatabases.AppendL( dB );

                     CleanupStack::Pop( dB );

                    }

                else

                    {

                    CleanupStack::PopAndDestroy( dB );

                    }

                }

            else if( check == KErrNone )

                {

                TRAPD(openError, GetDatabaseL(static_cast<TDriveNumber>(driveNum)).OpenL() );

                if(openError != KErrNone)

                    {

                    TRAP_IGNORE( RemoveDatabaseL(static_cast<TDriveNumber>(driveNum)));

                    }

                }

            }

        }

#else

    TInt check(KErrNone);

    TRAP( check, GetDatabaseL(EDriveC) );

    if( check == KErrNotFound )

        {

        CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL( EDriveC, iFs );

        CleanupStack::PushL( dB );

        iDatabases.AppendL( dB );

        CleanupStack::Pop( dB );

        TRAP_IGNORE( rtn = dB->OpenL() ); //lint !e665

        }

    else if( check == KErrNone )

        {

        TRAPD(openError, GetDatabaseL(EDriveC).OpenL() );

        if(openError != KErrNone)

            {

            TRAP_IGNORE( RemoveDatabaseL(EDriveC));

            }

        }

    TRAP( check, GetDatabaseL(EDriveE) );  //lint !e961

    if( check == KErrNotFound )

        {

        CMPXHarvesterDB* dB = CMPXHarvesterDB::NewL( EDriveE, iFs );

        CleanupStack::PushL( dB );

        TRAPD(openError, rtn |= dB->OpenL() );  //lint !e665

        if(openError == KErrNone)

            {

             iDatabases.AppendL( dB );

             CleanupStack::Pop( dB );

            }

        else

            {

            CleanupStack::PopAndDestroy( dB );

            }

        }

    else if( check == KErrNone )

        {

        TRAPD(openError,GetDatabaseL(EDriveE).OpenL() );

        if(openError != KErrNone)

            {

            TRAP_IGNORE( RemoveDatabaseL(EDriveE));

            }

        }

#endif // RD_MULTIPLE_DRIVE

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenAllDatabasesL --->");  //lint !e961

    return rtn;

    }

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

// CMPXHarvesterDatabaseManager::OpenDatabaseL

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

//

void CMPXHarvesterDatabaseManager::OpenDatabaseL( TDriveNumber aDrive )

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL <---");

    // Re-open a specific database

    //

    if (!IsRemoteDrive(aDrive))

        {

        TInt count( iDatabases.Count() );

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

            {

            CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

            if( db->GetDbDrive() == aDrive )

                {

                db->OpenL();

                break;

                }

            }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::OpenDatabaseL --->");

    }

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

// CMPXHarvesterDatabaseManager::CloseAllDatabase

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

//

void CMPXHarvesterDatabaseManager::CloseAllDatabase()

    {

    // Close all databases for shutdown

    iDatabases.ResetAndDestroy();

    }

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

// CMPXHarvesterDatabaseManager::CloseDatabase

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

//

void CMPXHarvesterDatabaseManager::CloseDatabase( TDriveNumber aDrive )

    {

     if (!IsRemoteDrive(aDrive))

        {

        MPX_DEBUG2("CMPXHarvesterDatabaseManager::CloseDatabase drive %d <---", aDrive );

        TInt count = iDatabases.Count();

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

            {

            CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

            if ( db->GetDbDrive() == aDrive)

                {

                db->Close();

                break;

                }

            }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::CloseDatabase --->");

    }

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

// CMPXHarvesterDatabaseManager::GetDatabase

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

//

CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TDriveNumber aDrive )

    {

    CMPXHarvesterDB* db( NULL );

    // Find the database

    TInt count = iDatabases.Count();

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

        {

        CMPXHarvesterDB* tmp = (CMPXHarvesterDB*) iDatabases[i];

        if( tmp->GetDbDrive() == aDrive )

            {

            db = tmp;

            break;

            }

        }

    // Not found, so we leave

    if( db == NULL )

        {

        User::Leave( KErrNotFound );

        }

    return *db;

    }

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

// CMPXHarvesterDatabaseManager::RemoveDatabase

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

//

void CMPXHarvesterDatabaseManager::RemoveDatabaseL( TDriveNumber aDrive )

    {

    TBool bFound(EFalse);

    // Find the database

    TInt count = iDatabases.Count();

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

        {

        if((iDatabases[index]!=NULL) && ( iDatabases[index]->GetDbDrive() == aDrive ))

            {

            bFound = ETrue;

            delete iDatabases[index];

            iDatabases.Remove(index);

            break;

            }

        }

    // Not found, so we leave

    if( !bFound )

        {

        User::Leave( KErrNotFound );

        }

    }

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

// CMPXHarvesterDatabaseManager::Count

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

//

TInt CMPXHarvesterDatabaseManager::Count()

    {

    return iDatabases.Count();

    }

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

// CMPXHarvesterDatabaseManager::GetDatabaseL

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

//

CMPXHarvesterDB& CMPXHarvesterDatabaseManager::GetDatabaseL( TInt aDb )

    {

    if( aDb > iDatabases.Count() )

        {

        User::Leave(KErrNotFound/*KErrArgument*/);

        }

    return *iDatabases[aDb];

    }

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

// CMPXHarvesterDatabaseManager::RecreateDatabase

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

//

void CMPXHarvesterDatabaseManager::RecreateDatabases()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::RecreateDatabases <--");

    TInt count( iDatabases.Count() );

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

        {

        // Close db, delete and recreate

        //

        MPX_DEBUG2("RecreateDatabasesL() -- %i", i);

        CMPXHarvesterDB* cur = (CMPXHarvesterDB*)iDatabases[i];

        cur->Close();

        cur->DeleteDatabase();

        // trap leave just in case 1 db had err

        //

        TRAP_IGNORE( cur->OpenL() );

        }

    }

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

// CMPXHarvesterDatabaseManager::IsRemoteDrive

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

//

TBool CMPXHarvesterDatabaseManager::IsRemoteDrive(TDriveNumber aDrive)

    {

    TDriveInfo driveInfo;

    TBool isRemoteDrive(EFalse);

    if (iFs.Drive(driveInfo, aDrive) == KErrNone)

        {

        isRemoteDrive = driveInfo.iDriveAtt & KDriveAttRemote;

        }

    return isRemoteDrive;

    }

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

// CMPXHarvesterDatabaseManager::BeginL

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

// 

void CMPXHarvesterDatabaseManager::BeginL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::BeginL <--");

    TInt count( iDatabases.Count() );

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

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        if(!db->InTransaction())

             {

        TRAPD(err, db->BeginL());

        User::LeaveIfError(err);

             }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::BeginL -->");

    }

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

// CMPXHarvesterDatabaseManager::CommitL

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

//

void CMPXHarvesterDatabaseManager::CommitL()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::CommitL <--");

    TInt count( iDatabases.Count() );

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

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        // commit only on databases that are in transaction

        if(db->InTransaction())

            {

            TRAPD(err, db->CommitL());

            User::LeaveIfError(err);

            }

        }

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::CommitL -->");

    }

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

// CMPXHarvesterDatabaseManager::Rollback

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

//

void CMPXHarvesterDatabaseManager::Rollback()

    {

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::Rollback <--");

    TInt count( iDatabases.Count() );

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

        {

        CMPXHarvesterDB* db = (CMPXHarvesterDB*) iDatabases[i];

        // rollback only on databases that are in transaction

        if(db->InTransaction())

            {

            db->Rollback();

            }

        }      

    MPX_DEBUG1("CMPXHarvesterDatabaseManager::Rollback -->");

    }

#ifdef __RAMDISK_PERF_ENABLE

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

// CMPXHarvesterDatabaseManager::CopyDBsToRamL

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

//

void CMPXHarvesterDatabaseManager::CopyDBsToRamL( TBool aMtpMode )

    {

    MPX_FUNC("CMPXHarvesterDatabaseManager::CopyDBsToRamL");

    iMtpMode = aMtpMode;

    //iMtpAddCount = 0;

    //iUpdateCount = 0;

    if( iRAMDiskPerfEnabled )

        {

        // Check for low ram disk space.

        if ( !IsRamDiskSpaceAvailable() || IsRamDiskLow() )

            {

            return;

            }

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

        TInt dbSize=0;

        TInt err = GetTotalDatabasesSize(dbSize, EFalse);

        if ( err || (dbSize > iMaximumAllowedRAMDiskSpaceToCopy) )

            {

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

            return;

            }

        TInt count(iDatabases.Count());

        MPX_DEBUG2("CMPXHarvesterDatabaseManager::CopyDBsToRamL() iDatabaseHandles.Count()=%d", count);

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

            {

            TDriveUnit drive( iDatabases[i]->GetDbDrive() );

            // Don't copy db on C drive.

            if ( (TInt)drive == EDriveC )

                {

                MPX_DEBUG1("CMPXHarvesterDatabaseManager::CopyDBsToRamL() Drive C: skipped.");