/*
* 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 graveyard cleaner  
*
*/



// ----------------------------------------------------------------------------
// INCLUDE FILES
// ----------------------------------------------------------------------------
//
#include "CMRUtilsGraveyardCleaner.h"
#include "CMRUtilsCalDbBase.h"
#include <ct/RCPointerArray.h>
#include <CalIterator.h>
#include <CalEntryView.h>

// CONSTANTS
/// Unnamed namespace for local definitions
namespace {

enum TPanicCode
    {
    EUnexpectedState = 1,
    ENullUid
    };

_LIT( KPanicMsg, "CMRUtilsGraveyardCleaner" );

void Panic( TPanicCode aReason )
    {
    User::Panic( KPanicMsg, aReason );
    }
    
}  // namespace

// ----------------------------------------------------------------------------
// MEMBER FUNCTIONS
// ----------------------------------------------------------------------------
//

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::NewL
// ----------------------------------------------------------------------------
//
CMRUtilsGraveyardCleaner* CMRUtilsGraveyardCleaner::NewL(
    const CMRUtilsCalDbBase& aNormalDb,
    CMRUtilsCalDbBase& aTombsDb )
	{
	CMRUtilsGraveyardCleaner* self =
	    new( ELeave ) CMRUtilsGraveyardCleaner( aNormalDb, aTombsDb );
	CleanupStack::PushL( self );
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::CMRUtilsGraveyardCleaner
//
// Constructor.
// ----------------------------------------------------------------------------
//
CMRUtilsGraveyardCleaner::CMRUtilsGraveyardCleaner(
    const CMRUtilsCalDbBase& aNormalDb,
    CMRUtilsCalDbBase& aTombsDb )
    : iNormalDb( aNormalDb),
      iTombsDb( aTombsDb ),
      iState( ENotActive ) 
    {
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::~CMRUtilsGraveyardCleaner
//
// Destructor.
// ----------------------------------------------------------------------------
//        
CMRUtilsGraveyardCleaner::~CMRUtilsGraveyardCleaner()
    {
    delete iIdleCleaner; // also cancels ongoing cleanup
    delete iTombsEntryIterator;
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::ConstructL
// ----------------------------------------------------------------------------
//    
void CMRUtilsGraveyardCleaner::ConstructL()
    {
    iIdleCleaner = CIdle::NewL( CActive::EPriorityIdle );
    // It is certain that at this point iTombsDb returns valid session pointer
    iTombsEntryIterator = CCalIter::NewL( *( iTombsDb.Session() ) );
    }

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::ConstructL
// ----------------------------------------------------------------------------
//    
void CMRUtilsGraveyardCleaner::StartIdleCleanupL(
    TTime aTimeLimitUtc )
    {    
    // basically latter check is unnecessary, just double checking
    if ( iIdleCleaner->IsActive() || iState != ENotActive )
        {
        User::Leave( KErrInUse );
        }
        
    iTimeLimitUtc = aTimeLimitUtc;
    iCurrentEntryUid.Set( iTombsEntryIterator->FirstL() );
    if ( iCurrentEntryUid != KNullDesC8 )
        {        
        iState = EResurrectedItemsCleanup;        
        iIdleCleaner->Start( TCallBack( StepL, this ) );
        }
    }

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::CurrentStateL
// ----------------------------------------------------------------------------
//   
CMRUtilsGraveyardCleaner::TCleanerState
CMRUtilsGraveyardCleaner::CurrentStateL() const
    {
    return iState;
    }

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::StepL
// ----------------------------------------------------------------------------
//   
TInt CMRUtilsGraveyardCleaner::StepL( TAny* aCleaner )
    {
    TInt retVal( 0 );
    CMRUtilsGraveyardCleaner* thisCleaner =
        static_cast<CMRUtilsGraveyardCleaner*>( aCleaner );
    TRAPD( err, retVal = thisCleaner->DoStepL() );
    if ( err != KErrNone )
        {        
        // Errors are handled just by stopping cleanup,
        // maybe better luck next time
        thisCleaner->iState = ENotActive;
        User::Leave( err );
        }
    return retVal;
    }
  
// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::DoStepL
// ----------------------------------------------------------------------------
//        
TInt CMRUtilsGraveyardCleaner::DoStepL()
    {
    TInt retVal( 0 );
    switch ( iState )
        {
        case EResurrectedItemsCleanup:
            {
            CleanupIfResurrectedL( iCurrentEntryUid );
            
            // step iterator
            iCurrentEntryUid.Set( iTombsEntryIterator->NextL() );
            if ( iCurrentEntryUid == KNullDesC8 )
                { // EOF, proceed to time limit cleanup phase
                iState = ETimeLimitCleanup;
                }
            retVal = 1; // clenup is not finished yet
            break;
            }
        case ETimeLimitCleanup:
            {
            if ( iTimeLimitUtc == Time::NullTTime() )
                {
                iState = ENotActive;
                }
            else
                {
                TCalTime startTime;
                startTime.SetTimeUtcL( TCalTime::MinTime() );
                TCalTime endTime;                
                endTime.SetTimeUtcL( iTimeLimitUtc );                
                CalCommon::TCalTimeRange timeRange( startTime, endTime );
                
                // TombsDb surely has entry view when status is 'available'
                iTombsDb.EntryView()->DeleteL( timeRange, 
                                               CalCommon::EIncludeAppts,
                                               *this );
                // CIdle operation is now finished but entry view continues
                // asynchronously with time range cleanup
                }
            retVal = 0;
            break;
            }
        default:
            {
            Panic( EUnexpectedState );
            break;
            }                                    
        }
    return retVal;
    }

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::CleanupIfResurrectedL
// ----------------------------------------------------------------------------
//
void CMRUtilsGraveyardCleaner::CleanupIfResurrectedL( const TDesC8& aUid )
    {
    __ASSERT_DEBUG( aUid.Length() > 0, Panic( ENullUid ) );

    RCPointerArray<CCalEntry> arrayNormal;
    CleanupClosePushL( arrayNormal ); 
    RCPointerArray<CCalEntry> arrayTombs;
    CleanupClosePushL( arrayTombs );     

    // Fetch parent and child entries:    
    iNormalDb.EntryView()->FetchL( aUid, arrayNormal );
    iTombsDb.EntryView()->FetchL( aUid, arrayTombs );

    TInt normalCount( arrayNormal.Count() );        
    TInt tombsCount( arrayTombs.Count() );
    TInt numChildrenCleaned( 0 );
    
    if ( tombsCount > 0 && normalCount > 0 )
        { // tombs found, and at least one of them may have been resurrected
        
        // First go through child entries:
            
        for ( TInt i( 1 ); i < tombsCount; ++i )
            {
            for ( TInt j( 1 ); j < normalCount; ++j )
                {
                if ( CMRUtilsCalDbBase::Compare( *( arrayTombs[i] ),
                                                 *( arrayNormal[j] ) ) == 0 )
                    { // entry was found in normal db -> has been resurrected
                    iTombsDb.EntryView()->DeleteL( *( arrayTombs[i] ) );
                    numChildrenCleaned++;
                    break;
                    }
                }
            }
            
        // If all children tombs were deleted we can also check the parent tomb:
        
        if ( numChildrenCleaned == tombsCount-1 )
            {
            // This "if" is actually only relevant when parent doesn't have any
            // children:
            if ( CMRUtilsCalDbBase::Compare( *( arrayTombs[0] ),
                                             *( arrayNormal[0] ) ) == 0 )
                {
                // For some reason after deleting the children the agenda model
                // can't find parent entry from db, we must re-fetch it first!
                arrayTombs.ResetAndDestroy();
                iTombsDb.EntryView()->FetchL( aUid, arrayTombs );
                
                iTombsDb.EntryView()->DeleteL( *( arrayTombs[0] ) );
                }
            }
        }
                     
    CleanupStack::PopAndDestroy( 2 ); // arrayTombs, arrayNormal
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::Progress
// ----------------------------------------------------------------------------
//
void CMRUtilsGraveyardCleaner::Progress( TInt /*aPercentageCompleted*/ )
    {
    // Not interested in progress
    }
    
// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::NotifyProgress
// ----------------------------------------------------------------------------
//
TBool CMRUtilsGraveyardCleaner::NotifyProgress()
    {
    // Not interested in progress
    return EFalse;
    }

// ----------------------------------------------------------------------------
// CMRUtilsGraveyardCleaner::Completed
// ----------------------------------------------------------------------------
//
void CMRUtilsGraveyardCleaner::Completed( TInt /*aError*/ )
    {
    // Not interested in error code either
    iState = ENotActive;
    }

// End of file