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

#include <calentry.h>

#include <calentryview.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

#include <e32test.h>

_LIT(KFormatDate, "%D%M%Y%/0%1%/1%2%/2%3%/3");

_LIT(KCalendarFile, "tCal_GsEntry");

class CDummyCalendarApp : public CBase

	{

public:

	static CDummyCalendarApp* NewLC();

	~CDummyCalendarApp();

	void DoTestL();

private:

	CDummyCalendarApp();

	void ConstructL();

	void OpenCleanFileL();

    void FillDefaultDatabaseL(TInt aTestCount, TBool aFloating, TBool aSummerTime = EFalse);

	void ExtractFromDatabaseL();

    void ExtractEntriesL(TBool aCompareWithExpectedNum = EFalse, TInt aExpectedNum = 0);

	void ExtractInstancesL();

	void ExtractNonExistentEntryL();

private: // member data

	CCalTestLibrary* iTestLib;

	CCalInstanceView* iInstanceView;

	CCalEntryView* iEntryView;

	TTestDataStruct* iCurrentTestData;

	};

CDummyCalendarApp* CDummyCalendarApp::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return (self);

	}

CDummyCalendarApp::~CDummyCalendarApp()

	{

	delete iTestLib;

	delete iCurrentTestData;

	}

CDummyCalendarApp::CDummyCalendarApp()

	{

	}

void CDummyCalendarApp::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	}

void CDummyCalendarApp::OpenCleanFileL()

	{

	iTestLib->ReplaceFileL(KCalendarFile);

	iTestLib->OpenFileL(KCalendarFile);

	iInstanceView = &iTestLib->SynCGetInstanceViewL();

	iEntryView = &iTestLib->SynCGetEntryViewL();

	}

void CDummyCalendarApp::FillDefaultDatabaseL(TInt aTestCount, TBool aFloating, TBool aSummerTime)

	{

	if (iCurrentTestData)

		{

		delete iCurrentTestData;

		iCurrentTestData = NULL;

		}

   	iCurrentTestData = CTestData::GetTestDataL((CTestData::TTestNumber)aTestCount, iInstanceView, iEntryView, aFloating, aSummerTime);

	}

static void ResetAndDestroyCalEntryArray(TAny* aPtr)

	{

	if (aPtr)

		{

		RPointerArray<CCalEntry>* array = static_cast<RPointerArray<CCalEntry>*>(aPtr);

		array->ResetAndDestroy();

		}

	}

// Helper method

// Extract all entries given by Guids in iCurrentTestData

void CDummyCalendarApp::ExtractEntriesL(TBool aCompareWithExpectedNum, TInt aExpectedNum)

	{

	// Extract entries by the GUIDs given in current-test-data's iGuids

	for(TInt a = 0; a < iCurrentTestData->iGuidsToExtract.Count(); a++)

		{

		TPtrC8 guid = iCurrentTestData->iGuidsToExtract[a];

		RPointerArray<CCalEntry> entryArray;

		CleanupStack::PushL(TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray));

		iEntryView->FetchL(guid, entryArray);

		test.Printf(_L("%d GS entries fetched\n"), entryArray.Count());

        if (aCompareWithExpectedNum)

            {

            test.Printf(_L("%d entries were expected"), aExpectedNum);

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

            }

		CCalEntry* entryPtr;

		for(TInt a = 0; a < entryArray.Count(); a++)

			{

			entryPtr = entryArray[a];

			if(a==0)

				{

				test.Printf(_L("Parent -> SeqNum:%d\n"), entryPtr->SequenceNumberL());

				}

			else

				{

				TBuf<16> recIdTimeBuf;

				TTime recIdTime = entryPtr->RecurrenceIdL().TimeLocalL();

				recIdTime.FormatL(recIdTimeBuf, KFormatDate());

				test.Printf(_L("Child  -> SeqNum:%d, RecID: %S\n"), entryPtr->SequenceNumberL(), &recIdTimeBuf);

				}

			}

		CleanupStack::Pop(); // TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray)

		entryArray.ResetAndDestroy();

		}

	}

// Helper method

// Extract all instances given by Guids in iCurrentTestData

void CDummyCalendarApp::ExtractInstancesL()

	{

	TCalTime startDate;

	startDate.SetTimeLocalL(iCurrentTestData->iStartDate);

	TCalTime endDate;

	endDate.SetTimeLocalL(iCurrentTestData->iEndDate);

	CalCommon::TCalTimeRange timeRange(startDate, endDate);

	RPointerArray<CCalInstance> instanceArray;

	if (iCurrentTestData->iSearchString)

		{

		CCalInstanceView::TCalSearchParams searchParams(*iCurrentTestData->iSearchString, iCurrentTestData->iSearchBehaviour);

		iInstanceView->FindInstanceL(instanceArray, 

									(CalCommon::TCalViewFilter)iCurrentTestData->iFilter, 

									timeRange, 

									searchParams);

		}

	else

		{

		iInstanceView->FindInstanceL(instanceArray, 

							(CalCommon::TCalViewFilter)iCurrentTestData->iFilter, 

							timeRange);		

		}

	TBuf<26> startBuf;

	TBuf<26> endBuf;

	startDate.TimeLocalL().FormatL(startBuf,KFormatDate());

	endDate.TimeLocalL().FormatL(endBuf,KFormatDate());

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

	if (instanceArray.Count() == 0)

		{

		test.Printf(_L("No instances found\n"));

		}

	else

		{

		TInt instanceCount = 0;

		TTime instTime;

		TBuf<26> instBuf;

		while (instanceCount < instanceArray.Count())

			{

			CCalInstance* inst = instanceArray[instanceCount];

			CleanupStack::PushL(inst);

			instTime = inst->Time().TimeLocalL();

			instTime.FormatL(instBuf,KFormatDate());

			TBuf<62> 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:

						ASSERT(0);

						break;

					}

				}

			test.Printf(_L("One instance is on %S, %d:%d - %S"), &instBuf, instTime.DateTime().Hour(), instTime.DateTime().Minute(), &rptType);

			if (iCurrentTestData->iTimes.Find(instTime) == KErrNotFound)

				{

				test.Printf(_L("THIS ENTRY WAS NOT EXPECTED\n"));

				test(0);

				}

			instanceCount++;

			CleanupStack::Pop(inst);

			}

		if (iCurrentTestData->iFunction)

			ASSERT(iCurrentTestData->iFunction->CallBack() == 0);

		}

	if (instanceArray.Count() != iCurrentTestData->iTimes.Count())

		{

		test.Printf(_L("Some expected entries were not found!\n"));

		test(0);	

		}

	instanceArray.ResetAndDestroy();

	}

void CDummyCalendarApp::ExtractFromDatabaseL()

	{

	// Print test's description

	// Check if description field is longer than 124 characters and split the print if it is.

	// (printf does not seem to handle string length > 124)

	TInt len(iCurrentTestData->iDescription.Length());

	if(len > 124)

		{

		TInt num(len / 124);

		TBuf<TTestDataStruct::KDescriptionLen> tmpBuff(iCurrentTestData->iDescription);

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

			{

			test.Printf(_L("%.124S"), &tmpBuff);

			tmpBuff.Delete(0, 124);

			}

		if(tmpBuff.Length())

			{

			test.Printf(_L("%S\n"), &tmpBuff);

			}

		}

	else

		{

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

		}	

	if(iCurrentTestData->iTestType == TTestDataStruct::EEntryTest)

		{

		ExtractEntriesL();

		}

	else if(iCurrentTestData->iTestType == TTestDataStruct::EInstanceTest)

		{

		ExtractInstancesL();

		}

	}

void CDummyCalendarApp::ExtractNonExistentEntryL()

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupStack::PushL(TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray));

	// Passing string type UID parameter and expecting entryArray to be empty

	iEntryView->FetchL( _L8("myuid"), entryArray);

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

	entryArray.Reset();

	// Passing integer type UID parameter and expecting entryArray to be empty

	iEntryView->FetchL( _L8("10"), entryArray);

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

	CleanupStack::Pop(); // TCleanupItem(ResetAndDestroyCalEntryArray, &entryArray)

	entryArray.ResetAndDestroy();

	}

void CDummyCalendarApp::DoTestL()

	{

	TInt testCount(0);

	while (testCount < CTestData::ENumberOfTestsForFixedAndFloating)

		{

		OpenCleanFileL();

		FillDefaultDatabaseL(testCount, EFalse);

		ExtractFromDatabaseL();

		testCount++;

		iTestLib->CleanDatabaseL();

		}

	// repeat the above test for floating entry

	/**

	@SYMTestCaseID PIM-TCAL-GSENTRY-Floating_Parent_And_Child_Entry-0001

	@SYMTestCaseDesc Create floating parent and child entries

	@SYMFssID App-Engines/CalInterimAPI/Data.007

	@SYMTestStatus Implemented

	@SYMTestPriority Medium

	@SYMTestActions Create floating parent and child entries with various combination of repeating rule, excption dates, and RDates. 

	Store the entries, then check that the expected instances can be retrieved.

	@SYMTestExpectedResults The check shows that the instances defined by the repeated rule and exception dates and RDates are found

	@SYMTestType CT	

	*/

	testCount = 0;

	while (testCount < CTestData::ENumberOfTests)

		{

		OpenCleanFileL();

		FillDefaultDatabaseL(testCount, ETrue);

		ExtractFromDatabaseL();

		testCount++;

		iTestLib->CleanDatabaseL();

		}

    //Test with Local floating time the replacement of existing child entry

    OpenCleanFileL();

    //Fill the database with entries in LocalFloating format and with August dates

    //to get difference between UTC and Local time

    FillDefaultDatabaseL(CTestData::EReplaceExistingChild, ETrue, ETrue);

    ExtractEntriesL(ETrue, 3);//check the entries count, it should be 3

	//Test added for DEF069038

	ExtractNonExistentEntryL();

	}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

 * DoTestL()

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

static void DoTestL()

	{

	CDummyCalendarApp* app = CDummyCalendarApp::NewLC();

	TPerformanceTimer timer(test);

	timer.Start();

	// Run the test suite

	app->DoTestL();

	timer.Stop();

	test.Printf(_L("Done\n"));

	// printout performance time

	timer.PrintOut();

	CleanupStack::PopAndDestroy(app);

	}

/**

@SYMTestCaseID     PIM-TCAL-GSENTRY-0001

*/

TInt E32Main()

    {

	__UHEAP_MARK;

	test.Start(_L("@SYMTESTCaseID:PIM-TCAL-GSENTRY-0001 Calendar Interim API Group Scheduling 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);

    }