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

#include <calentry.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <caliterator.h>

#include <calprogresscallback.h>

#include <calrrule.h>

#include <calsession.h>

#include <e32test.h>

#include <tz.h>

RTest test(_L("tcal_undatedtodo"));

_LIT(KCalendarFile, "tcal_undatedtodo");

_LIT(KDateFormat, "%02d:%02d %02d/%02d/%04d\0");

class CTestApp : public CBase

	{

public:

	static CTestApp* NewL();

	~CTestApp();

	void DoTestsL();

private:

	void ConstructL();

	void TestTodoSortOrderL(const CalCommon::TCalTimeRange& aSearchRange);

	void TestFindInstanceNonRepeatingTodoL();

	void TestFindInstanceRepeatingTodoL();

	void TestNextInstanceL();

	void CreateAndTestNonRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, const CalCommon::TCalTimeRange& aTimeRange, TBool aExpected);

	CCalEntry* CreateTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime);

	void CreateAndTestRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount, const CalCommon::TCalTimeRange& aTimeRange, RArray<TTime> aExpectedLocalInstanceTimes);

	CCalEntry* CreateRepeatingTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount);

	void PrintDetailsInstancesL(const RPointerArray<CCalInstance>& aInstanceList);

	HBufC* TimeBufLC(const TTime& aLocalTime);

private: // member data

	CCalTestLibrary* iTestLib;

	CCalEntryView* iEntryView;		// not owned

	CCalInstanceView* iInstanceView;// not owned

	TTime iToday;

	};

CTestApp* CTestApp::NewL()

	{

	CTestApp* app = new (ELeave) CTestApp();

	CleanupStack::PushL(app);

	app->ConstructL();

	CleanupStack::Pop(app);

	return app;

	}

CTestApp::~CTestApp()

	{

	delete iTestLib;

	}

void CTestApp::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KCalendarFile());

	iTestLib->OpenFileL(KCalendarFile());

	iInstanceView = &iTestLib->SynCGetInstanceViewL();

	iEntryView = &iTestLib->SynCGetEntryViewL();

	iToday.HomeTime();

	}

HBufC* CTestApp::TimeBufLC(const TTime& aLocalTime)

	{

	TBuf<17> timeBuf;

	TDateTime localDateTime = aLocalTime.DateTime();

	timeBuf.AppendFormat(KDateFormat,

							localDateTime.Hour(),

							localDateTime.Minute(),

							localDateTime.Day() + 1, 

							static_cast<TInt>(localDateTime.Month()) + 1, 

							localDateTime.Year());

	return timeBuf.AllocLC();

	}

void CTestApp::PrintDetailsInstancesL(const RPointerArray<CCalInstance>& aInstanceList)

	{

	const TInt KInstanceCount(aInstanceList.Count());

	if (KInstanceCount == 0)

		{	

		test.Printf(_L("No instances found!"));

		}

	else

		{

		test.Printf(_L("%d instances found"), KInstanceCount);

		// print the entry details

		if (aInstanceList[0]->Entry().EndTimeL().TimeLocalL() != Time::NullTTime())

			{

			// get the instance and entry due dates as strings	

			HBufC* entryEndTimeBuf = TimeBufLC(aInstanceList[0]->Entry().EndTimeL().TimeLocalL());

			// does entry have start time?

			TCalTime entryStartTime = aInstanceList[0]->Entry().StartTimeL();

			if (entryStartTime.TimeLocalL() == Time::NullTTime())

				{

				test.Printf(_L("Entry due date := %s"), entryEndTimeBuf->Ptr());

				}

			else

				{

				// get the instance and entry start times as strings

				HBufC* entryStartTimeBuf = TimeBufLC(aInstanceList[0]->Entry().StartTimeL().TimeLocalL());

				test.Printf(_L("Entry start and due date := %s - %s"), entryStartTimeBuf->Ptr(), entryEndTimeBuf->Ptr());

				CleanupStack::PopAndDestroy(entryStartTimeBuf);

				}

			CleanupStack::PopAndDestroy(entryEndTimeBuf);

			}

		else

			{

			test.Printf(_L("undated entry"));

			}

		}

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

		{	

		if (aInstanceList[i]->Entry().EndTimeL().TimeLocalL() != Time::NullTTime())

			{

			// get the instance and entry due dates as strings	

			HBufC* instanceEndTimeBuf = TimeBufLC(aInstanceList[i]->EndTimeL().TimeLocalL());

			// does entry have start time?

			TCalTime entryStartTime = aInstanceList[i]->Entry().StartTimeL();

			if (entryStartTime.TimeLocalL() == Time::NullTTime())

				{

				test.Printf(_L("Instance %d due date := %s"), i + 1, instanceEndTimeBuf->Ptr());

				}

			else

				{

				// get the instance and entry start times as strings

				HBufC* instanceStartTimeBuf = TimeBufLC(aInstanceList[i]->StartTimeL().TimeLocalL());

				test.Printf(_L("Instance %d start and due date := %s - %s"), i + 1, instanceStartTimeBuf->Ptr(), instanceEndTimeBuf->Ptr());

				CleanupStack::PopAndDestroy(instanceStartTimeBuf);

				}

			CleanupStack::PopAndDestroy(instanceEndTimeBuf);

			}

		else

			{

			test.Printf(_L("undated"));

			}

		// display the completed time if the is one

		TTime completedTimeLocal = aInstanceList[i]->Entry().CompletedTimeL().TimeLocalL();

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

			{

			HBufC* completedTimeBuf = TimeBufLC(completedTimeLocal);

			test.Printf(_L("Completed time = %s"), completedTimeBuf->Ptr());

			CleanupStack::PopAndDestroy(completedTimeBuf);

			}

		else

			{

			test.Printf(_L("incomplete"));

			}

		}

	}

CCalEntry* CTestApp::CreateTodoLC(const TTime& aStartTime, const TTime& aEndTime,  const TTime& aCompletedTime)

	{

	HBufC8* guid = NULL;

	CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::ETodo, guid);

	CleanupStack::PushL(entry);

	TCalTime calStartTime;

	calStartTime.SetTimeLocalL(aStartTime);

	TCalTime calEndTime;

	calEndTime.SetTimeLocalL(aEndTime);

	entry->SetStartAndEndTimeL(calStartTime, calEndTime);

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

		{

		TCalTime calTime;

		calTime.SetTimeLocalL(aCompletedTime);

		entry->SetCompletedL(ETrue, calTime);

		}

	return entry;

	}

CCalEntry* CTestApp::CreateRepeatingTodoLC(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount)

	{

	HBufC8* guid = NULL;

	CCalEntry* entry = iTestLib->CreateCalEntryL(CCalEntry::ETodo, guid);

	CleanupStack::PushL(entry);

	TCalTime calStartTime;

	calStartTime.SetTimeLocalL(aStartTime);

	TCalTime calEndTime;

	calEndTime.SetTimeLocalL(aEndTime);

	entry->SetStartAndEndTimeL(calStartTime, calEndTime);

	TCalRRule rRule(aRepeatType);

	rRule.SetDtStart(calEndTime);

	rRule.SetInterval(aInterval);

	rRule.SetCount(aCount);

	switch (aRepeatType)

		{

		case TCalRRule::EWeekly:

			{

			RArray<TDay> days;

			CleanupClosePushL(days);

			days.AppendL(aEndTime.DayNoInWeek());

			rRule.SetByDay(days);

			CleanupStack::PopAndDestroy(&days);

			}

			break;

		case TCalRRule::EMonthly:

			{

			RArray<TInt> monthDays;

			CleanupClosePushL(monthDays);

			monthDays.AppendL(aEndTime.DayNoInMonth());

			rRule.SetByMonthDay(monthDays);

			CleanupStack::PopAndDestroy(&monthDays);

			}

			break;

		case TCalRRule::EYearly:

			{

			RArray<TMonth> months;

			CleanupClosePushL(months);

			months.AppendL(aEndTime.DateTime().Month());

			rRule.SetByMonth(months);

			CleanupStack::PopAndDestroy(&months);

			}

			break;

		}

	entry->SetRRuleL(rRule);

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

		{

		TCalTime calTime;

		calTime.SetTimeLocalL(aCompletedTime);

		entry->SetCompletedL(ETrue, calTime);

		}

	return entry;

	}

void CTestApp::TestTodoSortOrderL(const CalCommon::TCalTimeRange& aSearchRange)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	// Create 3 TODOs 2 days in the past

	// with different priorities

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime()));

	entryArray[entryArray.Count() - 1]->SetPriorityL(4);

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime()));

	entryArray[entryArray.Count() - 1]->SetPriorityL(2);

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(2), iToday - TTimeIntervalDays(2), Time::NullTTime()));

	entryArray[entryArray.Count() - 1]->SetPriorityL(3);

	// Create 3 TODOs 1 day in the past

	// with different completed times

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(4)));

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(2)));

	entryArray.AppendL(CreateTodoLC(iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1), iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(7)));

	// Create 2 undated TODOs

	entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), Time::NullTTime()));

	entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), Time::NullTTime()));

	// Create 2 undated TODOs

	// with completed times

	entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), iToday - TTimeIntervalMinutes(4)));

	entryArray.AppendL(CreateTodoLC(Time::NullTTime(), Time::NullTTime(), iToday - TTimeIntervalMinutes(7)));

	// Create a TODO in the future

	entryArray.AppendL(CreateTodoLC(iToday + TTimeIntervalDays(2), iToday + TTimeIntervalDays(2), Time::NullTTime()));	

	TInt success(0);

	iEntryView->StoreL(entryArray, success);

	test(success == entryArray.Count());

	CleanupStack::PopAndDestroy(entryArray.Count());

	CleanupStack::PopAndDestroy(&entryArray);

	RPointerArray<CCalInstance> instanceArray;

	CleanupResetAndDestroyPushL(instanceArray);

	iInstanceView->FindInstanceL(instanceArray, CalCommon::EIncludeAll, aSearchRange);

	test.Printf(_L("Test we found the expected number of instances!"));

	//test(instanceArray.Count() == 11);

	const TInt KInstanceCount(instanceArray.Count());

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

		{

		TDateTime dt = instanceArray[i]->Time().TimeLocalL().DateTime();

		test.Printf(_L("the time of instance [%d] = %d:%d %d/%d/%d: \n"), i, dt.Hour(), dt.Minute(),dt.Day() + 1, dt.Month() + 1, dt.Year());

		}

	test.Printf(_L("Test the times of the todos"));

	test(instanceArray[0]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2));

	test(instanceArray[1]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2));

	test(instanceArray[2]->Time().TimeLocalL() == iToday - TTimeIntervalDays(2));

	// completed todos are sorted by completed time

	test(instanceArray[3]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(7));

	test(instanceArray[4]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(4));

	test(instanceArray[5]->Time().TimeLocalL() == iToday - TTimeIntervalDays(1) - TTimeIntervalMinutes(2));	

	// due date should be Time::NullTTime but instance time should be set to completed time

	test(instanceArray[6]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime());

	test(instanceArray[7]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime());

	test(instanceArray[6]->Time().TimeLocalL() == iToday - TTimeIntervalMinutes(7));

	test(instanceArray[7]->Time().TimeLocalL() == iToday - TTimeIntervalMinutes(4));

	test(instanceArray[8]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime());

	test(instanceArray[9]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime());

	test(instanceArray[10]->Time().TimeLocalL() == iToday + TTimeIntervalDays(2));

	test.Printf(_L("Test the priority of the todos"));

	test(instanceArray[0]->Entry().PriorityL() == 2);

	test(instanceArray[1]->Entry().PriorityL() == 3);

	test(instanceArray[2]->Entry().PriorityL() == 4);

	CleanupStack::PopAndDestroy(&instanceArray);

	}

void CTestApp::CreateAndTestNonRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, const CalCommon::TCalTimeRange& aTimeRange, TBool aExpected)

	{

	iTestLib->CleanDatabaseL();

	// Create and store entry

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	CCalEntry* todo = CreateTodoLC(aStartTime, aEndTime, aCompletedTime);

	entryArray.AppendL(todo);

	CleanupStack::Pop(todo);

	TInt numSuc;

	iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc);

	CleanupStack::PopAndDestroy(&entryArray);

	// find the todo

	RPointerArray<CCalInstance> instanceList;

	CleanupResetAndDestroyPushL(instanceList);

	iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, aTimeRange);

	PrintDetailsInstancesL(instanceList);

	if (aExpected)

		{

		// We are expecting an instance so test it

		test(instanceList.Count() == 1);

		// test the entry times

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

			{

			// dated

			test(instanceList[0]->Entry().EndTimeL().TimeLocalL() == aEndTime);

			}

		else

			{

			// undated

			test(instanceList[0]->Entry().StartTimeL().TimeLocalL() == Time::NullTTime());

			test(instanceList[0]->Entry().EndTimeL().TimeLocalL() == Time::NullTTime());

			}

		// test the instance times

		if (instanceList[0]->Entry().CompletedTimeL().TimeLocalL() == Time::NullTTime())

			{

			// incomplete

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

				{

				// the todo is dated

				// the instance due date should always be the same as the entry due date 

				test(instanceList[0]->EndTimeL().TimeLocalL() == aEndTime);

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

					{

					// The entry has a start time so the instance should have the same start time

					test(instanceList[0]->StartTimeL().TimeLocalL() == aStartTime);

					}

				else

					{

					// The entry was not stored with a start time

					// so the instance start time should be the same as the due date

					test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->EndTimeL().TimeLocalL());

					}

				}

			else

				{

				// The todo is undated

				// so test that the start and end times are the same and that they are set as some time today

				test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->EndTimeL().TimeLocalL());

				test(instanceList[0]->StartTimeL().TimeLocalL() != Time::NullTTime());

				test(instanceList[0]->StartTimeL().TimeLocalL().DaysFrom(iToday).Int() == 0);

				}

			}

		else

			{

			// complete

			test(instanceList[0]->StartTimeL().TimeLocalL() == instanceList[0]->Entry().CompletedTimeL().TimeLocalL());

			test(instanceList[0]->EndTimeL().TimeLocalL() == instanceList[0]->Entry().CompletedTimeL().TimeLocalL());

			}

		}

	else

		{

		test(instanceList.Count() == 0);

		}

	CleanupStack::PopAndDestroy(&instanceList);

	}

void CTestApp::CreateAndTestRptTodoL(const TTime& aStartTime, const TTime& aEndTime, const TTime& aCompletedTime, TCalRRule::TType aRepeatType, TInt aInterval, TInt aCount, const CalCommon::TCalTimeRange& aTimeRange, RArray<TTime> aExpectedLocalInstanceTimes)

	{

	iTestLib->CleanDatabaseL();

	// Create and store repeating todo entry

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	CCalEntry* rptTodo = CreateRepeatingTodoLC(aStartTime, aEndTime, aCompletedTime, aRepeatType, aInterval, aCount);

	entryArray.AppendL(rptTodo);

	CleanupStack::Pop(rptTodo);

	TInt numSuc;

	iTestLib->SynCGetEntryViewL().StoreL(entryArray, numSuc);

	CleanupStack::PopAndDestroy(&entryArray);

	// find the todo

	RPointerArray<CCalInstance> instanceList;

	CleanupResetAndDestroyPushL(instanceList);

	iTestLib->SynCGetInstanceViewL().FindInstanceL(instanceList, CalCommon::EIncludeAll, aTimeRange);

	PrintDetailsInstancesL(instanceList);

	test(instanceList.Count() == aExpectedLocalInstanceTimes.Count());

	for (TInt i(0) ; i < instanceList.Count() ; ++i)

		{

		test(instanceList[i]->EndTimeL().TimeLocalL() == aExpectedLocalInstanceTimes[i]);

		}

	CleanupStack::PopAndDestroy(&instanceList);

	}

void CTestApp::TestFindInstanceNonRepeatingTodoL()

	{

	// set up a search range +- 10 days from now

	TCalTime startDateTime1;

	startDateTime1.SetTimeLocalL(iToday - TTimeIntervalDays(10));	

	TCalTime endDateTime1;

	endDateTime1.SetTimeLocalL(iToday + TTimeIntervalDays(10));

	CalCommon::TCalTimeRange timeRangeWithToday(startDateTime1, endDateTime1);

	TCalTime startDateTime2;

	startDateTime2.SetTimeLocalL(iToday + TTimeIntervalDays(1));	

	TCalTime endDateTime2;

	endDateTime2.SetTimeLocalL(iToday + TTimeIntervalDays(20));

	CalCommon::TCalTimeRange timeRangeAfterToday(startDateTime2, endDateTime2);

	TCalTime startDateTime3;

	startDateTime3.SetTimeLocalL(iToday - TTimeIntervalDays(20));	

	TCalTime endDateTime3;

	endDateTime3.SetTimeLocalL(iToday - TTimeIntervalDays(1));

	CalCommon::TCalTimeRange timeRangeBeforeToday(startDateTime3, endDateTime3);

	// completed todos

	test.Printf(_L("\n--Completed todo with completion date before the time range (due before)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),

						timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2), // due before

						timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2),

						timeRangeWithToday,

						EFalse);

	test.Printf(_L("\n--Completed todo with completion date before the time range (due inside)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),

						timeRangeWithToday.StartTime().TimeLocalL() + TTimeIntervalDays(2), // due inside

						timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2),

						timeRangeWithToday,

						EFalse);

	test.Printf(_L("\n--Completed todo with completion date before the time range (due after)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),

						timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // due after

						timeRangeWithToday.StartTime().TimeLocalL() - TTimeIntervalDays(2),

						timeRangeWithToday,

						EFalse);

	test.Printf(_L("\n--Completed todo with completion date after the time range (due after)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),

						timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2), // due after

						timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2),

						timeRangeWithToday,

						EFalse);

	test.Printf(_L("\n--Completed todo with completion date after the time range (due inside)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),

						timeRangeWithToday.EndTime().TimeLocalL() - TTimeIntervalDays(2), // due inside

						timeRangeWithToday.EndTime().TimeLocalL() + TTimeIntervalDays(2),

						timeRangeWithToday,

						EFalse);

	test.Printf(_L("\n--Completed todo with completion date after the time range (due inside)--"));

	CreateAndTestNonRptTodoL(Time::NullTTime(),