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

#include <calinstanceiterator.h>

RTest test(_L("tcal_instance"));

_LIT(KFormatDate, "%D%M%Y%/0%1%/1%2%/2%3%/3");
_LIT(KFormatDateTime, "%D%M%Y%/0%1%/1%2%/2%3%/3 %H:%T:%S.%C");
_LIT(KCalendarFile, "tcal_instance");

class CInstanceTestManager : public CBase
	{
public:
	enum TTestAPI
		{
		EFindInstance,
		EIteratorNextInstance,
		ETotalTestAPI
		};
public:
	static CInstanceTestManager* NewLC();
	~CInstanceTestManager();
	
	inline void CleanDatabaseL();
	void TestPopulateAndCheckL(TInt aTestAPI);
	void TestEditAndCheckL(TInt aTestAPI);	


private:

	// avoid any method but NewL instancing the class
	CInstanceTestManager() {	}
	// no copy constructor and assignment operator
	CInstanceTestManager(CInstanceTestManager& );
	CInstanceTestManager& operator = (const CInstanceTestManager& );

	void ConstructL();

	void ExtractFromDatabaseL(CTestDataStruct& aTestData, TInt aTestAPI);
	void EditEntriesL();


private: // member data
	CCalTestLibrary*  iTestLibrary;
	
	CCalEntryView*    iEntryView;	// not owned
	CCalInstanceView* iInstanceView;// not owned
	};


CInstanceTestManager* CInstanceTestManager::NewLC()
	{
	CInstanceTestManager* self = new (ELeave) CInstanceTestManager();
	
	CleanupStack::PushL(self);
	self->ConstructL();
	
	return (self);
	}
	

CInstanceTestManager::~CInstanceTestManager()
	{
	TRAP_IGNORE(iTestLibrary->DeleteFileL(KCalendarFile));
	delete iTestLibrary;
	}


void CInstanceTestManager::ConstructL()
	{
	iTestLibrary = CCalTestLibrary::NewL();

	iTestLibrary->ReplaceFileL(KCalendarFile());
	iTestLibrary->OpenFileL(KCalendarFile());

	iInstanceView = &iTestLibrary->SynCGetInstanceViewL();
	iEntryView = &iTestLibrary->SynCGetEntryViewL();
	}
	
	
inline void CInstanceTestManager::CleanDatabaseL()
	{
	iTestLibrary->CleanDatabaseL();		
	}


void CInstanceTestManager::TestPopulateAndCheckL(TInt aTestAPI)
	{
	TInt testStart = 0; 
	TInt testEnd = CTestData::ENumberOfTests;


	for(TInt i = testStart; i < testEnd; ++i)
		{
		CTestDataStruct* testData = CTestData::GenerateTestDataLC((CTestData::TTestNumber)i, iInstanceView, iEntryView);

		ExtractFromDatabaseL(*testData, aTestAPI);

		CleanupStack::PopAndDestroy(testData);

		CleanDatabaseL();
		}		
	}


void CInstanceTestManager::TestEditAndCheckL(TInt aTestAPI)
	{
	TInt testStart = 0; 
	TInt testEnd = CTestData::ENumberOfTests;
	
	
	for(TInt j = testStart; j < testEnd; ++j)
		{
		CTestDataStruct* testData = CTestData::GenerateTestDataLC((CTestData::TTestNumber)j, iInstanceView, iEntryView);
		EditEntriesL();
		ExtractFromDatabaseL(*testData, aTestAPI);

		CleanupStack::PopAndDestroy(testData);

		CleanDatabaseL();
		}			
	}


// Edit entries
void CInstanceTestManager::EditEntriesL()
	{
	CCalIter& iter = iTestLibrary->GetIterL();
	
	for( TPtrC8 Uid(iter.FirstL()); Uid != KNullDesC8(); Uid.Set(iter.NextL()) )
		{
		RPointerArray<CCalEntry> entryList;
		CleanupResetAndDestroyPushL(entryList);

		iEntryView->FetchL(Uid, entryList);
		// can't update child entries, so only the first entry in entryList can be used
		while (entryList.Count() > 1)
			{
			delete entryList[1];
			entryList.Remove(1);
			}
		
		entryList[0]->SetSequenceNumberL( 0 );
		// don't remove the original summary as it is used in text search tests 
		TBuf<256> summary;
		summary.Copy(entryList[0]->SummaryL());
		summary.Append( _L("0123456789 qwertyuiopasdfghjklzxcvbnm") );
		entryList[0]->SetSummaryL(summary);
		
		TInt updated = 0;

		iEntryView->UpdateL(entryList, updated);

		test( entryList.Count() == updated );		

		CleanupStack::PopAndDestroy(&entryList);		
		}
	}


// Call FindInstanceL and check the results
void CInstanceTestManager::ExtractFromDatabaseL(CTestDataStruct& aTestData, TInt aTestAPI)
	{
	TCalTime startDate;
	startDate.SetTimeLocalL(aTestData.iStartDate);
	TCalTime endDate;
	endDate.SetTimeLocalL(aTestData.iEndDate);

	CalCommon::TCalTimeRange timeRange(startDate, endDate);

	test.Printf(_L("TEST: %S\n"), &aTestData.iDescription);

	RPointerArray<CCalInstance> instanceArray;
	CleanupResetAndDestroyPushL(instanceArray);

	switch (aTestAPI)
		{
		case EFindInstance:
			{
			test.Printf(_L("EFindInstance\n"));
			
			if (aTestData.iSearchString)
				{
				CCalInstanceView::TCalSearchParams searchParams(*aTestData.iSearchString, aTestData.iSearchBehaviour);
				
				iInstanceView->FindInstanceL(instanceArray, aTestData.iFilter, timeRange, searchParams);
				}
			else
				{
				iInstanceView->FindInstanceL(instanceArray, aTestData.iFilter, timeRange);		
				}
			}
			break;
		case EIteratorNextInstance:
			{
			test.Printf(_L("EIteratorNextInstance\n"));
			
			if (aTestData.iFilter & CalCommon::EIncludeRptsNextInstanceOnly)
				{
				// the iterator does not support this filter flag so return
				CleanupStack::PopAndDestroy(&instanceArray);
				return;			
				}
			
			CCalFindInstanceSettings* findInstanceSettings = CCalFindInstanceSettings::NewL(aTestData.iFilter, timeRange);
			CleanupStack::PushL(findInstanceSettings);
			
			if (aTestData.iSearchString)
				{
				CCalInstanceView::TCalSearchParams searchParams(*aTestData.iSearchString, aTestData.iSearchBehaviour);
				findInstanceSettings->SetTextSearchL(searchParams);
				}
			
			CCalInstanceIterator* iterator = iInstanceView->FindInstanceL(*findInstanceSettings);
			CleanupStack::PopAndDestroy(findInstanceSettings);
			CleanupStack::PushL(iterator);
			
			while (CCalInstance* instance = iterator->NextL())
				{
				instanceArray.AppendL(instance);
				}
			
			CleanupStack::PopAndDestroy(iterator);
			}
			break;
		default:
			{
			test(EFalse);
			}
		}
	
	

	TBuf<50> startBuf;
	TBuf<50> endBuf;
	startDate.TimeLocalL().FormatL(startBuf,KFormatDate());
	endDate.TimeLocalL().FormatL(endBuf,KFormatDate());

	test.Printf(_L("Checking instances between %S and %S\n"), &startBuf, &endBuf);

	if (aTestData.iFunction)
		{
		ASSERT(aTestData.iFunction->CallBack() == 0); // this fails if test function returns non-zero
		aTestData.iFunction->iPtr = NULL;	// the callback is a one shot function that deletes the object..
		}
	
	if (instanceArray.Count() == 0)
		{
		test.Printf(_L("No instances found\n"));
		}
	else
		{
		TTime instTime;
		TTime instStartTime;
		TTime instEndTime;
		
		TBuf<50> instBuf;
		TBuf<50> instStartBuf;
		TBuf<50> instEndBuf;
		
		for (TInt instanceCount = 0; instanceCount < instanceArray.Count(); ++instanceCount)
			{
			CCalInstance* inst = instanceArray[instanceCount];
			instTime = inst->Time().TimeLocalL();
			instStartTime = inst->StartTimeL().TimeLocalL();
			instEndTime = inst->EndTimeL().TimeLocalL();
			
			instTime.FormatL(instBuf,KFormatDate());
			instStartTime.FormatL(instStartBuf,KFormatDateTime());
			instEndTime.FormatL(instEndBuf,KFormatDateTime());
			
			instBuf.Append(_L(" "));
			instBuf.AppendNum(instTime.DateTime().Hour());
			instBuf.Append(_L(":"));
			instBuf.AppendNum(instTime.DateTime().Minute());
			
			TBuf<32>  rptType;
			TCalRRule rptDef;
			if (!inst->Entry().GetRRuleL(rptDef))
				{
				rptType.Copy(_L("One off"));
				}
			else
				{
				switch (rptDef.Type())
					{
					case TCalRRule::EDaily:
						rptType.Format(_L("Daily every %d days"), rptDef.Interval());
						break;
					case TCalRRule::EWeekly:
						rptType.Format(_L("Weekly every %d weeks"), rptDef.Interval());
						break;
					case TCalRRule::EMonthly:
						rptType.Format(_L("MonthlyByDates every %d months"), rptDef.Interval());
						break;
					case TCalRRule::EYearly:
						rptType.Format(_L("YearlyByDate every %d years"), rptDef.Interval());
						break;
					default:
						test(0); // should never get here unless somehow a repeat rule has an invalid type!
						break;
					}
				}

			TBool instanceNotExpected = EFalse;
				
			if (inst->Entry().EntryTypeL() == CCalEntry::ETodo)
				{
				// For a todo the 'end time' is the 'time' of the instance
				TDateTime dateTime = instEndTime.DateTime();
								
				//**NOTE**//
				//In case of undated ToDo's the instance time is current time, it may change slightly as
				//the FindInstance() and other operations take some amount of time thereby changing the
				//seconds and microseconds, which will cause the test condition below to fail.
				//So,while adding Expected instance time to aTestData.iTimes, we set the seconds
				//and microseconds to 0.
				//Now, to match that time we need to set the seconds and microseconds
				//of retrieved instance time to 0 as well.
					
				dateTime.SetMicroSecond(0);
				dateTime.SetSecond(0);
				instEndTime = TTime(dateTime);

				if (aTestData.iTimes.Find(instEndTime) == KErrNotFound)
					{
					instanceNotExpected = ETrue;
					}
				}
			else
				{
				if (aTestData.iTimes.Find(instTime) == KErrNotFound && instStartTime == instTime)
					{
					instanceNotExpected = ETrue;
					}
				}
				
#ifdef __WINS__
			test.Printf(_L("One instance is on %S to %S - %S\n"), &instStartBuf, &instEndBuf, &rptType);
			if (instanceNotExpected)
				{
				test.Printf(_L("THIS ENTRY WAS NOT EXPECTED"));
				test(0);
				}
#else
// don't output every instance on non-WINS environment because the log size is too great
			if (instanceNotExpected)
				{
				test.Printf(_L("Unexpected instance at %S to %S - %S\n"), &instStartBuf, &instEndBuf, &rptType);
				test(0);
				}
#endif
			}
		}
		
	if (instanceArray.Count() != aTestData.iTimes.Count())
		{
		test.Printf(_L("Some expected entries were not found!"));
		test(0);	
		}
		
	CleanupStack::PopAndDestroy(&instanceArray);
	}


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * DoTestL()
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	
LOCAL_C void DoTestL()
	{
	CInstanceTestManager* testManager = CInstanceTestManager::NewLC();


	TPerformanceTimer timer(test);
	timer.Start();


	// Run the test suite

	for (TInt i(0) ; i < CInstanceTestManager::ETotalTestAPI ; ++i)
		{
		testManager->CleanDatabaseL();
		testManager->TestPopulateAndCheckL(i);
		testManager->TestEditAndCheckL(i);
		}


	timer.Stop();
	test.Printf(_L("Done\n"));
	// printout performance time
	timer.PrintOut();	


	CleanupStack::PopAndDestroy(testManager);	
	}


/**
@SYMTestCaseID     PIM-TCAL-INSTANCE-0001
*/
TInt E32Main()
    {
	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-INSTANCE-0001 Calendar Interim API Instance test suite"));
	test.Title();

	CTrapCleanup* trapCleanup = CTrapCleanup::New();
	if (!trapCleanup)
		{
		return KErrNoMemory;
		}

	CActiveScheduler* scheduler = new CActiveScheduler();
	if (!scheduler)
		{
		delete trapCleanup;
		return KErrNoMemory;
		}
	CActiveScheduler::Install(scheduler);	

	TRAPD(ret, DoTestL());
	test(ret == KErrNone);
	
	delete scheduler;
	delete trapCleanup;	

	test.End();
	test.Close();

	__UHEAP_MARKEND;

	return (KErrNone);
    }