// 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 "tcal_observer_modifier.h"

void ResetAndDestroyCalEntryArray(TAny*);

LOCAL_D const TInt KNumberBulkEntries(50);

LOCAL_D const TInt KNumberBulkEntriesToOverflowNotificationBuffer(51);

_LIT8(KGuid1, "guid");

_LIT8(KEntryGuid, "A_DUMMY_GUID");

_LIT(KSummary1, "Reminder Parent entry");

_LIT(KDescription1, "Source entry");

_LIT(KSummary2, "Reminder child entry with repeat rule");

_LIT(KDescription2, "Updating the Parent entry");

CTestAppModifier* CTestAppModifier::NewL()

	{

	CTestAppModifier* self = new(ELeave) CTestAppModifier;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestAppModifier::ConstructL()

	{

	CTestApp::ConstructL();

	iCalTestLibrary = CCalTestLibrary::NewL();

	iCalTestLibrary->OpenFileL(KCalendarFile());

	iChunk.OpenGlobal(KChunkName(), EFalse);

	iNumExpectedChanges = reinterpret_cast<TInt*>(iChunk.Base());

	(*iNumExpectedChanges) = 0;

	iExpectedChanges = sizeof(TInt) + reinterpret_cast<TCalChangeEntry*>(iChunk.Base());

	}

CTestAppModifier::~CTestAppModifier()

	{

	delete iCalTestLibrary;

	}

void CTestAppModifier::ClearEntryL()

	{

	// this function deletes all entries with the UID used in this test harness

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

		{

		iExpectedChanges[i].iChangeType = MCalChangeCallBack2::EChangeDelete;

		}

	iNumEntriesToDelete = 0;

	iCalTestLibrary->AsynCGetEntryViewL().DeleteL(*iUidArray);

	delete iUidArray;

	iUidArray = NULL;

	}

CCalEntry* CTestAppModifier::CreateEntryLC(CCalEntry::TType aType, TTime aTimeLocal)

	{

	// create a new unique guid every time we create an entry   

	TBuf8<255> buf; // 255 is the Maximum guid length;

	buf.Num(iGuidNum++);

	HBufC8* guid = buf.AllocLC();

	if (!iUidArray)

		{

		iUidArray = new (ELeave) CDesC8ArraySeg(1000);

		}

	iUidArray->AppendL(*guid);

	CCalEntry* entry = CCalEntry::NewL(aType, guid, CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	// Set the start and end time as passed to us

	TCalTime calTime1;

	TCalTime calTime2;

	calTime1.SetTimeLocalL(aTimeLocal);

	//for undated todo, both start and end time shud be NULL

	if(aTimeLocal != Time::NullTTime())

		{

		calTime2.SetTimeLocalL(aTimeLocal + TTimeIntervalHours(1));

		}

	else

		{

		calTime2.SetTimeLocalL(aTimeLocal);

		}

	entry->SetStartAndEndTimeL(calTime1, calTime2);

	return entry;

	}

void CTestAppModifier::UpdateEntriesL(TBool aInRange)

	{

	// update every entry the we have added to the store so far

	const TInt KUidCount(iUidArray->Count());

	for (TInt j(0) ; j < KUidCount ; ++j)

		{

		RPointerArray<CCalEntry> calEntries;

		CleanupResetAndDestroyPushL(calEntries);

		iCalTestLibrary->SynCGetEntryViewL().FetchL((*iUidArray)[j], calEntries);

		const TInt KEntryCount(calEntries.Count());

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

			{

			calEntries[i]->SetLastModifiedDateL();

			if (aInRange)

				{

				iExpectedChanges[*iNumExpectedChanges].iChangeType = MCalChangeCallBack2::EChangeModify;

				iExpectedChanges[*iNumExpectedChanges].iEntryId = calEntries[i]->LocalUidL();

				++(*iNumExpectedChanges);	

				}

			}

		TInt numSucsessful;

		iCalTestLibrary->AsynCGetEntryViewL().UpdateL(calEntries, numSucsessful);

		CleanupStack::PopAndDestroy(); //calEntries.ResetAndDestroy();

		}	

	if(KUidCount>20)

		{//bulk operation

		*iNumExpectedChanges = 1;

		}

	}

void CTestAppModifier::StoreEntryLD(CCalEntry* aEntry, TBool aInRange)

	{

	StoreEntryLC(aEntry, aInRange);

	CleanupStack::PopAndDestroy(aEntry);

	}

void CTestAppModifier::StoreEntryLC(CCalEntry* aEntry, TBool aInRange)

	{

	CleanupStack::PushL(aEntry);

	RPointerArray<CCalEntry> entriesToAdd;

	CleanupClosePushL(entriesToAdd);

	entriesToAdd.AppendL(aEntry);

	if (aInRange)

		{

		iExpectedChanges[*iNumExpectedChanges].iChangeType = MCalChangeCallBack2::EChangeAdd;

		if (aEntry->EntryTypeL() == CCalEntry::ETodo)

			{

			iExpectedChanges[*iNumExpectedChanges].iEntryType = MCalChangeCallBack2::EChangeEntryTodo;

			}

		else

			{

			iExpectedChanges[*iNumExpectedChanges].iEntryType = MCalChangeCallBack2::EChangeEntryEvent;	

			}

		iExpectedChanges[*iNumExpectedChanges].iEntryId = 0;

		++(*iNumExpectedChanges);

		++iNumEntriesToDelete;

		}

	TInt successfulAdd(0);

	iCalTestLibrary->SynCGetEntryViewL().StoreL(entriesToAdd, successfulAdd);

	CleanupStack::PopAndDestroy(); // entriesToAdd.Close()

	}

void CTestAppModifier::RunTestL()

	{

	while (*iTestCase < EAmount)

		{

		NextTestL();         // Prepare the test case

		iSemaphore.Signal(); // Done preparing: Report to the manager thread that it can continue now

		RThread().Suspend(); // Rest here until the manager thread has finished this test case

		}

	}

void CTestAppModifier::NextTestL()

	{		

	// Create some variables for use in the test cases

	TCalTime startBoundaryStartTime;

	startBoundaryStartTime.SetTimeLocalL(KRangeStartTime - TTimeIntervalDays(1));

	TCalTime startBoundaryEndTime;

	startBoundaryEndTime.SetTimeLocalL(KRangeStartTime - TTimeIntervalDays(1) + TTimeIntervalHours(1));

	TCalTime endBoundaryStartTime;

	endBoundaryStartTime.SetTimeLocalL(KRangeEndTime - TTimeIntervalDays(1));

	TCalTime endBoundaryEndTime;

	endBoundaryStartTime.SetTimeLocalL(KRangeEndTime - TTimeIntervalDays(1) + TTimeIntervalHours(1));

	TCalTime outsideStartTime;

	outsideStartTime.SetTimeLocalL(KRangeEndTime + TTimeIntervalDays(1));

	TCalTime outsideEndTime;

	outsideEndTime.SetTimeLocalL(KRangeEndTime + TTimeIntervalDays(1) + TTimeIntervalHours(1));

	TCalRRule rRuleStartBoundary(TCalRRule::EDaily);

	rRuleStartBoundary.SetDtStart(startBoundaryStartTime);

	rRuleStartBoundary.SetCount(5);

	rRuleStartBoundary.SetInterval(1);

	TCalRRule rRuleEndBoundary(TCalRRule::EDaily);

	rRuleEndBoundary.SetDtStart(endBoundaryStartTime);

	rRuleEndBoundary.SetCount(5);

	rRuleEndBoundary.SetInterval(1);

	TCalRRule rRuleOutside(TCalRRule::EDaily);

	rRuleOutside.SetDtStart(outsideStartTime);

	rRuleOutside.SetInterval(1);

	rRuleOutside.SetCount(5);

	TInt numSucsess;

	switch (*iTestCase)

		{

		case EEntryOutOfRange:

			{

			HBufC8* guid = KEntryGuid().AllocLC();

			CCalEntry* entry = CCalEntry::NewL(CCalEntry::EReminder, guid, CCalEntry::EMethodNone, 0);

			CleanupStack::Pop(guid);

			CleanupStack::PushL(entry);	

			TTime startTime(TDateTime(1984, EJune, 9, 10, 0, 0, 0)); // 10 June 1984 10am

			TCalTime calTime1;

			calTime1.SetTimeLocalFloatingL(startTime);

			entry->SetStartAndEndTimeL(calTime1, calTime1); // end time is ignored for for reminder

			entry->SetSummaryL(KSummary1());

			entry->SetDescriptionL(KDescription1());

			TCalRRule rule(TCalRRule::EDaily);

			rule.SetDtStart(calTime1);

			rule.SetInterval(1);

			rule.SetCount(5);

			entry->SetRRuleL(rule);

			CleanupStack::Pop(entry);

			StoreEntryLD(entry,ETrue); // store the entry which is out of range

			*iNumExpectedChanges = 0;

			}

			break;

		case EEntryOutOfRange1:

			{

			HBufC8* guid2 = KEntryGuid().AllocLC();

			TTime recurId(TDateTime(1984, EJune, 11, 10, 0, 0, 0)); // 12 June 1984 10am

			TCalTime calRecurId;

			calRecurId.SetTimeLocalFloatingL(recurId);

			CCalEntry* childEntry = CCalEntry::NewL(CCalEntry::EReminder, guid2, CCalEntry::EMethodNone, 0, calRecurId, CalCommon::EThisAndFuture);

			CleanupStack::Pop(guid2);

			CleanupStack::PushL(childEntry);	

			TTime startTime2(TDateTime(1984, EJune, 15, 15, 0, 0, 0)); // 16 June 1984 3pm

			TTime endTime2(TDateTime(1984, EJune, 15, 16, 0, 0, 0)); // 16 June 1984 4pm

			TCalTime calStartTime2;

			calStartTime2.SetTimeLocalFloatingL(startTime2);

			TCalTime calEndTime2;

			calEndTime2.SetTimeLocalFloatingL(endTime2);

			childEntry->SetStartAndEndTimeL(calStartTime2, calEndTime2);

			childEntry->SetSummaryL(KSummary2);

			childEntry->SetDescriptionL(KDescription2);

			TCalRRule rule2(TCalRRule::EDaily);

			rule2.SetDtStart(calStartTime2);

			rule2.SetInterval(1);

			rule2.SetCount(5);

			childEntry->SetRRuleL(rule2);

			CleanupStack::Pop(childEntry);

			StoreEntryLD(childEntry, ETrue); // store the entry which is out of range

			*iNumExpectedChanges = 0;

			}

			break;

		case EApptInsideRange1:

			{

			// Add an appointment inside the range

			CCalEntry* entry = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime + TTimeIntervalDays(5));

			CleanupStack::Pop(entry);

			StoreEntryLD(entry, ETrue);

			}

			break;

		case EApptInsideRange2:

			{

			UpdateEntriesL(ETrue);

			}

			break;

		case EApptInsideRange3:

			{

			*iNumExpectedChanges = 1;

			ClearEntryL();

			}

			break;	

		case EApptOutsideRange1:

			{

			// add appt outside time range

			CCalEntry* entry = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime - TTimeIntervalMonths(3));

			CleanupStack::Pop(entry);

			StoreEntryLD(entry, EFalse);

			}

			break;

		case EApptOutsideRange2:

			{

			UpdateEntriesL(EFalse);

			}

			break;

		case EApptOutsideRange3:

			{

			ClearEntryL();

			}

			break;

		case ENotifyNonResponsive:

			{

			// Disable notification then add a ToDo.

			iCalTestLibrary->GetSession().DisableChangeBroadcast();

			CCalEntry* entry = CreateEntryLC(CCalEntry::ETodo, KRangeStartTime + TTimeIntervalDays(5));

			CleanupStack::Pop(entry);

			StoreEntryLD(entry, EFalse);

			/* this client will be non responsive */

 			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeUndefined;

 			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryAll;

 			iExpectedChanges[0].iEntryId = 0;

//The timer which enbles the broadcast added in 9.3 is not implemented here

 			*iNumExpectedChanges = 0;

 			//*iNumExpectedChanges = 1;

//

			}

			break;

		case ENotifyNonResponsive1:

			{

//The timer which enbles the broadcast added in 9.3 is not implemented here

			*iNumExpectedChanges = 0;

			iNumEntriesToDelete = 0;

			//*iNumExpectedChanges = 1;

			//iNumEntriesToDelete = 1;

//			

			ClearEntryL();

			/* notification is still not enabled */

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeUndefined;				

			}

			break;

		case ETodoInsideRange1:

			{

			// Add a todo within the time range, but disable notification

			iCalTestLibrary->GetSession().DisableChangeBroadcast();

			CCalEntry* entry = CreateEntryLC(CCalEntry::ETodo, KRangeStartTime + TTimeIntervalDays(5));

			CleanupStack::Pop(entry);

			StoreEntryLD(entry, EFalse);

			}

			break;

		case ETodoInsideRange2:

			{

			// re-enable notification and set up the expected values 

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeUndefined;

			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryAll;

			iExpectedChanges[0].iEntryId = 0;

			*iNumExpectedChanges = 1;

			iCalTestLibrary->GetSession().EnableChangeBroadcast();

			}

			break;

		case ETodoInsideRange3:

			{

			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryTodo;

			UpdateEntriesL(ETrue);

			}

			break;

		case ETodoInsideRange4:

			{

			*iNumExpectedChanges = iNumEntriesToDelete = 1;

			ClearEntryL();

			}

			break;

		case ETodoOutsideRange1:

			{

			// Add a todo outside of the time range

			CCalEntry* entry = CreateEntryLC(CCalEntry::ETodo, KRangeEndTime + TTimeIntervalHours(4));

			CleanupStack::Pop(entry);

			StoreEntryLD(entry, EFalse);

			}

			break;

		case ETodoOutsideRange2:

			{

			UpdateEntriesL(EFalse);

			}

			break;

		case ETodoOutsideRange3:

			{

			ClearEntryL();

			}

			break;

		case EAddUndatedTodo:

			{

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeAdd;

			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryTodo;

			iExpectedChanges[0].iEntryId = 0;

			*iNumExpectedChanges = 0;

			CCalEntry* entry = CreateEntryLC(CCalEntry::ETodo, Time::NullTTime());

			entry->SetSummaryL(_L("original todo"));

			CleanupStack::Pop(entry);

			StoreEntryLC(entry, ETrue);

			iExpectedChanges[0].iEntryId = entry->LocalUidL();

			CleanupStack::PopAndDestroy(entry);

			}

			break;

		case EUpdateUndatedTodo:

			{

			//Create a modified todo with new GUID.

			CCalEntry* newEntry = CreateEntryLC(CCalEntry::ETodo, Time::NullTTime());

			iUidArray->Delete(0);

			newEntry->SetSummaryL(_L("Modified todo"));

			CCalEntry* entry = iCalTestLibrary->SynCGetEntryViewL().FetchL(iExpectedChanges[0].iEntryId);

			CleanupStack::PushL(entry);

			entry->CopyFromL(*newEntry);

			entry->SetLocalUidL(iExpectedChanges[0].iEntryId);

			CleanupStack::Pop(entry);

			CleanupStack::PopAndDestroy(newEntry);

			*iNumExpectedChanges = 1;

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeModify;

			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryTodo;

			StoreEntryLD(entry, EFalse);

			--iNumEntriesToDelete;

			}

			break;

		case EClearUndatedTodo:

			{	

			*iNumExpectedChanges = iNumEntriesToDelete = 1;

			ClearEntryL();

			}

			break;

		case EMultipleInAndOutside1:

			{

			// Add multiple entries in and outside range

			CCalEntry* todoOutRange = CreateEntryLC(CCalEntry::ETodo, KRangeEndTime + TTimeIntervalHours(4));

			CleanupStack::Pop(todoOutRange);

			StoreEntryLD(todoOutRange, EFalse);

			CCalEntry* apptOutOfRange = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime - TTimeIntervalMonths(3));

			CleanupStack::Pop(apptOutOfRange);

			StoreEntryLD(apptOutOfRange, EFalse);

			CCalEntry* apptInRange = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime + TTimeIntervalDays(5));

			CleanupStack::Pop(apptInRange);

			StoreEntryLD(apptInRange);

			CCalEntry* todoInRange = CreateEntryLC(CCalEntry::ETodo, KRangeStartTime + TTimeIntervalDays(5));

			CleanupStack::Pop(todoInRange);

			StoreEntryLD(todoInRange);

			}

			break;

		case EMultipleInAndOutside2:

			{	

			*iNumExpectedChanges = 2;

			ClearEntryL();

			}

			break;

		case EBulkAdd:

			{

			// add a lot of entries quickly to see if the notification can keep up

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

				{

				CCalEntry* entry = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime + TTimeIntervalDays(5));

				CleanupStack::Pop(entry);

				StoreEntryLD(entry);

				}

			}

			break;

		case EBulkDelete:

			{

			// Delete all the entries in the bulk add

			*iNumExpectedChanges = 1;//bulk operation

			ClearEntryL();

			}

			break;

		case EBulkAddToOverflowNotificationBuffer:

			{

			// Add a lot of entries and wait for 5 seconds (in the manager) and overflow the notification buffer

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

				{

				CCalEntry* entry = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime + TTimeIntervalDays(5));

				CleanupStack::Pop(entry);

				StoreEntryLD(entry);

				}

			// set up expected data

			*iNumExpectedChanges = 1;

			// Expecting one Undefined Change

			iExpectedChanges[0].iEntryType = MCalChangeCallBack2::EChangeEntryAll;

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeUndefined;

			iExpectedChanges[0].iEntryId = 0;

			}

			break;

		case EBulkDeleteToOverflowNotificationBuffer:

			{

			// Delete all the entries in the bulk add

			*iNumExpectedChanges = 1;

			iNumEntriesToDelete = KNumberBulkEntriesToOverflowNotificationBuffer;

			ClearEntryL();

			// Expecting one Undefined Change

			iExpectedChanges[0].iChangeType = MCalChangeCallBack2::EChangeUndefined;

			}

			break;

		case ERepeatingEitherSideOfRange1:

			{

			// Create an entry that has instances before and after the observation range

			CCalEntry* entry = CreateEntryLC(CCalEntry::EAppt, KRangeStartTime - TTimeIntervalDays(1));

			TCalRRule rRule(TCalRRule::EYearly);

			TCalTime calTime;

			calTime.SetTimeLocalL(KRangeStartTime - TTimeIntervalDays(1));

			rRule.SetDtStart(calTime);

			rRule.SetCount(2);

			rRule.SetInterval(2);