/*

* Copyright (c) 2005 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: Implementation for meeting request utils calendar    

*              database manager

*/

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

// INCLUDE FILES

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

//

#include "CMRUtilsCalDbMgr.h"

#include "CMRUtilsCalDbNormal.h"

#include "CMRUtilsCalDbTombs.h"

#include "CMRUtilsCmdIterationAO.h"

#include "CMRUtilsGraveyardCleaner.h"

#include "MREntryConsultant.h"

#include "MRHelpers.h"

#include "ICalUILog.h"

#include "CMRUtilsInternal.h"

#include <ct/RCPointerArray.h>

#include <CalSession.h>

#include <CalEntryView.h>

#include <CalInstance.h>

#include <CalInstanceView.h>

#include <CalEntry.h>

#include <CalCommon.h>

#include <CalUser.h>

#include <CalenInterimUtils2.h>

// CONSTANTS

/// Unnamed namespace for local definitions

namespace {

const TInt KUidListGranularity = 10;

enum TPanicCode

    {

    EPanicIllegalFetchParams = 1,

    EPanicAccessedWhenUnavailable,

    EPanicAsyncOpAlreadyExists,

    EPanicIllegalEntryStatus,

    EPanicIllegalResurrect,

    EPanicUnexpectedUidValue

    };

_LIT( KPanicMsg, "CMRUtilsCalDbMgr" );

void Panic( TPanicCode aReason )

    {

    User::Panic( KPanicMsg, aReason );

    }

}  // namespace

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

// MEMBER FUNCTIONS

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

//

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

// CMRUtilsCalDbMgr::NewL

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

//

CMRUtilsCalDbMgr* CMRUtilsCalDbMgr::NewL(

    CCalSession& aCalSession,

    MMRUtilsObserver& aObserver )

	{

	CMRUtilsCalDbMgr* self = new( ELeave ) CMRUtilsCalDbMgr( aCalSession,

	                                                         aObserver );

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

// CMRUtilsCalDbMgr::CMRUtilsCalDbMgr

//

// Constructor.

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

//

CMRUtilsCalDbMgr::CMRUtilsCalDbMgr(

    CCalSession& aCalSession,

    MMRUtilsObserver& aObserver )

    : iCurrentAsyncOp( CMRUtils::ENoOperation ),

      iCalSession( aCalSession ),

      iObserver( aObserver )    

    {    

    }

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

// CMRUtilsCalDbMgr::~CMRUtilsCalDbMgr

//

// Destructor.

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

//        

CMRUtilsCalDbMgr::~CMRUtilsCalDbMgr()

    {

    delete iGraveyardCleaner;

    delete iCmdIterator;

    delete iNormalDb;

    delete iTombsDb;

    }

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

// CMRUtilsCalDbMgr::ConstructL

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

//    

void CMRUtilsCalDbMgr::ConstructL()

    {

    iNormalDb = CMRUtilsCalDbNormal::NewL( iCalSession, *this, *this );

    iTombsDb = CMRUtilsCalDbTombs::NewL( *this, *this );    

    iCmdIterator = CMRUtilsCmdIterationAO::NewL( *this );

    }

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

// CMRUtilsCalDbMgr::HandleCalDbStatus

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

//    

void CMRUtilsCalDbMgr::HandleCalDbStatus(

    const CMRUtilsCalDbBase* /*aNotifier*/,

    MMRUtilsCalDbObserver::TDbStatus aStatus )

    {

    // If there is any change in db status, we must stop cleaning:

    delete iGraveyardCleaner;

    iGraveyardCleaner = NULL;

    if ( aStatus == EReseting )

        { // reset db is ongoing, engine becomes unavailable

        iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotReady );

        }

    else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&

              iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk )

        {

        iObserver.HandleCalEngStatus( MMRUtilsObserver::EAvailable );        

        // Both databases are available so we can start idle cleanup

        // We can ignore the error if it fails, try again next time

        TRAP_IGNORE(

            iGraveyardCleaner =

                CMRUtilsGraveyardCleaner::NewL( *iNormalDb, *iTombsDb );

            iGraveyardCleaner->StartIdleCleanupL( Time::NullTTime() );

            )

        }

    else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&

              iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )

        {

        iObserver.HandleCalEngStatus(

            MMRUtilsObserver::EAvailableWithoutTombs );

        }

    else if ( iNormalDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )

        {

        iObserver.HandleCalEngStatus( MMRUtilsObserver::ENotAvailable );

        }

    // In other cases either db is not yet finished        

    }

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

// CMRUtilsCalDbMgr::Progress

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

//

void CMRUtilsCalDbMgr::Progress( TInt /*aPercentageCompleted*/ )

    {

    // Not interested in progress currently

    }

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

// CMRUtilsCalDbMgr::NotifyProgress

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

//

TBool CMRUtilsCalDbMgr::NotifyProgress()

    {

    // Not interested in progress currently

    return EFalse;

    }

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

// CMRUtilsCalDbMgr::Completed

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

//

void CMRUtilsCalDbMgr::Completed( TInt aError )

    {

    iObserver.HandleOperation( iCurrentAsyncOp, 100, aError );

    iCurrentAsyncOp = CMRUtils::ENoOperation;

    }

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

// CMRUtilsCalDbMgr::NormalDbEntryView

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

//

CCalEntryView* CMRUtilsCalDbMgr::NormalDbEntryView()

    { // NormalDbEntryView will only be called if engine is available

    return iNormalDb->EntryView();

    }

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

// CMRUtilsCalDbMgr::NormalDbInstanceView

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

//

CCalInstanceView* CMRUtilsCalDbMgr::NormalDbInstanceView()

    { // NormalDbInstanceView will only be called if engine is available

    return iNormalDb->InstanceView();

    }

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

// CMRUtilsCalDbMgr::FetchEntriesL

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

//

void CMRUtilsCalDbMgr::FetchEntriesL(

    RPointerArray<CCalEntry>& aCalEntryArray,

    const CalCommon::TCalTimeRange& aTimeRange )

    {

    __ASSERT_DEBUG( aCalEntryArray.Count() == 0,

                    Panic( EPanicIllegalFetchParams ) );

    aCalEntryArray.ResetAndDestroy();

    // caller definitely wants to get full copies -> ETrue as 3rd argument:

    iNormalDb->FetchWithRangeL( aCalEntryArray,

                                aTimeRange,

                                ETrue );    

    }

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

// CMRUtilsCalDbMgr::FetchEntryL

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

//

CCalEntry* CMRUtilsCalDbMgr::FetchEntryL(

    const TDesC8& aUid,

    const TCalTime& aRecurrenceId )

    {

    __ASSERT_DEBUG( aUid.Length() > 0,

                    Panic( EPanicIllegalFetchParams ) );

    RCPointerArray<CCalEntry> tmpFetchArray;

    CleanupClosePushL( tmpFetchArray ); 

    CCalEntry* retVal = NULL;

    TInt index( -1 );

    if ( EntryExistsInDbL( aUid,

                           aRecurrenceId,

                           *iNormalDb,

                           tmpFetchArray,

                           index ) )

        {        

        retVal = tmpFetchArray[index];        

        tmpFetchArray.Remove( index ); // ownership transferred to retVal

        }        

    CleanupStack::PopAndDestroy(); // tmpFetchArray

    return retVal;

    }        

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

// CMRUtilsCalDbMgr::StoreEntryL

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

//          

TInt CMRUtilsCalDbMgr::StoreEntryL(

    CCalEntry& aCalEntry,

    TBool aToNormalDb )

    {

    TInt retVal( KErrNone );   

    CMRUtilsCalDbBase* dbToStore = aToNormalDb ? iNormalDb : iTombsDb;    

    CCalenInterimUtils2::StoreL( *( dbToStore->EntryView() ),

                                 aCalEntry,

                                 ETrue );

    return retVal;

    }        

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

// CMRUtilsCalDbMgr::UpdateEntryL

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

//          

TInt CMRUtilsCalDbMgr::UpdateEntryL( const CCalEntry& aCalEntry )

    {

    RPointerArray<CCalEntry> calEntryTmpArray( 1 ); // entry not own

    CleanupClosePushL( calEntryTmpArray ); 

    calEntryTmpArray.AppendL( &aCalEntry );

    TInt numSuccessfulEntry( 0 );

    // entry view surely exists when status is 'available':

    iNormalDb->EntryView()->UpdateL( calEntryTmpArray, numSuccessfulEntry );

    TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );

    CleanupStack::PopAndDestroy(); // calEntryTmpArray, only close array

    return retVal;    

    }        

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

// CMRUtilsCalDbMgr::DeleteEntryL

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

//          

TInt CMRUtilsCalDbMgr::DeleteEntryL( const TDesC8& aUid )

    {  

    CDesC8ArrayFlat* uidArray = new( ELeave ) CDesC8ArrayFlat( 1 );

    CleanupStack::PushL( uidArray );

    uidArray->AppendL( aUid );

    // entry view surely exists when status is 'available':

    iNormalDb->EntryView()->DeleteL( *uidArray );

    CleanupStack::PopAndDestroy( uidArray );

    return KErrNone;    

    }        

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

// CMRUtilsCalDbMgr::DeleteEntryL

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

//          

TInt CMRUtilsCalDbMgr::DeleteEntryL( const TCalLocalUid& aLocalUid )

    {

    RArray<TCalLocalUid> localUidArray( 1 );

    CleanupClosePushL( localUidArray ); 

    localUidArray.AppendL( aLocalUid );

    TInt numSuccessfulEntry( 0 );

    iNormalDb->EntryView()->DeleteL( localUidArray, numSuccessfulEntry );

    TInt retVal( numSuccessfulEntry == 1 ? KErrNone : KErrGeneral );

    CleanupStack::PopAndDestroy(); // localUidArray

    return retVal;

    }

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

// CMRUtilsCalDbMgr::ResetTombsFileL

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

//          

void CMRUtilsCalDbMgr::ResetTombsFileL()

    {

    iTombsDb->ResetDbL();

    }

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

// CMRUtilsCalDbMgr::DeleteTombstonesL

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

//          

void CMRUtilsCalDbMgr::DeleteTombstonesL(

    const CalCommon::TCalTimeRange& aCalTimeRange )

    {

    __ASSERT_DEBUG( iCurrentAsyncOp == CMRUtils::ENoOperation,

                    Panic( EPanicAsyncOpAlreadyExists ) );

    iTombsDb->EntryView()->DeleteL( aCalTimeRange,

                                    CalCommon::EIncludeAppts,

                                    *this );

    iCurrentAsyncOp = CMRUtilsInternal::EDeleteTombstones;

    }

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

// CMRUtilsCalDbMgr::StoreEntryCondL

// aResurrect can only be ETrue if aCheckOnly is EFalse, i.e. when user is

// really trying to store something.

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

//          

MMRUtilsTombsExt::TMRUtilsDbResult CMRUtilsCalDbMgr::StoreEntryCondL(

    CCalEntry& aCalEntry,

    TBool aResurrect,

    TBool aCheckOnly )

    {    

    RCPointerArray<CCalEntry> tmpFetchArray;

    CleanupClosePushL( tmpFetchArray );

    MMRUtilsTombsExt::TMRUtilsDbResult entryStatus(

        MMRUtilsTombsExt::EUndefined );

    TInt index( -1 );

    // 1. Normal db part, if entry is found in there then tombstones aren't

    //    checked at all:

    if ( EntryExistsInDbL( aCalEntry, *iNormalDb, tmpFetchArray, index ) )

        { // Entry exists in normal db

        entryStatus = EvaluateExistingEntryL( aCalEntry,

                                              *( tmpFetchArray[index] ) );

        if ( entryStatus == MMRUtilsTombsExt::ECheckedValidUpdate &&

             !aCheckOnly ) 

            {

            StoreEntryL( aCalEntry );

            entryStatus = MMRUtilsTombsExt::EStoredUpdate;

            }

        else if ( entryStatus == MMRUtilsTombsExt::EErrorCancelled &&

                  aResurrect ) 

            {

            __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );

            StoreEntryL( aCalEntry );

            entryStatus = MMRUtilsTombsExt::EResurrectedCancelled;

            }            

        // entry can't be new if it exists in the db already:            

        __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidNew,

                        Panic( EPanicIllegalEntryStatus) );                        

        }

    // 2. Tombstone db part (omitted if tombs db unavailable):

    else if ( iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedOk &&

              EntryExistsInDbL( aCalEntry, *iTombsDb, tmpFetchArray, index ) )

        { // Entry has been deleted and is a tombstone now

        entryStatus = EvaluateExistingEntryL( aCalEntry,

                                              *( tmpFetchArray[index] ) );

        if ( entryStatus == MMRUtilsTombsExt::ECheckedValidUpdate &&

             !aCheckOnly )

            { // Older entry exists in tombstone db, our policy is that

              // updates are still accepted

            if ( MREntryConsultant::IsModifyingEntryL( aCalEntry ) &&

                 !OriginatingExistInDbL( aCalEntry ) )

                { // originating not found in normal db, so modifying entry

                  // is "illegal", cannot be saved

                entryStatus = MMRUtilsTombsExt::EErrorRecurrence;

                }

            else

                {                

                StoreEntryL( aCalEntry );

                entryStatus = MMRUtilsTombsExt::EStoredUpdate;

                // Try to delete this particular tombstone, any further

                // tombstone cleanup is taken care by a separate class:         

                TRAP_IGNORE( iTombsDb->EntryView()->DeleteL( aCalEntry ) );

                }

            }

        else if ( entryStatus == MMRUtilsTombsExt::EErrorIdenticalExists )

            { // Identical entry exists in tombstone db

            if ( aResurrect )

                {

                __ASSERT_DEBUG( !aCheckOnly, Panic( EPanicIllegalResurrect ) );

                if ( MREntryConsultant::IsModifyingEntryL( aCalEntry ) &&

                     !OriginatingExistInDbL( aCalEntry ) )

                    { // originating not found in normal db, so modifying entry

                      // is "illegal", cannot be resurrected

                    entryStatus = MMRUtilsTombsExt::EErrorRecurrence;

                    }

                else

                    {                    

                    StoreEntryL( aCalEntry );

                    entryStatus = MMRUtilsTombsExt::EResurrectedDeleted;                                    

                    // Try to delete this particular tombstone, any further

                    // tombstone cleanup is taken care by a separate class:         

                    TRAP_IGNORE( iTombsDb->EntryView()->DeleteL( aCalEntry ) );

                    }

                }

            else

                {                                

                entryStatus = MMRUtilsTombsExt::EErrorHasBeenDeleted;

                }

            }

        // entry can't be new if it exists in the db already:            

        __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidNew,

                        Panic( EPanicIllegalEntryStatus) );                        

        }

    // 3. New entry in this phone:

    else

        { // Completely new entry (or tombstone has disappeared)

        entryStatus = EvaluateNewEntryL( aCalEntry );

        if ( entryStatus == MMRUtilsTombsExt::ECheckedValidNew && !aCheckOnly )

            {

            StoreEntryL( aCalEntry );

            entryStatus = MMRUtilsTombsExt::EStoredNew;

            }

        // entry can't be update if doesn't exist in the db already:        

        __ASSERT_DEBUG( entryStatus != MMRUtilsTombsExt::ECheckedValidUpdate,

                        Panic( EPanicIllegalEntryStatus) );         

        }

    CleanupStack::PopAndDestroy(); // tmpFetchArray

    return entryStatus;        

    }

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

// CMRUtilsCalDbMgr::DeleteEntryCondL

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

//          

void CMRUtilsCalDbMgr::DeleteEntryCondL( const TDesC8& aUid )

    {

    RCPointerArray<CCalEntry> tmpFetchArray;

    CleanupClosePushL( tmpFetchArray );

    // 1. Delete all found entries from normal db:

    iNormalDb->EntryView()->FetchL( aUid, tmpFetchArray );

    DeleteEntryL( aUid );

    // 2. Add them to tombstone db, if this fails then no tombstone gets

    // created, but that isn't a major problem:

    if ( iTombsDb->DbStatus() == MMRUtilsCalDbObserver::EFinishedError )

        { // if tombstone db isn't available then we omit it silently          

        return;

        }

    TInt count( tmpFetchArray.Count() );

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

        {

// TODO: currently child entry uid cannot be read anymore after it has been

// deleted from the db, this might be a bug in CalInterimApi. Check later

// if it works, if doesn't we could e.g. make a copy of each entry before

// deleting it and delete and store one at a time, parent as the last one.

// See also DeleteEntryCondL( const CCalEntry& aCalEntry ) variant below.       

        CCalEntry* tombstone = MRHelpers::CopyEntryLC( *( tmpFetchArray[i] ),

                                                tmpFetchArray[i]->MethodL(),

                                                MRHelpers::ECopySkeleton );

        // store to iTombsDb, parent will be added first (it has index 0):

        // don't care if creating a tombstone would fail

        TRAP_IGNORE( StoreEntryL( *tombstone, EFalse ) );

        CleanupStack::PopAndDestroy( tombstone );        

        }

    CleanupStack::PopAndDestroy(); // tmpFetchArray

    }

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

// CMRUtilsCalDbMgr::DeleteEntryCondL

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

//          

void CMRUtilsCalDbMgr::DeleteEntryCondL( const TCalLocalUid& aLocalUid )

    {

    CCalEntry* entry = iNormalDb->EntryView()->FetchL( aLocalUid );

    if ( entry )

        {

        CleanupStack::PushL( entry );