// Copyright (c) 2007-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 "calinstanceiteratoruid.h"
#include "calsessionimpl.h"
#include "calinstance.h"
#include "calinstanceimpl.h"
#include "calentryimpl.h"
#include "calclient.h"
#include "agmrptdef.h"
#include "agmentry.h"
#include "agmsimpleentry.h"
#include "calcommonimpl.h"
#include "agmdate.h"

/** Uid instance iterator NewL

@internalComponent
*/
CCalInstanceIteratorUid* CCalInstanceIteratorUid::NewL(const CCalInstanceViewImpl& iInstanceViewImpl, const TDesC8& aGuid, const TCalTime& aStartInstance, TUint8 aShortFileId)
	{
	CCalInstanceIteratorUid* self = new(ELeave) CCalInstanceIteratorUid(iInstanceViewImpl);
	CleanupStack::PushL(self);
	self->ConstructL(aGuid, aStartInstance, aShortFileId);
	CleanupStack::Pop(self);
	return self;
	}

/** Uid instance iterator constructor

@internalComponent
*/
CCalInstanceIteratorUid::CCalInstanceIteratorUid(const CCalInstanceViewImpl& iInstanceViewImpl)
:CCalInstanceIterator(iInstanceViewImpl), iCurrentIndex(-1)
	{
	}

/** Uid instance iterator ConstructL

Fetches all the related entries to the UID and sets the currently indexed time

@internalComponent
*/
void CCalInstanceIteratorUid::ConstructL(const TDesC8& aUid, const TCalTime& aInstanceTime, TCalCollectionId aCollectionId)
	{
	// record the time to use for undated todos
	TTime now;
	now.HomeTime();
	iUndatedTodoTime.SetTimeLocalL(now);
	
	// Fetch all the entries that relate to the instance
	RPointerArray<CAgnSimpleEntry> simpleEntries;
	TCleanSimpleEntryArray cleanSimpleEntryArray(simpleEntries, iInstanceViewImpl.GetServ());
	CleanupStack::PushL(TCleanupItem(CCalInstanceViewImpl::DestroySimpleEntryArray, &cleanSimpleEntryArray));
	RArray<TInt> fileIds;
	iInstanceViewImpl.GetShortFileIdLC(fileIds);//It is in order 
	iInstanceViewImpl.GetServ().FetchSimpleEntriesByGuidL(aUid, simpleEntries, fileIds);
	CleanupStack::PopAndDestroy(&fileIds);
	
	const TInt KEntryCount(simpleEntries.Count());
	
	// There must be entries associated with this UID
	__ASSERT_ALWAYS(KEntryCount != 0, User::Leave(KErrNotFound));
	
	TBool instanceExists(EFalse);
	
	for (TInt i(0) ; i < KEntryCount ; ++i)
		{
		CCalLiteEntry* liteEntry = CCalLiteEntry::NewL(*simpleEntries[0], iInstanceViewImpl.GetServ());
		liteEntry->IncrementRefCount();
		simpleEntries.Remove(0);
		TInt appendError = iCalLiteEntries.Append(liteEntry);	
		if (appendError != KErrNone)
			{
			liteEntry->DecrementRefCount();
			User::Leave(appendError);
			}
		
		if (iInstanceViewImpl.IsValidInstanceL(liteEntry->LiteEntry(), aInstanceTime))
			{//Add the index of the entry which has the same time as aInstanceTime into iEntryWithSameTime
			if(liteEntry->LiteEntry().CollectionId() == aCollectionId)
				{
				instanceExists = ETrue;
				iCurrentIndexTime = aInstanceTime;
				iCurrentIndex = iEntryWithSameTime.Count();
				}
			iEntryWithSameTime.AppendL(i);
			}
		}
	
	__ASSERT_ALWAYS(instanceExists, User::Leave(KErrNotFound));
	CleanupStack::PopAndDestroy(); // simpleEntries
	}

/** UID instance iterator destructor

@internalComponent
*/
CCalInstanceIteratorUid::~CCalInstanceIteratorUid()
	{
	// should use CleanArray of LiteEntries 
	const TInt KEntryCount(iCalLiteEntries.Count());
	for (TInt i(0) ; i < KEntryCount ; ++i)
		{
		iCalLiteEntries[i]->DecrementRefCount(); 
		}
	
	iCalLiteEntries.Close();
	iEntryWithSameTime.Close();
	}

TCalTime CCalInstanceIteratorUid::NonRptEntryInstanceTimeL(const CAgnSimpleEntry& aEntry)
	{	
	// The entry does not have a repeat rule so it is just a single instance
	TCalTime entryInstanceTime;
	if (aEntry.Type() == CCalEntry::ETodo)
		{
		TTime completionDate = aEntry.CompletedDateUtc();
		if (completionDate == Time::NullTTime())
			{
			if (!aEntry.EntryTime().IsSet())
				{
				entryInstanceTime = iUndatedTodoTime;
				}
			else
				{
				entryInstanceTime = CalUtils::TAgnCalendarTimeToTCalTimeL(aEntry.EntryTime());
				}
			}
		else
			{
			if (aEntry.TimeMode() == MAgnCalendarTimeMode::EFloating)
				{
				entryInstanceTime.SetTimeLocalFloatingL(AgnDateTime::ConvertToLocalTimeL(completionDate));
				}
			else
				{
				entryInstanceTime.SetTimeUtcL(completionDate);
				}
			}
		}
	else
		{
		entryInstanceTime = CalUtils::TAgnCalendarTimeToTCalTimeL(aEntry.EntryTime());
		}
	
	return entryInstanceTime;
	}

/** Returns the next instance

Loops through all the entries in the cached entry list and finds
the earliest instance that appears after the current index instance time.

@return The next instance

@internalComponent
*/
CCalInstance* CCalInstanceIteratorUid::NextL()
	{
	CCalInstance* retInstance = NULL;
	TInt numSameTimeEntry = iEntryWithSameTime.Count();
	if(numSameTimeEntry >0 && iCurrentIndex < numSameTimeEntry - 1)
		{
		//If there are entries in iEntryWithSameTime, their instance time is same as the iCurrentIndexTime, we should return this instance. 
		return iInstanceViewImpl.CreateInstanceL(*iCalLiteEntries[iEntryWithSameTime[++iCurrentIndex]], iCurrentIndexTime);
		}
	
	TCalTime bestSoFar;
	bestSoFar.SetTimeUtcL(TCalTime::MaxTime());
	TInt thisAgnSimpleEntryIndex(KErrNotFound);
	
	const TInt KEntryCount(iCalLiteEntries.Count());
	TInt i(0);
	for (; i < KEntryCount ; ++i)
		{
		TCalTime entryNextTime;
		entryNextTime.SetTimeUtcL(TCalTime::MaxTime());
		
		CAgnRptDef* thisEntryRptDef = iCalLiteEntries[i]->LiteEntry().RptDef();
		if (thisEntryRptDef)
			{
			TTime entryNextTimeUtc;
			TBool instanceFound(EFalse);
			TTime fromTimeUtc(iCurrentIndexTime.TimeUtcL() + TTimeIntervalMicroSeconds(1));
			
			do
				{
				// keep looping until we find an unexcepted instance or there are no more instances
				instanceFound = thisEntryRptDef->NudgeNextInstanceUtcL(fromTimeUtc, entryNextTimeUtc);
				fromTimeUtc = entryNextTimeUtc + TTimeIntervalMicroSeconds(1);
				}
			while (instanceFound && !thisEntryRptDef->IsAnUnexceptedInstanceL(AgnDateTime::ConvertToLocalTimeL(entryNextTimeUtc) ) );
			
			if (instanceFound)
				{
				entryNextTime.SetTimeUtcL(entryNextTimeUtc);
				}
			}
		else
			{
			TCalTime entryInstanceTime = NonRptEntryInstanceTimeL(iCalLiteEntries[i]->LiteEntry());
						
			if (entryInstanceTime.TimeUtcL() > iCurrentIndexTime.TimeUtcL())
				{
				// The entry's instance time is after the current index time
				// so it is a valid possible next instance
				entryNextTime = entryInstanceTime;
				}
			}
		
		if (entryNextTime.TimeUtcL() < bestSoFar.TimeUtcL()) 
			{
			// This time is better than best time so far so update the best so far
			bestSoFar = entryNextTime;
			thisAgnSimpleEntryIndex = i;
			iEntryWithSameTime.Reset();
			iCurrentIndex = -1;
			}
		else if (entryNextTime.TimeUtcL() == bestSoFar.TimeUtcL() && entryNextTime.TimeUtcL()!= TCalTime::MaxTime())
			{
			//Store the index of the entry which has the instance time as the "bestSoFar" time
			iEntryWithSameTime.AppendL(i);
			}
		}
	
	
	if (bestSoFar.TimeUtcL() != TCalTime::MaxTime())
		{
		retInstance = iInstanceViewImpl.CreateInstanceL(*iCalLiteEntries[thisAgnSimpleEntryIndex], bestSoFar);
		iCurrentIndexTime = bestSoFar;
		}
	
	return retInstance;
	}

/** Returns the previous instance

Loops through all the entries in the cached entry list and finds
the latest instance that appears before the current index instance time.

@return The previous instance

@internalComponent
*/
CCalInstance* CCalInstanceIteratorUid::PreviousL()
	{
	CCalInstance* retInstance = NULL;
	TInt numOfsameTimeInstance = iEntryWithSameTime.Count();
	if(numOfsameTimeInstance > 0 && iCurrentIndex >= 1)
		{
		// we should return the last instance in the array to make it consistent with NextL which returns the first entry's instance.
		return iInstanceViewImpl.CreateInstanceL(*iCalLiteEntries[iEntryWithSameTime[--iCurrentIndex]], iCurrentIndexTime);
		}

	TCalTime bestSoFar;
	bestSoFar.SetTimeUtcL(TCalTime::MinTime());
	TInt thisAgnSimpleEntryIndex(KErrNotFound);
	
	const TInt KEntryCount(iCalLiteEntries.Count());
	TInt i(0);
	for (; i < KEntryCount ; ++i)
		{
		TCalTime entryPreviousTime;
		entryPreviousTime.SetTimeUtcL(TCalTime::MinTime());
		
		CAgnRptDef* thisEntryRptDef = iCalLiteEntries[i]->LiteEntry().RptDef();
		
		if (thisEntryRptDef)
			{
			TTime entryPreviousTimeUtc(iCurrentIndexTime.TimeUtcL());
			TBool instancefound(EFalse);
			TTime fromTimeUtc;
			
			do
				{
				fromTimeUtc = entryPreviousTimeUtc - TTimeIntervalMicroSeconds(1);
				// keep calling until an unexcepted instance is found or there are no more instances
				instancefound = thisEntryRptDef->NudgePreviousInstanceUtcL(fromTimeUtc, entryPreviousTimeUtc);
				}
			while (instancefound && !thisEntryRptDef->IsAnUnexceptedInstanceL(AgnDateTime::ConvertToLocalTimeL(entryPreviousTimeUtc) ) );
			
			if (instancefound)
				{
				entryPreviousTime.SetTimeUtcL(entryPreviousTimeUtc);
				}
			}
		else
			{
			// The entry does not have a repeat rule so it is just a single instance
			TCalTime entryInstanceTime = NonRptEntryInstanceTimeL(iCalLiteEntries[i]->LiteEntry());
			
			if (entryInstanceTime.TimeUtcL() < iCurrentIndexTime.TimeUtcL())
				{
				// The entry's instance time is before the current index time
				// so it is a valid possible next instance
				entryPreviousTime = entryInstanceTime;
				}
			}
		
		if (entryPreviousTime.TimeUtcL() > bestSoFar.TimeUtcL()) 
			{
			// This time is better than best time so far so update the best so far
			bestSoFar = entryPreviousTime;
			thisAgnSimpleEntryIndex = i;
			iEntryWithSameTime.Reset();
			iCurrentIndex = -1;
			}
		else if (entryPreviousTime.TimeUtcL() == bestSoFar.TimeUtcL() && entryPreviousTime.TimeUtcL()!= TCalTime::MinTime())
			{
			iEntryWithSameTime.AppendL(thisAgnSimpleEntryIndex);
			thisAgnSimpleEntryIndex = i;
			}
		}
	
	if (bestSoFar.TimeUtcL() != TCalTime::MinTime())
		{
		retInstance = iInstanceViewImpl.CreateInstanceL(*iCalLiteEntries[thisAgnSimpleEntryIndex], bestSoFar);
		iCurrentIndexTime = bestSoFar;
		numOfsameTimeInstance = iEntryWithSameTime.Count();
		if(numOfsameTimeInstance>0)
			{
			iCurrentIndex = numOfsameTimeInstance;
			}
		}
		
	return retInstance;
	}

/** To check if there are more instance to be returned by NextL().

Calls NextL() to see if if returns another instance, and then sets the current
indexed instance time back to what it was before the call. 

@return ETrue if there are more instance to be returned by NextL(),
EFalse if there are no more instance, and EFalse if there is a problem
calculating if there are more instance to be returned by NextL().

@internalComponent
*/
TBool CCalInstanceIteratorUid::HasMore() const
	{
	TBool returnValue(EFalse);
	TRAP_IGNORE(returnValue = HasMoreL());
	return returnValue;
	}

TBool CCalInstanceIteratorUid::HasMoreL() const
	{
	TBool returnValue(EFalse);

	//Store the current state
	TCalTime storedCurrentIndex = iCurrentIndexTime;
	TInt storedArrayIndex = iCurrentIndex;
	RArray<TInt> storedArray;
	CleanupClosePushL(storedArray);
	const TInt count = iEntryWithSameTime.Count();
	for(TInt ii=0; ii<count;++ii)
		{
		storedArray.AppendL(iEntryWithSameTime[ii]);
		}

	//Find instances
	CCalInstance* nextInstance = const_cast<CCalInstanceIteratorUid*>(this)->NextL();
	returnValue = (nextInstance != NULL);
	delete nextInstance;

	// restore the state
	const_cast<CCalInstanceIteratorUid*>(this)->iCurrentIndexTime = storedCurrentIndex; 
	iCurrentIndex = storedArrayIndex;//reset index since it could be moved in NextL
	iEntryWithSameTime.Reset();
	const TInt countSortedArray = storedArray.Count();
	for(TInt ii=0; ii<countSortedArray;++ii)
		{
		iEntryWithSameTime.AppendL(storedArray[ii]);
		}

	CleanupStack::PopAndDestroy(&storedArray);

	return returnValue;
	}

/** Instance iterator count

Loops through all the entries in the cached entry list and finds each of the instance counts.
The instance count is the sum of all the entries instances.

@return The sum of the instance counts for all the entries in the cached list. 

@internalComponent
*/
TInt CCalInstanceIteratorUid::Count() const
	{
	TInt returnInstanceCount(0);
	const TInt KEntryCount(iCalLiteEntries.Count());
	for (TInt i(0) ; i < KEntryCount ; ++i)
		{
		CAgnRptDef* rptDef = iCalLiteEntries[i]->LiteEntry().RptDef();
		if (rptDef)
			{
			// This gets all the instances generated by the repeat rule
			TRAPD(error, returnInstanceCount += rptDef->InstanceCountL());
			if (error)
				{
				// an error has occoured whilst calculating the instance count
				// so quit and retrun the error code
				returnInstanceCount = error;
				break;
				}
			
			// Need to take off valid exception dates
			if (rptDef->Exceptions())
				{
				returnInstanceCount -= rptDef->Exceptions()->Count();
				}
			}
		else
			{
			// The entry does not have a repeat rule
			// so it is just a single instance
			++returnInstanceCount;	
			}
		}
	
	return returnInstanceCount;
	}