/*
* 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
#include <mpxlog.h>
#include "mpxharvesterdbmanager.h"
#include "mpxharvesterdb.h"
#include "mpxharvesterdbtable.h"

// ---------------------------------------------------------------------------
// C++ Constructor
// ---------------------------------------------------------------------------
//
CMPXHarvesterDatabaseManager::CMPXHarvesterDatabaseManager( RFs& aFs )
                                                                  : iFs( aFs )
    {

    }


// ---------------------------------------------------------------------------
// 2nd Phase Constructor
// ---------------------------------------------------------------------------
//
void CMPXHarvesterDatabaseManager::ConstructL()
    {
    User::LeaveIfError( iDBSession.Connect() );
    }


// ---------------------------------------------------------------------------
// 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()
    {
    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 -->");
    }

// END OF FILE