// Copyright (c) 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 <calsession.h>

#include <e32test.h>

#include <caliterator.h>

#include <calrrule.h>

#include <s32file.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <e32base.h>

#include <calinstanceiterator.h>

#include <calattachment.h>

#include <calattachmentmanager.h>

_LIT(KTestName,"TCal_MultipleFiles");

_LIT(KWorkCalendar,"Work_Calendar");

_LIT(KPersonalCalendar,"Personal_Calendar");

_LIT(KSportsCalendar, "Sports_Calendar");

_LIT(KWorkCalendarIndexFile, "c:\\private\\10003a5b\\work_calendarIdx");

RTest test(KTestName);

const TInt KShortFileId1 = 1;

const TInt KShortFileId2 = 2;

_LIT8(KUid, "MFTUid");

_LIT8(KUid1, "MFTUid1");

class CTestFileObservers : public CBase, MCalChangeCallBack2

	{

public:

	static CTestFileObservers* NewL(const TDesC& aFileName);

	// from MCalChangeCallBack2

	void CalChangeNotification(RArray<TCalChangeEntry>& aChangeItems);

	~CTestFileObservers();

private:

	void ConstructL(const TDesC& aFileName);

private:

	CCalSession* iNotificationSession;

	};

class CTestMultipleCalendar : public CBase, MCalProgressCallBack

	{

public:

    static CTestMultipleCalendar* NewL();

	void RunAllTestsL();

	~CTestMultipleCalendar();	

private:

	void ConstructL();

	CTestMultipleCalendar();

	// Test cases

	void TestEntryViewAndFileConsistencyL(TBool aAddingSameEntry);

	void TestInstanceViewL();

	void TestFindInstanceL(TBool aSessionToFindInstanceFrom, TInt aExpectedValue);

	void TestFindInstanceWithInstanceIdL();

	void TestUpdateDeleteFunctionalityL();

	void TestShortFileIdL();

	void TestSwitchInstanceViewsL();

	void TestNegativeForSecondSessionL();

	void TestNegativeForCollectionIdL();

	void TestCopyEntryBetweenCalendarsL();

	// Data creation and check functions

	TCalInstanceId AddAndCheckEntryL(CCalEntryView& aEntryView, CCalSession& aSession, TBool aSameEntry = ETrue);

	void AddLargeNumberOfEntriesL(CCalEntryView& aEntryView);

	void CreateNotificationSessionL();

	void CreateSecondSessionL();

	void CreateAndTestInstanceIteratorL(CCalInstanceView& aInstanceView, TInt aExpectedCount);

	TInt CheckIteratorL(CCalInstanceIterator& aIterator, RPointerArray<CCalInstance>& aInstances);

	TBool CheckInstanceIdL(TCalInstanceId aId1, TCalInstanceId aId2);

	void CheckInstanceDetailsL(CCalInstance* aInstance, TCalInstanceId aInstanceId);

	void CheckInstanceViewL(CCalInstanceView& aInstanceView, TInt aNumInstance);

	void DeleteSecondCalendarFileL();

	void ClearStoredDataL();

	void Progress(TInt aPercentageCompleted); 

	void Completed(TInt aError);

	TBool NotifyProgress();

private:

	CCalTestLibrary* iTestLib;

	TInt 	iProgress;

	CCalSession* iSecondSession;

	TCalTime iStartTime;

	TCalTime iEndTime;

	CTestFileObservers* iObserverForWorkCalendar;

	CTestFileObservers* iObserverForPersonalCalendar;

	};

CTestFileObservers* CTestFileObservers::NewL(const TDesC& aFileName)

	{

	CTestFileObservers* self = new (ELeave) CTestFileObservers();

	CleanupStack::PushL(self);

	self->ConstructL(aFileName);

	CleanupStack::Pop(self);

	return self;	

	}

void CTestFileObservers::ConstructL(const TDesC& aFileName)

	{

	iNotificationSession = CCalSession::NewL();

	iNotificationSession->OpenL(aFileName);

	TCalTime minTime;

	minTime.SetTimeUtcL(TCalTime::MinTime());

	TCalTime maxTime;

	maxTime.SetTimeUtcL(TCalTime::MaxTime());

	CalCommon::TCalTimeRange timeRange(minTime, maxTime);

	CCalChangeNotificationFilter* filter = CCalChangeNotificationFilter::NewL(MCalChangeCallBack2::EChangeEntryAll, ETrue, timeRange);

	CleanupStack::PushL(filter);

	iNotificationSession->StartChangeNotification(*this, *filter);

	CleanupStack::PopAndDestroy(filter);

	}

CTestFileObservers::~CTestFileObservers()

	{

	delete iNotificationSession;

	}

void CTestFileObservers::CalChangeNotification(RArray<TCalChangeEntry>& aChangeItems)

	{

	test.Printf(_L("MCalChangeCallBack2 notification happened\n") );

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

	TCalChangeEntry change = aChangeItems[0];

	switch(change.iChangeType)

		{

		case MCalChangeCallBack2::EChangeAdd:

			{

			test.Printf(_L("Calendar entry has been added"));

			break;

			}

		case MCalChangeCallBack2::EChangeDelete:

			{

			test.Printf(_L("Calendar entry has been deleted"));

			break;

			}

		case MCalChangeCallBack2::EChangeModify:

			{

			test.Printf(_L("Calendar entry has been modified"));

			break;

			}

		case MCalChangeCallBack2::EChangeUndefined:

			{

			test.Printf(_L("Undefined calendar entry change"));

			break;

			}

		case MCalChangeCallBack2::EChangeTzRules:

			{

			test.Printf(_L("Calendar entry's time zone rules have been changed"));

			break;

			}

		}

	CActiveScheduler::Stop();

	}

CTestMultipleCalendar::CTestMultipleCalendar() : iProgress(0)

	{

	}

CTestMultipleCalendar* CTestMultipleCalendar::NewL()

	{

	CTestMultipleCalendar* self = new (ELeave) CTestMultipleCalendar();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestMultipleCalendar::ConstructL()

	{

	iStartTime.SetTimeLocalL(TDateTime(2007, EMarch, 20, 5, 0, 0, 0)); 

	iEndTime.SetTimeLocalL(TDateTime(2007, EMarch, 20, 6, 0, 0, 0));

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KWorkCalendar);

	iTestLib->OpenFileL(KWorkCalendar);

	}	

CTestMultipleCalendar::~CTestMultipleCalendar()	

	{

	TRAP_IGNORE(DeleteSecondCalendarFileL());

	delete iObserverForWorkCalendar;

	delete iObserverForPersonalCalendar;

	delete iTestLib;

	delete iSecondSession;

	}

TCalInstanceId CTestMultipleCalendar::AddAndCheckEntryL(CCalEntryView& aEntryView, CCalSession& aSession, TBool aSameEntry)

	{

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);	

	// create an appt

	test.Printf(_L("Create an appointment \n"));

	HBufC8* guid; 

	CCalEntry* entry;

	if(aSameEntry)

		{

		guid = KUid().AllocLC();

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

		}

	else

		{

		guid = KUid1().AllocLC();

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

		}

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);	

	test.Printf(_L("Set the start and end time for the entry \n"));

	entry->SetStartAndEndTimeL(iStartTime, iEndTime);		

	test.Printf(_L("Set the repeat definition \n"));	

	TCalRRule repeat;

	repeat.SetType(TCalRRule::EDaily);

	repeat.SetDtStart(iStartTime);

	repeat.SetInterval(1);

	repeat.SetCount(10);

	entry->SetRRuleL(repeat);

	entries.AppendL(entry);

	CleanupStack::Pop(entry);

	// Store the entry

	test.Printf(_L("Store the entry in the session"));

	TInt entriesStored(0);

	aEntryView.StoreL(entries, entriesStored);

	test(entriesStored == 1);

	entries.ResetAndDestroy();

	//Fetch entry

	test.Printf(_L("Fetch the entry and verify it \n"));

	if(aSameEntry)

		{

		aEntryView.FetchL(KUid, entries);		

		}	

	else

		{

		aEntryView.FetchL(KUid1, entries);

		}

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

	entry = entries[0];

	test.Printf(_L("Get the instance id \n"));

	TCalInstanceId instanceId;

	instanceId.iEntryLocalId = entry->LocalUidL(); 

	instanceId.iCollectionId = aSession.CollectionIdL();

	instanceId.iInstanceTime = iStartTime;

	CleanupStack::PopAndDestroy(&entries);

	return instanceId;

	}

void CTestMultipleCalendar::AddLargeNumberOfEntriesL(CCalEntryView& aEntryView)

	{

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);	

	// create an appt

	test.Printf(_L("Create an appointment \n"));

	CCalEntry* entry;

	TBuf8<64> uid;

	HBufC8* guid; 

	for(TInt k = 0; k < 50; k++)

		{

		uid.Copy(KUid());

		uid.AppendNum(k);

		guid = uid.AllocLC();

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

		CleanupStack::Pop(guid);

		CleanupStack::PushL(entry);	

		test.Printf(_L("Set the start and end time for the entry \n"));

		entry->SetStartAndEndTimeL(iStartTime, iEndTime);		

		test.Printf(_L("Set the repeat definition \n"));	

		TCalRRule repeat;

		repeat.SetType(TCalRRule::EDaily);

		repeat.SetDtStart(iStartTime);

		repeat.SetInterval(1);

		repeat.SetCount(10);

		entry->SetRRuleL(repeat);

		entries.AppendL(entry);

		CleanupStack::Pop(entry);

		// Store the entry

		test.Printf(_L("Store the entry in the session"));

		TInt entriesStored(0);

		aEntryView.StoreL(entries, entriesStored);

		test(entriesStored == 1);

		entries.ResetAndDestroy();

		}	

	CleanupStack::PopAndDestroy(&entries);

	}

void CTestMultipleCalendar::Progress(TInt aPercentageCompleted) 

	{

	iProgress++;

	test(aPercentageCompleted >= 0);

	test(aPercentageCompleted <=100);

	test.Printf(_L("MCalProgressCallBack::Progress is %d complete\n"), aPercentageCompleted);

	}

void CTestMultipleCalendar::Completed(TInt aError)

	{

	test(aError == KErrNone);

	test.Printf(_L("MCalProgressCallBack::Completed\n") );

	CActiveScheduler::Stop();

	}

TBool CTestMultipleCalendar::NotifyProgress()

	{

	return ETrue;

	}

void CTestMultipleCalendar::CreateSecondSessionL()

	{

	test.Printf(_L("Create and open the second calendar file \n"));

	iSecondSession = CCalSession::NewL(iTestLib->GetSession());

	iSecondSession->CreateCalFileL(KPersonalCalendar);

	iSecondSession->OpenL(KPersonalCalendar);	

	}

void CTestMultipleCalendar::DeleteSecondCalendarFileL()

	{

	test.Printf(_L("Delete the calendar file"));

	if(!iSecondSession)

		{

		iSecondSession = CCalSession::NewL(iTestLib->GetSession());

		}	

	TRAPD(err, iSecondSession->DeleteCalFileL(KPersonalCalendar));

	test(err == KErrNone || err == KErrNotFound);

	}

void CTestMultipleCalendar::ClearStoredDataL()

	{

	// Clear data

	DeleteSecondCalendarFileL();

	delete iSecondSession;

	iSecondSession = NULL;

	iTestLib->ReplaceFileL(KWorkCalendar);

	iTestLib->OpenFileL(KWorkCalendar);

	}

void CTestMultipleCalendar::CreateAndTestInstanceIteratorL(CCalInstanceView& aInstanceView, TInt aExpectedCount)

	{	

	test.Printf(_L("Create the instance iterator to iterate through all the instances \n"));

	RPointerArray<CCalInstance> instances;

	CleanupResetAndDestroyPushL(instances);

	TCalTime start;

	start.SetTimeUtcL(TCalTime::MinTime());

	TCalTime end;

	end.SetTimeUtcL(TCalTime::MaxTime());

	CalCommon::TCalTimeRange timeRange(start, end);

	aInstanceView.FindInstanceL(instances, CalCommon::EIncludeAll, timeRange);

	test(instances.Count() == aExpectedCount);

	instances.ResetAndDestroy();

	// Instance iterator

	CCalFindInstanceSettings* findSetting = CCalFindInstanceSettings::NewL(CalCommon::EIncludeAll, timeRange);

	CleanupStack::PushL(findSetting);

	CCalInstanceIterator* iterator = aInstanceView.FindInstanceL(*findSetting);

	CleanupStack::PopAndDestroy(findSetting);

	CleanupStack::PushL(iterator);

	test.Printf(_L("Created iterator, now check the previous and next instances \n"));

	TInt count = CheckIteratorL(*iterator, instances);

	test(count == aExpectedCount);

	test.Printf(_L("Finished iterating \n"));

	test.Printf(_L("Deleting the instances \n"));

	CleanupStack::PopAndDestroy(2, &instances); //instances, iterator

	}

TInt CTestMultipleCalendar::CheckIteratorL(CCalInstanceIterator& aIterator, RPointerArray<CCalInstance>& aInstances)

	{

	test.Printf(_L("Iterate through the instances and verify the start and end time"));

	TTime previousInstanceTime = Time::NullTTime();

	TInt count = 0;

	while(CCalInstance* nextInstance = aIterator.NextL())

		{

		CleanupStack::PushL(nextInstance);

		if(count > 0)

			{

			CCalInstance* preInstance = aIterator.PreviousL();

			CleanupStack::PushL(preInstance);

			test(preInstance!=NULL);

			test(nextInstance->Time().TimeLocalL() >= preInstance->Time().TimeLocalL());

			CleanupStack::PopAndDestroy(preInstance);

			CleanupStack::PopAndDestroy(nextInstance);

			nextInstance = aIterator.NextL();

			CleanupStack::PushL(nextInstance);

			}

		test(nextInstance->Time().TimeLocalL() >= previousInstanceTime);

		previousInstanceTime = nextInstance->Time().TimeLocalL();

		aInstances.AppendL(nextInstance);

		CleanupStack::Pop(nextInstance);

		++count;

		test.Printf(_L("Instance count = %d"), count);

		}

	return count;

	}

void CTestMultipleCalendar::CheckInstanceViewL(CCalInstanceView& aInstanceView, TInt aNumInstance)

	{

	test.Printf(_L("Find the instances and verify the count \n"));

	RPointerArray<CCalInstance> calInstances;

	CleanupResetAndDestroyPushL(calInstances);

	TCalTime startCalTime;

	startCalTime.SetTimeUtcL(TCalTime::MinTime());

	TCalTime endCalTime;

	endCalTime.SetTimeUtcL(TCalTime::MaxTime());

	CalCommon::TCalTimeRange timeRange(startCalTime, endCalTime);

	aInstanceView.FindInstanceL(calInstances, CalCommon::EIncludeAll, timeRange);

	test(calInstances.Count() == aNumInstance);

	CleanupStack::PopAndDestroy(&calInstances);

	}

void CTestMultipleCalendar::CheckInstanceDetailsL(CCalInstance* aInstance, TCalInstanceId aInstanceId)

	{

	test.Printf(_L("test the instance time"));

	test(aInstance->Time().TimeLocalL() == iStartTime.TimeLocalL());

	test.Printf(_L("test the entry start and end times"));

	test(aInstance->Entry().StartTimeL().TimeLocalL() == iStartTime.TimeLocalL());

	test(aInstance->Entry().EndTimeL().TimeLocalL() == iEndTime.TimeLocalL());

	test.Printf(_L("test short file id"));

	test(aInstance->InstanceIdL().iCollectionId == aInstanceId.iCollectionId);	

	}

TBool CTestMultipleCalendar::CheckInstanceIdL(TCalInstanceId aId1, TCalInstanceId aId2)

	{

	TBool aReturn = ETrue;

	if(aId1.iEntryLocalId != aId2.iEntryLocalId)

		{

		aReturn = EFalse;

		}	

	if(aId1.iInstanceTime.TimeMode() != aId2.iInstanceTime.TimeMode())

		{

		aReturn = EFalse;

		}

	if(aId1.iInstanceTime.TimeLocalL() != aId2.iInstanceTime.TimeLocalL())

		{

		aReturn = EFalse;

		}

	if(aId1.iCollectionId != aId2.iCollectionId)

		{

		aReturn = EFalse;

		}

	return aReturn;

	}

/*

@SYMTestCaseID 				PIM-TCAL-MULTIPLE-FILES-0001

@SYMPreq					PREQ2554

@SYMTestCaseDesc			Make sure a session is closed when the last CCalSession referencing it is closed.

@SYMTestPriority            1

@SYMTestType                CIT

@SYMTestStatus 				Implemented

@SYMTestActions 			1.	Open a CCalSession object

							2.	Open a second CCalSession object, sharing the connection from the first

							3.	Destroy both CCalSession objects					

@SYMTestExpectedResults		There should be no memory leaks and the calendar server process should close 

							after destroying both CCalSession objects.

**/

void CTestMultipleCalendar::TestEntryViewAndFileConsistencyL(TBool aAddingSameEntry)

	{

	iTestLib->ReplaceFileL(KWorkCalendar);

	iTestLib->OpenFileL(KWorkCalendar);

	// Clear the previously stored files

	ClearStoredDataL();

	// Create the second session

	CreateSecondSessionL();

	CCalEntryView* secondView =CCalEntryView::NewL(*iSecondSession);

	CleanupStack::PushL(secondView);

	test.Printf(_L("Add one entry in each file \n"));

	if(aAddingSameEntry)

		{

		// Add an entry to the first calendar file

		AddAndCheckEntryL(iTestLib->SynCGetEntryViewL(), iTestLib->GetSession());

		// Add an entry to the second calendar file

		AddAndCheckEntryL(*secondView, *iSecondSession);

		}

	else

		{

		// Add an entry to the first calendar file

		AddAndCheckEntryL(iTestLib->SynCGetEntryViewL(), iTestLib->GetSession());

		// Add an entry to the second calendar file

		AddAndCheckEntryL(*secondView, *iSecondSession, EFalse);

		}

	CleanupStack::PopAndDestroy(secondView);

	test.Printf(_L("Server is shuting down \n") );