// Copyright (c) 1997-2009 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:

//

#include "agsasyncdelete.h"

#include "agsfilemanager.h"

#include "agmentry.h"

#include "agsentrymodel.h"

#include "agmrptdef.h"

#include "agmutil.h"

#include "agssess.h"

#include "agmdebug.h"

const TUint KTidyCallbackRate = 24;

const TInt KTidyArrayGranularity = 16;

/**

Used to sort a list of TAgnEntryIds by their stream id component - used when tidying

*/

TInt CCalAsyncDelete::TStreamIdKey::Compare(TInt aLeft,TInt aRight) const

	{

	TUint32 left = static_cast<TAgnEntryId*>(At(aLeft))->StreamId().Value();

	TUint32 right = static_cast<TAgnEntryId*>(At(aRight))->StreamId().Value();

	TInt r = -1;

	if (left == right)

		{

		r=0;

		}

	else if (left > right)

		{

		r=1;

		}

	return (r);

	}

CCalAsyncDelete::CCalAsyncDelete(CAgnEntryModel& aModel, TAgnChangeFilter& aChangeFilter, CAgnSimpleEntryTable& aEntryTable)

	:iModel(aModel), iChangeFilter(aChangeFilter), iEntryTable(aEntryTable)

	{

	}

void CCalAsyncDelete::ConstructL()

	{

	iAlreadyTidied = new(ELeave)CArrayFixFlat<TAgnEntryId>(KTidyArrayGranularity);

	iTidyDeleteArray = new(ELeave)CArrayFixFlat<TAgnEntryId>(KTidyArrayGranularity);

	}

CCalAsyncDelete* CCalAsyncDelete::NewL(CAgnEntryModel& aModel, TAgnChangeFilter& aChangeFilter, CAgnSimpleEntryTable& aEntryTable)

	{

	CCalAsyncDelete* self = new(ELeave) CCalAsyncDelete(aModel, aChangeFilter, aEntryTable);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CCalAsyncDelete::~CCalAsyncDelete()

	{

	delete iTidyIter;

	delete iAlreadyTidied;

	delete iTidyDeleteArray;

	}

/**

Determines if an instance of an entry falls within the tidy range.

*/

TBool CCalAsyncDelete::IsEntryValidToTidyL(const CAgnSimpleEntry& aSimpleEntry)

	{

	// non-repeating entries must fall in the time range because otherwise the entry iterator wouldn't find them

	if (aSimpleEntry.RptDef())

		{

		TTime instance;

		if ( ! aSimpleEntry.RptDef()->NudgeNextInstanceL(iTidyStartDate, instance, ETrue))

		    {

            // If the parent is repeating but all its instances are excepted it doesn't mean 

            // that it cannot be deleted. It can if its time range is falling 

            // within the time filter, meaning the parent is safe to tidy as 

            // the child entries are already in the tidy up list.

            if (aSimpleEntry.RptDef()->FirstInstanceL().LocalL() < iTidyStartDate || 

                aSimpleEntry.RptDef()->LastInstanceL().LocalL() > iTidyEndDate)

                {

                return (EFalse);

                }

            else

                {

                return (ETrue);

                }

            }

        if (instance < iTidyStartDate || instance > iTidyEndDate)

            {

            return (EFalse);

            }

        }

    return (ETrue);

    }

/**

Calculate the number of entries to be tidied (so the percentage tidied so far

can be determined) and create and required objects.

@capability WriteUserData

@capability ReadUserData

*/

TBool CCalAsyncDelete::SetUpDeleteL(const TAgnFilter& aFilter, const TTime& aTodaysDate, const TTime& aStartDate, const TTime& aEndDate)

	{

	iTidyStartDate = aStartDate;

	iTidyEndDate = aEndDate;

	iTidyDate = iTidyStartDate;

	#if defined (__CAL_ASYNC_LOGGING__) || (__CAL_VERBOSE_LOGGING__)

		{

		TBuf<KMinTTimeStrLength> tidyEndDateTimeBuf;

		AgmDebug::TTimeStrL(iTidyEndDate, tidyEndDateTimeBuf);

		TBuf<KMinTTimeStrLength> tidyStartDateTimeBuf;

		AgmDebug::TTimeStrL(iTidyStartDate, tidyStartDateTimeBuf);

		AgmDebug::DebugLog("Async Delete: Range From %S To %S", &tidyStartDateTimeBuf, &tidyEndDateTimeBuf);

		}

	#endif

	iNumEntriesToProcess = 0;

	delete iTidyIter;

	iTidyIter = NULL;

	iTidyIter = new(ELeave) TAgnEntryDateIterator(iEntryTable, aTodaysDate, aFilter);

	for (iTidyIter->GotoL(iTidyStartDate); !iTidyIter->AtEnd() && iTidyIter->CurrentKey() <= iTidyEndDate; iTidyIter->NextL())

		{

		if (IsEntryValidToTidyL(iTidyIter->CurrentElement()))

			{

			++iNumEntriesToProcess;

			}

		}

	if (!iNumEntriesToProcess)

		{ // there are no entries to tidy that match the date/filter criteria

		return (EFalse); 

		}

	iNumEntriesProcessed = 0;

	return (ETrue);

	}

TBool CCalAsyncDelete::CheckDateIteratorEnd() const

	{

	return ( ! iTidyIter->AtEnd() && iTidyIter->CurrentKey() <= iTidyEndDate);

	}

/**

Tidy the agenda model and return the progress as a percentage of the number of entries tidied so far.

Returns 0 when the tidy has completed.

The callback frequency and percentage completed are based on the number of entries tidied so far out

of the total number of entreis that match the tidy filter and date range. But as the iterator may be

position half-way through the entries for a day when a callback is due to be made then its necessary

to continue processing till the end of that day before the callback is made - this is so that next time

round the same entries aren't processed twice.

@capability WriteUserData

@capability ReadUserData

*/

TInt CCalAsyncDelete::DoDeleteStepL()

	{

	iTidyIter->GotoL(iTidyDate);	

	TInt pos = 0;

	TKeyArrayFix alreadyTidiedKey(0, ECmpTUint32);

	while(CheckDateIteratorEnd())

		{

		const CAgnSimpleEntry& simpleEntry = iTidyIter->CurrentElement();

		if (IsEntryValidToTidyL(simpleEntry))

			{

			TBool alreadyTidied = EFalse;

			// If the entry is repeating or if it spans more than one instant then the iterator may return the

			// same entry more than once (due to the fact that the call backs interrupt the sequence and the

			// iterator is reset on each chunk of processing) so add then to an array to prevent this

			if ( simpleEntry.RptDef() || simpleEntry.StartTime() != simpleEntry.EndTime())

				{

				if (iAlreadyTidied->Find(simpleEntry.EntryId(), alreadyTidiedKey, pos) == 0)

					{

					alreadyTidied = ETrue;

					}

				else

					{

					iAlreadyTidied->AppendL(simpleEntry.EntryId());

					}

				}

			if ( ! alreadyTidied)

				{

				TidyEntryL(simpleEntry);

				if ((++iNumEntriesProcessed % KTidyCallbackRate)==0)

					{

					DeleteTidiedEntriesL();

					TInt percentage = (iNumEntriesProcessed * KAgnPercentageComplete) / iNumEntriesToProcess;

					return (percentage < 1 ? 1 : percentage);

					}

				__ASSERT_DEBUG(iNumEntriesProcessed <= iNumEntriesToProcess, Panic(EAgmErrCorruptDelete));

				}

			}

		iTidyIter->NextL();	

		}

	DeleteTidiedEntriesL();

	return KAgnPercentageComplete;

	}

/**

Delete entries whose id's have been placed in iTidyDeleteArray during the tidying process

@capability WriteUserData

@capability ReadUserData

*/

void CCalAsyncDelete::DeleteTidiedEntriesL()

	{

	if (iTidyDeleteArray && iTidyDeleteArray->Count())

		{

		// sort the entries in the tidy array by their entry ID (and therefore by their stream)

		// this ensures entries in the same stream will be deleted together

		TStreamIdKey key;

		iTidyDeleteArray->Sort(key);

		const TInt KDeleteArrayCount = iTidyDeleteArray->Count();

		for (TInt ii = 0; ii < KDeleteArrayCount; ++ii)

			{

			CAgnEntry* entry = iModel.FetchEntryL((*iTidyDeleteArray)[ii]);

			if (entry)

				{

				CleanupStack::PushL(entry);

				iModel.DeleteEntryL(*entry, ETrue, NULL);

				CleanupStack::PopAndDestroy(entry);

				}

			}

		iModel.ResetDeleteRollbackArray();

		iTidyDeleteArray->Reset();

		iModel.FlushL();

		}

	}

/**

Tidies (i.e. deletes) the entry identified by aSimpleEntry from the agenda if its eligible according to 

its dates. 

If it is non-repeating then for it to be tidied its instance date must fall within iTidyStartDate and

iTidyEndDate. 

If it is repeating then both its repeat start and until dates must fall within the range. 

If it is an undated todo then it would not have been selected by the iterator if today does not fall within the tidy

range hence it can be added without further checks.

*/

void CCalAsyncDelete::TidyEntryL(const CAgnSimpleEntry& aSimpleEntry)

	{

	CAgnEntry* entry = iModel.FetchEntryL(aSimpleEntry.EntryId());

	if (entry == NULL)

		{

		// already deleted

		return;

		}

	CleanupStack::PushL(entry);

	TBool todelete = EFalse;

	if(entry->GsDataType() == CGsData::EParent)

		{

		// Only parents need to be tidied

		todelete = FallInTimeRangeL(aSimpleEntry);

		// If this Entry is a parent and it has children

		if (todelete)

			{

			//Find out whether all children fall in the time range to tidy

			const RArray<TGsChildRefData>& KChildIds = entry->ChildIds();

			const TInt KCount = KChildIds.Count();

			// Check each child to see if they are all fall in the date range

			for (TInt i = 0; i < KCount && todelete; ++i)

				{

				const CAgnSimpleEntry* KChildEntry = iModel.GetSimpleEntryFromIndexes(KChildIds[i].ChildId());

				if(KChildEntry != NULL)

				    {

                    todelete = FallInTimeRangeL(*KChildEntry);

				    }

				}

			}

	#if defined (__CAL_ENTRY_LOGGING__) || (__CAL_VERBOSE_LOGGING__)

		if(todelete)

			{

			AgmDebug::DebugLog("TidyEntryL: Async - Tidying - Deleting an entry");

			AgmDebug::DebugLogEntryL(*entry,EDumpEntryIDs);

			}

	#endif

		}

	CleanupStack::PopAndDestroy(entry);

	if(todelete)

		{

		iTidyDeleteArray->AppendL(aSimpleEntry.EntryId());

		if(aSimpleEntry.Type() == CCalEntry::ETodo)

			{

			iChangeFilter.SetPubSubChange(TAgnChangeFilter::ETodoChanged);

			}

		else

			{

			iChangeFilter.SetPubSubChange(TAgnChangeFilter::EEventChanged);

			}

		}

	}

TBool CCalAsyncDelete::FallInTimeRangeL(const CAgnSimpleEntry& aSimpleEntry)

	{

	if (aSimpleEntry.RptDef())

		{ 

		TTime firstUnexceptedInstanceDate;

		TTime lastUnexceptedInstanceDate;

		if(!aSimpleEntry.RptDef()->NudgeNextInstanceL(aSimpleEntry.RptDef()->FirstInstanceL().LocalL(), firstUnexceptedInstanceDate, ETrue))

			{

			firstUnexceptedInstanceDate = aSimpleEntry.RptDef()->FirstInstanceL().LocalL(); //we don't want the last date - we want the first date

			}

		if(!aSimpleEntry.RptDef()->NudgePreviousUnexceptedInstanceL(aSimpleEntry.RptDef()->LastInstanceL().LocalL(), lastUnexceptedInstanceDate))

			{

			lastUnexceptedInstanceDate = aSimpleEntry.RptDef()->LastInstanceL().LocalL(); // we don't want the first date - we want the last date

			}

		if ((firstUnexceptedInstanceDate >= iTidyStartDate) && (lastUnexceptedInstanceDate <= iTidyEndDate))

			{

			return ETrue;

			}

		}

	else

		{

		if (aSimpleEntry.Type()==CCalEntry::ETodo)

			{

			// check due date only for Todos

			if (aSimpleEntry.EndTime().LocalL() <= iTidyEndDate && aSimpleEntry.EndTime().LocalL() >= iTidyStartDate)

				{

				return ETrue;

				}

			}

		else

			{

			if (aSimpleEntry.EndTime().LocalL() <= iTidyEndDate && aSimpleEntry.StartTime().LocalL() >= iTidyStartDate)

				{

				return ETrue;

				}

			}

		}

	return EFalse;

	}