// Copyright (c) 2005-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 "calclient.h"

#include "agmentry.h"

#include "agmutil.h"

#include "calcommonimpl.h"

#include "calentryimpl.h"

#include <calinstance.h>

#include <calsession.h>

#include "calsessionimpl.h"

#include "agmdebug.h"

#include "agmdate.h"

#include "calinstanceiteratorall.h"

#include "calinstanceiteratoruid.h"

#include "agmallocator.h"

#ifdef SYMBIAN_CALENDAR_ENHANCEDSEARCHANDSORT

#include "calsortedinstanceiterator.h"

#endif

#include <s32strm.h>

#ifdef SYMBIAN_SKIPPED_CALENDAR_ALARMS

#include <asshdalarm.h>

#endif

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <asshdalarmcal.h>

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

CCalInstanceViewImpl* CCalInstanceViewImpl::NewL(CCalSession& aSession, MCalProgressCallBack* aProgressCallBack)

	{

	CCalInstanceViewImpl* self = new (ELeave) CCalInstanceViewImpl(aSession.Impl().Server());

	CleanupStack::PushL(self);

	self->ConstructL(aProgressCallBack, aSession);

	CleanupStack::Pop(self);

	return self;

	}

CCalInstanceViewImpl::CCalInstanceViewImpl(RAgendaServ&	aAgendaServer)

	:iAgendaServer(aAgendaServer)

	{

	}

void CCalInstanceViewImpl::ConstructL(MCalProgressCallBack* aProgressCallBack, CCalSession& aSession)

	{

	iCalSessions.AppendL(&(aSession.Impl()));

	aSession.Impl().IncrementReferenceCount();

	if (aProgressCallBack)

		{

		iCalSessions[0]->AsyncTaskManager().StartBuildIndexL(*aProgressCallBack);	

		}

	else if (! iCalSessions[0]->AsyncTaskManager().IsBusy() || iCalSessions[0]->AsyncTaskManager().BuildingIndex())

		{//If it is not busy or it is building index, we will ask the server to build index. Otherwise, e.g. the server is doing filtering category, we will do nothing because index must have been built already.

		iAgendaServer.WaitUntilLoadedL(iCalSessions[0]->CollectionId());

		}

	}

CCalInstanceViewImpl* CCalInstanceViewImpl::NewL(RPointerArray<CCalSession>& aSessions, MCalProgressCallBack* aProgressCallBack)

	{

	CCalInstanceViewImpl* self = new (ELeave) CCalInstanceViewImpl(aSessions[0]->Impl().Server());

	CleanupStack::PushL(self);

	self->ConstructL(aSessions, aProgressCallBack);

	CleanupStack::Pop(self);

	return self;

	}

void CCalInstanceViewImpl::ConstructL(RPointerArray<CCalSession>& aSessions, MCalProgressCallBack* aProgressCallBack)

	{

	TInt count = aSessions.Count();

	__ASSERT_ALWAYS(count >0, User::Leave(KErrNotFound));

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

		{

		aSessions[i]->Impl().Server();

		__ASSERT_ALWAYS(&(aSessions[i]->Impl().Server())==&iAgendaServer, CalUtils::Panic(EInvalidServerHandle));

		iCalSessions.AppendL(&(aSessions[i]->Impl()));

		iCalSessions[i]->IncrementReferenceCount();

		if (!aProgressCallBack && (! iCalSessions[i]->AsyncTaskManager().IsBusy() || iCalSessions[i]->AsyncTaskManager().BuildingIndex()))

			{

			iAgendaServer.WaitUntilLoadedL(iCalSessions[i]->CollectionId());

			}

		}

	if (aProgressCallBack)

		{

		if(count == 1)

			{

			iCalSessions[0]->AsyncTaskManager().StartBuildIndexL(*aProgressCallBack);

			}

		else

			{

			iCurrentFileToOpen = 0;

			iCalProgressCallBack = aProgressCallBack;

			iCalSessions[iCurrentFileToOpen]->AsyncTaskManager().StartBuildIndexL(*this);

			}

		}

	}

void CCalInstanceViewImpl::Progress(TInt aPercentageCompleted)

	{

	iCalProgressCallBack->Progress((aPercentageCompleted + iCurrentFileToOpen*100)/iCalSessions.Count());

	}

void CCalInstanceViewImpl::Completed(TInt aError)

	{

	//if current file is not the last one, start to build the next file

	//otherwise complete aProgressCallBack  

	if(++iCurrentFileToOpen < iCalSessions.Count() && aError == KErrNone)

		{

		TRAPD(err, iCalSessions[iCurrentFileToOpen]->AsyncTaskManager().StartBuildIndexL(*this));

		if(err!= KErrNone)

			{

			iCalProgressCallBack->Completed(err);

			}

		}

	else

		{

		iCalProgressCallBack->Completed(aError);

		}

	}

TBool CCalInstanceViewImpl::NotifyProgress()

	{

	//get from aProgressCallBack

	return iCalProgressCallBack->NotifyProgress();

	}

CCalSessionImpl& CCalInstanceViewImpl::CalSessionImpl() const

	{//This method is not needed after multiple calendar support. However, we have to provide CCalSessionImpl for BC reason (CCalInstanceIterator::iSessionImpl)

	return *iCalSessions[0];

	}

CCalInstanceViewImpl::~CCalInstanceViewImpl()

	{

	const TInt count = iCalSessions.Count();

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

		{

		if(iCalSessions[ii]->AsyncTaskManager().BuildingIndex())

			{

			iCalSessions[ii]->AsyncTaskManager().CancelAsynTask();

			}

		iCalSessions[ii]->DecrementReferenceCount();

		}

	iCalSessions.Close();

	}

void CCalInstanceViewImpl::FindInstanceL(RPointerArray<CCalInstance>& aInstanceList, 

										 CalCommon::TCalViewFilter aCalViewFilter, 

										 const CalCommon::TCalTimeRange& aTimeRange) const

	{

	CCalInstanceView::TCalSearchParams params(KNullDesC(), CalCommon::EFoldedTextSearch);

	FindInstanceL(aInstanceList, aCalViewFilter, aTimeRange, params);

	}

void CCalInstanceViewImpl::DeleteL(CCalInstance* aInstance, CalCommon::TRecurrenceRange aWhichInstances)

	{

	__ASSERT_ALWAYS(aInstance, CalUtils::Panic(ENullInstanceParameter));

	CAgnEntry* entryToDelete = aInstance->Entry().Impl()->GetFullEntryL();

	if (entryToDelete)

		{

		TAgnCalendarTime instanceTime = CalUtils::TCalTimeToTAgnCalendarTimeL(aInstance->Time());

		DeleteInstanceL(*entryToDelete, instanceTime, aWhichInstances);

		}

	delete aInstance;

	}

void CCalInstanceViewImpl::DeleteInstanceL(CAgnEntry& aEntry, const TAgnCalendarTime& aInstanceTime, CalCommon::TRecurrenceRange aWhichInstances)

	{

	if (aEntry.EntryId().IsNullId() || (aEntry.RptDef() && !aEntry.RptDef()->IsAnInstanceL(aInstanceTime.LocalL())))

		{

		#if defined (__CAL_INSTANCE_LOGGING__) || (__CAL_VERBOSE_LOGGING__)

			{

			if(aEntry.EntryId().IsNullId())

				{

				_DBGLOG_INSTANCE(AgmDebug::DebugLog("Panic: EAgmErrInvalidInstance - Attempting to delete an instance where the entry Id is NULL");)	

				}

			else if (aEntry.RptDef() && !aEntry.RptDef()->IsAnInstanceL(aInstanceTime.LocalL()))

				{

				_DBGLOG_INSTANCE(AgmDebug::DebugLog("Panic: EAgmErrInvalidInstance - Attempting to delete an instance which is NOT part of the repeat definition");)

				TBuf<KMinTTimeStrLength> instTimeBuf;

				AgmDebug::TTimeStrL(aInstanceTime.LocalL(), instTimeBuf);

				_DBGLOG_INSTANCE(AgmDebug::DebugLog("Panic: EAgmErrInvalidInstance - Attempting to delete an instance which is NOT part of the repeat definition. Instance local time = %S", &instTimeBuf);)

				}

			_DBGLOG_BASIC(AgmDebug::DebugLog("Panic: EAgmErrInvalidInstance - Attempting to delete an invalid instance");)

			}

		#endif

		DBG_PANIC(EAgmErrInvalidInstance);

		return;

		}

	TCalLocalUid uniqId = aEntry.LocalUid();

	CAgnRptDef* rptDef = NULL;

	TBool isRepeating = EFalse;

	if (aEntry.RptDef())

		{

		isRepeating = ETrue;

		rptDef = CAgnRptDef::NewL(aEntry);

		CleanupStack::PushL(rptDef);

		rptDef->CopyL(*aEntry.RptDef());

		}

	const TAgnCalendarTime& KStart = aEntry.StartTime();

	const TAgnCalendarTime& KEnd = aEntry.EndTime();

	TRAPD(ret,DoDeleteInstanceL(aEntry, aInstanceTime, aWhichInstances));

	if (ret == KErrNone)

		{

		TRAP(ret, iAgendaServer.CommitL(aEntry.CollectionId()));

		if (ret != KErrNone)

			{

			iAgendaServer.Rollback(aEntry.CollectionId());

			}

		}

	if (ret != KErrNone)

		{

		// restore start date, end date and repeat definition

		aEntry.SetStartAndEndTimeL(KStart, KEnd);

		if (isRepeating)

			{

			aEntry.SetRptDefL(*rptDef);

			CleanupStack::PopAndDestroy();

			}

		User::Leave(ret);

		}

	if (isRepeating)

		CleanupStack::PopAndDestroy();

	}

/*

@capability WriteUserData

@capability ReadUserData

*/

void CCalInstanceViewImpl::DoDeleteInstanceL(CAgnEntry& aEntry, const TAgnCalendarTime& aInstanceTime, CalCommon::TRecurrenceRange aWhichInstances)

	{

	if (aEntry.RptDef())

		{

		switch(aWhichInstances)

			{

		case CalCommon::EThisOnly:

			{

			// if adding exception to the entry would result in all its instances

			// being excepted then delete from the store, otherwise add the exception and 

			// update it in the store

			if ( ! aEntry.HasChildren() && aEntry.RptDef()->Exceptions() && 

				 aEntry.RptDef()->InstanceCountL() == aEntry.RptDef()->Exceptions()->Count()+1)

				{

				iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

				}

			else

				{

				aEntry.RptDef()->AddExceptionL(aInstanceTime);

				iAgendaServer.UpdateEntryL(aEntry, EFalse, aEntry.CollectionId());

				}

			break;

			}

		case CalCommon::EThisAndAll:

			{

			iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

			break;

			}

		case CalCommon::EThisAndFuture:

			{

			TTime previousInstance;

			if ( ! aEntry.RptDef()->NudgePreviousUnexceptedInstanceL(aInstanceTime.LocalL(),previousInstance))

				{

				iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

				}

			else

				{

				TAgnCalendarTime prevInst;

				if (aEntry.TimeMode() == MAgnCalendarTimeMode::EFloating)

					{

					prevInst.SetFloatingL(previousInstance);

					}

				else

					{

					prevInst.SetLocalL(previousInstance);

					}

				if (aEntry.RptDef()->RRule())

					{

					aEntry.RptDef()->SetUntilTime(prevInst);

					}

				aEntry.RptDef()->PruneExceptionsL();

				if (aEntry.RptDef()->InstanceCountL()==1)	 // see if there's just one instance left

					{	

					// if that one instance is an exception then delete the entry 		

					if (aEntry.RptDef()->Exceptions())

						{

						iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

						}

					// otherwise make the entry non-repeating

					else

						{

						aEntry.ClearRepeat();

						iAgendaServer.UpdateEntryL(aEntry, EFalse, aEntry.CollectionId());

						}

					}

				else

					iAgendaServer.UpdateEntryL(aEntry, EFalse, aEntry.CollectionId());

				}

			break;

			}

		case CalCommon::EThisAndPrior: 

			{

			TTime nextInstance;

			if (!aEntry.RptDef()->NudgeNextInstanceL(aInstanceTime.LocalL(),nextInstance, ETrue))

				iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

			else

				{

				aEntry.MoveStartTimeLocalL(nextInstance);

				aEntry.RptDef()->PruneExceptionsL();

				if (aEntry.RptDef()->InstanceCountL()==1)	 // see if there's just one instance left

					{	

					// if that one instance is an exception then delete the entry 		

					if (aEntry.RptDef()->Exceptions())

						{

						iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

						}

					// otherwise make the entry non-repeating

					else

						{

						aEntry.ClearRepeat();

						iAgendaServer.UpdateEntryL(aEntry, EFalse, aEntry.CollectionId());

						}

					}

				else

					iAgendaServer.UpdateEntryL(aEntry, EFalse, aEntry.CollectionId());

				}

			break;

			}

		default: 

			{

			_DBGLOG_BASIC(AgmDebug::DebugLog("Panic: EAgmErrInvalidRecurrenceRange - Invalid Recurrence Range");)

			DBG_PANIC(EAgmErrInvalidRecurrenceRange);

			}

			}

		}

	else // the entry isn't repeating

		iAgendaServer.DeleteEntryL(aEntry.EntryId(), aEntry.CollectionId());

	}

// This function creates CCalLiteEntries from a list of entry ids

void CCalInstanceViewImpl::FetchLiteEntriesFromIdsL(RArray<TAgnInstance>& aEntryIds, RPointerArray<CCalLiteEntry>& aCalLiteEntries, TLinearOrder<CCalLiteEntry>* aOrder) const

	{

	RPointerArray<CAgnSimpleEntry> simpleEntries;

	CleanupClosePushL(simpleEntries);

	//for cleanup of the sortentries in the array if a leave happens, CleanupClosePushL is not enough.

	//Cleanup function needs access to non-static member iCalSession so that it can use

	//AgnEntryModel::DeleteLiteEntry to cleanup sortentries.

	TCleanSimpleEntryArray cleanupSimpleEntryArray(simpleEntries, iAgendaServer);

	CleanupStack::PushL(TCleanupItem(DestroySimpleEntryArray, &cleanupSimpleEntryArray));

	// first fetch the entries as CAgnSimpleEntries

	iAgendaServer.GetSimpleEntryL(aEntryIds, simpleEntries);

	__ASSERT_ALWAYS(aEntryIds.Count() == simpleEntries.Count(), User::Leave(KErrNotFound));

	// create CCalLiteEntries from the CAgnSimpleEntries

	// entries must be added to the CCalLiteEntry array in the same order they appeared in the other arrays

	while (simpleEntries.Count() > 0)

		{

		CCalLiteEntry* calLiteEntry = CCalLiteEntry::NewL(*simpleEntries[0], iAgendaServer);

		calLiteEntry->IncrementRefCount();

		simpleEntries.Remove(0); // CCalLiteEntry has taken ownership of CAgnSimpleEntry

		TInt err = 0;

		if(aOrder)

			{

			err = aCalLiteEntries.InsertInOrder(calLiteEntry, *aOrder);	

			}

		else

			{

			err = aCalLiteEntries.Append(calLiteEntry);	

			}

		if (err != KErrNone)

			{

			calLiteEntry->DecrementRefCount(); // deletes calLiteEntry

			User::Leave(err);

			}

		}

	CleanupStack::Pop(&cleanupSimpleEntryArray);

	CleanupStack::PopAndDestroy(&simpleEntries); // Close()

	}

CArrayFixSeg<TAgnInstance>* CCalInstanceViewImpl::FindInstanceIdL(const CCalFindInstanceSettings& aCalFindInstanceSettings) const

	{

	aCalFindInstanceSettings.Filter();

	const TInt KCalMaxSearchStringLength = 32;

	if (aCalFindInstanceSettings.Text() != KNullDesC && aCalFindInstanceSettings.Text().Length() > KCalMaxSearchStringLength)

		{

		User::Leave(KErrArgument);

		}

	TAgnFilter agnFilter(aCalFindInstanceSettings.Filter(), aCalFindInstanceSettings.Behaviour());

	TFindInstanceParams params;

	params.iFilter = agnFilter;

	params.iUndatedTodoTimeLocal.HomeTime();

	params.iRangeStart = CalUtils::TCalTimeToTAgnCalendarTimeL(aCalFindInstanceSettings.TimeRange().StartTime());

	params.iRangeEnd = CalUtils::TCalTimeToTAgnCalendarTimeL(aCalFindInstanceSettings.TimeRange().EndTime());

	params.iSearchString.Copy(aCalFindInstanceSettings.Text());

	CArrayFixSeg<TAgnInstance>* instances = new (ELeave) CArrayFixSeg<TAgnInstance>(16);

 	CleanupStack::PushL(instances);

	// Find the instances

 	RArray<TInt64> fileIds;

 	GetFileIdLC(fileIds);

  	iAgendaServer.FindInstancesL(fileIds,*instances, params);

 	CleanupStack::PopAndDestroy(&fileIds);

 	CleanupStack::Pop(instances);

 	return instances;

 	}

CCalSessionImpl* CCalInstanceViewImpl::FindSession(TCalCollectionId aCallectionId) const

	{

	const TInt count = iCalSessions.Count();

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

		{

		if(iCalSessions[ii]->CollectionId() == aCallectionId)

			{

			return iCalSessions[ii];

			}

		}

	return NULL;

	}

 CCalInstance* CCalInstanceViewImpl::CreateInstanceFromLiteEntryL(CCalLiteEntry& aLiteEntry, TAgnInstanceId& aInstanceId, TBool aCheckInstanceTime) const

 	{

 	CCalSessionImpl* session = FindSession(aLiteEntry.LiteEntry().CollectionId());

	__ASSERT_ALWAYS(session, User::Leave(KErrNotFound));

 	CCalEntryImpl* calEntryImpl = CCalEntryImpl::NewL(aLiteEntry, *session);

	CleanupStack::PushL(calEntryImpl);

	CCalEntry* calEntry = CCalEntry::NewL(calEntryImpl);

	CleanupStack::Pop(calEntryImpl);

	CleanupStack::PushL(calEntry);

	TCalTime instanceTime = CalUtils::TAgnCalendarTimeToTCalTimeL(aInstanceId.Date());

	CCalInstance* calInstance = NULL;

	TBool instanceTimeChanged = EFalse;

	if (aCheckInstanceTime)

		{// When instances are fetched using iterator, the instance ids is cached at the begining when the iterator is created. Therefore, the entry might has been changed by the time the instance is returned to the user.

		const CAgnSimpleEntry& KSimpleEntry = aLiteEntry.LiteEntry();

 		const CAgnRptDef* KRepeating = KSimpleEntry.RptDef();

 		if(KRepeating)

	 		{

	 		instanceTimeChanged = ! KRepeating->IsAnInstanceL(instanceTime.TimeLocalL());	

	 		}

	 	else //compare the instance time with the entry's start\end time depends on it is a todo or not

	 		{	

	 		instanceTimeChanged = KSimpleEntry.EntryTime() != aInstanceId.Date();

	 		}

 		}

	if (instanceTimeChanged)

		{

		User::Leave(KErrNotFound);	

		}

	else

		{

		calInstance= CCalInstance::NewL(calEntry, instanceTime);

		CleanupStack::Pop(calEntry);

		}

	return 	calInstance;	

 	}

 TInt CCalInstanceViewImpl::CompareInstanceId(const TAgnInstance& aLeft, const TAgnInstance& aRight)

 //

 // Compare two entries - used when sorting entries in the array

 //

 	{

 	if ( aLeft.iId.Value() == aRight.iId.Value() &&  aLeft.iCollectionId == aRight.iCollectionId)

 		{

 		return 0;

 		}

 	if(aLeft.iId.Value() < aRight.iId.Value())

 		{

 		return -1;

 		}

 	else if(aLeft.iId.Value() > aRight.iId.Value())

 		{

 		return 1;

 		}

 	else

 		{

 		return aLeft.iCollectionId  < aRight.iCollectionId ? -1 : 1;

 		}

  	}

void CCalInstanceViewImpl::FindInstanceL(RPointerArray<CCalInstance>& aMatchedInstanceList, 

										 CalCommon::TCalViewFilter aCalViewFilter, 

										 const CalCommon::TCalTimeRange& aTimeRange, 

										 const CCalInstanceView::TCalSearchParams& aSearchParams) const

	{

 	CCalFindInstanceSettings* findSetting = CCalFindInstanceSettings::NewL(aCalViewFilter, aTimeRange);

 	CleanupStack::PushL(findSetting);

 	findSetting->SetTextSearchL(aSearchParams);

 	CArrayFixSeg<TAgnInstance>* instances = FindInstanceIdL(*findSetting);

 	CleanupStack::PushL(instances);

 	FindInstancesFromIdsL(instances, aMatchedInstanceList); 	

	CleanupStack::PopAndDestroy(2, findSetting);//findSetting, instances

	}

void CCalInstanceViewImpl::FindInstancesFromIdsL(CArrayFixSeg<TAgnInstance>* aInstanceIds, RPointerArray<CCalInstance>& aInstanceArray) const

	{

	if (aInstanceIds->Count() > 0)

		{