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

#include <e32std.h>

#include <s32file.h>

#include <s32mem.h>

#include <caldataexchange.h>

#include <calentryview.h>

#include <calrrule.h>

#include <calalarm.h>

#include <caliterator.h>

#include <caldataformat.h>

#include <coreappstest/testserver.h>

#include "caltestlib.h"

// This testcode reproduces defect EDNSAID-4A6HSS (ER5 defects database)

// "Time is being shifted at IrDA Transfer"

// 

// In order to test that this defect is fixed, a vCalendar stream containing 

// 3 appointments and a to-do item is exported.  This provides 100% coverage of 

// all date/time properties used in Agenda Model.  The following properties are

// exported : LAST-MODIFIED, DTSTART, DTEND, DUE, AALARM, EXDATE, RRULE.

//

// To check that the test was successful, the localised vCalendar stream is imported

// and the entries are compared to the original entry definitions to check they have

// the same start/end times etc.  These files can also be inspected manually.  They 

// should be identical, other than minor differences in the last modified date.   

static RTest test(_L("T_VCAL4"));

_LIT(KFrenchFile,"c:\\french.vcs");

_LIT(KHomeFile,"c:\\home.vcs");

_LIT(KJapanFile,"c:\\japan.vcs");

_LIT(KNewYorkFile,"c:\\newyork.vcs");

_LIT(KTempFileName,"c:\\temp.vcs");

_LIT(KUkFile,"c:\\uk.vcs");

_LIT8(KAsiaTokyo, "Asia/Tokyo");

_LIT8(KEuropeLondon, "Europe/London");

_LIT8(KAmericaNewYork, "America/New_York");

_LIT8(KGuidAppt,		"t_vcal_guid_appt");

_LIT8(KGuidAlarmAppt,	"t_vcal_guid_alarmappt");

_LIT8(KGuidTodo,		"t_vcal_guid_todo");

_LIT8(KGuidAnniv,		"t_vcal_guid_anniv");

_LIT(KTestCalendarFile,		"c:t_vcal4");

class CTestApp : public CBase

	{

public:

	static CTestApp* NewL();

	~CTestApp();

	void CreateToDoL();

	void CreateAppointmentL();

	void CreateAnniversaryEntryL();

	void CreateTimedAlarmedApptEntryL();

	void ExportAsVCalendarL(const TDesC& aVCalendarStream, RPointerArray<CCalEntry>& aEntries, const TDesC8& aTimeZone);

	void ExportAsVCalendarL(const TDesC& aVCalendarStream);

	void DoSyncMLExportTestL();

	void SummaryOrDescriptionOnlyTestL();

	void CheckLastChangedDateOnVcalImportL();

	void CleanFileL();

	void ImportAsVCalendarL(const TDesC& aVCalendarStream);

	void DeleteFile(const TDesC& aFileName);

	void CheckEntriesL();

	TBool AreFilesToBeDeleted() //Leave files in the c drive if there is an error for debugging purposes

	    {

		return iDeleteFiles;

	    }

private:

    CTestApp();

	void ConstructL();

	TInt Diff(RFile anInFile, RFile anOutFile);

	void CheckOutputL(const TDesC& aFile, const TDesC& aFile2);

	TInt ContainsTextL(const TDesC& aFileName, const TDesC8& aText);

private:

	CCalTestLibrary* iCalTestLib;

	TCalTime iToday;

	TBool iDeleteFiles;

	};

CTestApp* CTestApp::NewL()

	{

	CTestApp* self = new(ELeave) CTestApp;

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CTestApp::DeleteFile(const TDesC& aFileName)

	{

	iCalTestLib->FileSession().Delete(aFileName);

	}

void CTestApp::ConstructL()

	{

	iCalTestLib = CCalTestLibrary::NewL();

	iCalTestLib->ReplaceFileL(KTestCalendarFile);

	iCalTestLib->OpenFileL(KTestCalendarFile);

	iToday.SetTimeLocalL(TTime(_L("20051123:120000.000000"))); // 12:00 23rd November 2005

	}

CTestApp::CTestApp() : 	iDeleteFiles(ETrue)

{}

CTestApp::~CTestApp()

	{

	delete iCalTestLib;

	}

void CTestApp::CleanFileL()

	{

	iCalTestLib->CleanDatabaseL();

	}

TInt CTestApp::Diff(RFile anInFile, RFile anOutFile)

	{

	TBuf8<256> inBuf;

	TBuf8<256> outBuf; 

	do	{

		inBuf.SetLength(0);

		outBuf.SetLength(0);

		anInFile.Read(inBuf, 256);

		anOutFile.Read(outBuf, 256);

		TInt err = inBuf.Compare(outBuf);

		if (err)

			{

		    iDeleteFiles = EFalse;

			return err;

			}

		}

	while (inBuf.Length() && outBuf.Length());

	return KErrNone;

	}

void CTestApp::CheckOutputL(const TDesC& aFile, const TDesC& aFile2)

	{

	RFile inFile;

	User::LeaveIfError(inFile.Open(iCalTestLib->FileSession(), aFile, EFileRead));

	CleanupClosePushL(inFile);

	RFile outFile;

	User::LeaveIfError(outFile.Open(iCalTestLib->FileSession(), aFile2, EFileRead));

	CleanupClosePushL(outFile);

	TInt err = Diff(inFile, outFile);

	inFile.Close();

	outFile.Close();

	test(err==KErrNone);

	CleanupStack::PopAndDestroy(2);

	}

// Create a to-do item, with a due date of five days after the testcode is run.

//

void CTestApp::CreateToDoL()

	{

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

	CCalEntry* todo = iCalTestLib->CreateCalEntryL(CCalEntry::ETodo, guid);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(todo);

	TCalTime startTime;

	startTime.SetTimeLocalL(iToday.TimeLocalL() + TTimeIntervalDays(5));

	TCalTime endTime;

	endTime.SetTimeLocalL(iToday.TimeLocalL() + TTimeIntervalDays(6));

	todo->SetStartAndEndTimeL(startTime, endTime);

	todo->SetSummaryL(_L("A to-do entry"));

	todo->SetCompletedL(ETrue, iToday);

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(todo);

	TInt numSuc;

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

	CleanupStack::PopAndDestroy(); // entryArray.close()

	CleanupStack::PopAndDestroy(todo);

	}

// Create a one hour appointment between 9-10am on the day the testcode is run.

//

void CTestApp::CreateAppointmentL()

	{

	TCalTime startTime;

	startTime.SetTimeLocalL(TDateTime(iToday.TimeLocalL().DateTime().Year(), iToday.TimeLocalL().DateTime().Month(), iToday.TimeLocalL().DateTime().Day(),9,0,0,0));

	TCalTime endTime;

	endTime.SetTimeLocalL(startTime.TimeLocalL() + TTimeIntervalMinutes(60));

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

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

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	entry->SetStartAndEndTimeL(startTime, endTime);

	entry->SetSummaryL(_L("An Appointment"));

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(entry);

	TInt numSuc;

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

	CleanupStack::PopAndDestroy(); // entryArray.close()

	CleanupStack::PopAndDestroy(entry);

	}

// Create a repeating entry.

// The repeat is set for yearly on June 24th starting in 1998, with the exception of 24/06/2000

//

void CTestApp::CreateAnniversaryEntryL()

	{

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

	CCalEntry* entry = iCalTestLib->CreateCalEntryL(CCalEntry::EAnniv, guid);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	entry->SetSummaryL(_L("Anniversary of company"));

	TCalTime symbianCreation;

	symbianCreation.SetTimeLocalL(TTime(TDateTime(1998,EJune,24,0,0,0,0)));

	entry->SetStartAndEndTimeL(symbianCreation, symbianCreation);

	TCalRRule rRule(TCalRRule::EYearly);

	rRule.SetDtStart(symbianCreation);

	rRule.SetInterval(1);

	TCalTime maxTime;

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

	rRule.SetUntil(maxTime);

	entry->SetRRuleL(rRule);

	RArray<TCalTime> exceptions;

	CleanupClosePushL(exceptions);

	TCalTime exception;

	exception.SetTimeLocalL(TTime(TDateTime(2000,EJune,24,0,0,0,0)));

	exceptions.AppendL(exception);

	entry->SetExceptionDatesL(exceptions);

	CleanupStack::PopAndDestroy(); // exceptions.close()

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(entry);

	TInt numSuc;

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

	CleanupStack::PopAndDestroy(); // entryArray.close()

	CleanupStack::PopAndDestroy(entry); // entry

	}

// Create an alarmed appointment

//

void CTestApp::CreateTimedAlarmedApptEntryL()

	{

	TCalTime startTime;

	startTime.SetTimeLocalL(TDateTime(iToday.TimeLocalL().DateTime().Year(), iToday.TimeLocalL().DateTime().Month(), iToday.TimeLocalL().DateTime().Day(),10,0,0,0));

	TCalTime endTime;

	endTime.SetTimeLocalL(startTime.TimeLocalL() + TTimeIntervalMinutes(90));

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

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

	CleanupStack::Pop(guid);

	CleanupStack::PushL(entry);

	entry->SetStartAndEndTimeL(startTime, endTime);

	entry->SetSummaryL(_L("app engines weekly meeting APPOINTMENT"));

	CCalAlarm* alarm = CCalAlarm::NewL();

	CleanupStack::PushL(alarm);

	alarm->SetAlarmSoundNameL(_L("Fanfare"));

	alarm->SetTimeOffset(TTimeIntervalMinutes(15));// entry->SetAlarm(0,15);

	entry->SetAlarmL(alarm);

	CleanupStack::PopAndDestroy(alarm);

	RPointerArray<CCalEntry> entryArray;

	CleanupClosePushL(entryArray);

	entryArray.AppendL(entry);

	TInt numSuc;

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

	CleanupStack::PopAndDestroy(); // entryArray.close()

	CleanupStack::PopAndDestroy(entry);

	}

// Export vCalendar file

//

void CTestApp::ExportAsVCalendarL(const TDesC& aVCalendarStream)

	{

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	CCalIter* calIter = CCalIter::NewL(iCalTestLib->GetSession());

	CleanupStack::PushL(calIter);

	for (TDesC8* guid = const_cast<TDesC8*>(&calIter->FirstL());

			guid->CompareF(KNullDesC8) != 0;

			guid = const_cast<TDesC8*>(&calIter->NextL()))

		{

		iCalTestLib->SynCGetEntryViewL().FetchL(*guid, entryArray);

		}

	CleanupStack::PopAndDestroy(calIter);

	RFile outFile;

	User::LeaveIfError(outFile.Replace(iCalTestLib->FileSession(), aVCalendarStream, EFileWrite));

	RFileWriteStream writeStream(outFile);

	iCalTestLib->DataExchangeL().ExportL(KUidVCalendar, writeStream, entryArray);

	writeStream.Close();

	outFile.Close();

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

	}

// Import vCalendar stream

//

void CTestApp::ImportAsVCalendarL(const TDesC& aVCalendarStream)

	{

	test.Next(_L("Importing all entries"));

	RFile infile;

	infile.Open(iCalTestLib->FileSession(), aVCalendarStream, EFileRead);

	RFileReadStream readStream(infile);

	// Create ptr array for new entries

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	iCalTestLib->DataExchangeL().ImportL(KUidVCalendar, readStream, entryArray);

	readStream.Close();

	infile.Close();

	TInt numSuc;

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

	CleanupStack::PopAndDestroy(&entryArray); // entryArray.Close()

	}

void CTestApp::CheckLastChangedDateOnVcalImportL()

	{

	test.Next(_L("Check last changed date on vcard import..."));

	_LIT8(KVcal,	"BEGIN:VCALENDAR\r\n"

					"VERSION:1.0\r\n"

					"BEGIN:VEVENT\r\n"

					"UID:4\r\n"

					"SUMMARY:test\r\n"

					"DTSTART:20021120T090000Z\r\n"

					"DTEND:20021120T100000Z\r\n"

					"X-EPOCAGENDAENTRYTYPE:APPOINTMENT\r\n"

					"CLASS:PUBLIC\r\n"

					"LAST-MODIFIED:20021120T152700Z\r\n"

					"PRIORITY:0\r\n"

					"STATUS:NEEDS ACTION\r\n"

					"END:VEVENT\r\n"

					"END:VCALENDAR\r\n");

	_LIT(KDateTime,"20/11/2002 15:27:00");

	TTime lastChangedDateExpected;

	lastChangedDateExpected.Parse(KDateTime);

	TBuf<30> dateString;

	TBuf<30> timeString;

	_LIT(KExpectedDateFormat,"Expected date: %S %S\n");

	_LIT(KImportedDateFormat,"Imported date: %S %S\n");

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

	_LIT(KTimeString,"%-B%:0%J%:1%T%:2%S%:3%+B");

	lastChangedDateExpected.FormatL(dateString,KDateString);

	lastChangedDateExpected.FormatL(timeString,KTimeString);

	test.Printf(KExpectedDateFormat,&dateString,&timeString);

	RDesReadStream readStream(KVcal);

	CleanupClosePushL(readStream);

	// Create ptr array for new entries

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	//Import vcal

	iCalTestLib->DataExchangeL().ImportL(KUidVCalendar, readStream, entryArray);

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

	CCalEntry* entry = entryArray[0];

	//Print last changed date from the entry imported

	entry->LastModifiedDateL().TimeUtcL().FormatL(dateString,KDateString);

	entry->LastModifiedDateL().TimeUtcL().FormatL(timeString,KTimeString);

	test.Printf(KImportedDateFormat,&dateString,&timeString);

	//Check last changed date

	test(entry->LastModifiedDateL().TimeUtcL() == lastChangedDateExpected);

	//now add the entry 

	RPointerArray<CCalEntry> storeEntryArray;

	CleanupClosePushL(storeEntryArray);

	storeEntryArray.AppendL(entry);

	TInt numSuc;

	iCalTestLib->SynCGetEntryViewL().StoreL(storeEntryArray, numSuc);

	CleanupStack::PopAndDestroy(); // entryArray.close()

	//Check that the add entry hasn't changed the date

	test(entry->LastModifiedDateL().TimeLocalL() == lastChangedDateExpected); 

	lastChangedDateExpected=entry->LastModifiedDateL().TimeLocalL();

	// test that an update does change the last modified date

	RPointerArray<CCalEntry> updateEntryArray;

	CleanupClosePushL(updateEntryArray);

	updateEntryArray.AppendL(entry);

	iCalTestLib->SynCGetEntryViewL().UpdateL(updateEntryArray, numSuc);

	CleanupStack::PopAndDestroy(); // updateEntryArray.close()

	TTime fetchedChangedDate = entry->LastModifiedDateL().TimeLocalL();

	test(fetchedChangedDate != lastChangedDateExpected); 

	CleanupStack::PopAndDestroy(2,&readStream); //entryArray

	}

// Check that the entries are correct when they are imported

//

void CTestApp::CheckEntriesL()

	{	

	RPointerArray<CCalEntry> entryArray;

	CleanupResetAndDestroyPushL(entryArray);

	// todo

	iCalTestLib->SynCGetEntryViewL().FetchL(KGuidTodo, entryArray);

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

	test.Printf(_L("Testing the todo; %S\n"), &entryArray[0]->SummaryL());

	test(entryArray[0]->EntryTypeL() == CCalEntry::ETodo);

	test(entryArray[0]->StartTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 28, 12, 0, 0, 0)));

	test(entryArray[0]->EndTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 29, 12, 0, 0, 0)));

	test(entryArray[0]->CompletedTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 23, 12, 0, 0, 0)));

	// anniv

	entryArray.ResetAndDestroy();

	iCalTestLib->SynCGetEntryViewL().FetchL(KGuidAnniv, entryArray);

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

	test.Printf(_L("Testing the anniv; %S\n"), &entryArray[0]->SummaryL());

	test(entryArray[0]->EntryTypeL() == CCalEntry::EAnniv);

	test(entryArray[0]->StartTimeL().TimeUtcL() == TTime(TDateTime(1998,EJune,23,23,0,0,0)));

	test(entryArray[0]->EndTimeL().TimeUtcL() == TTime(TDateTime(1998,EJune,23,23,0,0,0)));

	// appt

	entryArray.ResetAndDestroy();

	iCalTestLib->SynCGetEntryViewL().FetchL(KGuidAppt, entryArray);

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

	test.Printf(_L("Testing the appt; %S\n"), &entryArray[0]->SummaryL());

	test(entryArray[0]->EntryTypeL() == CCalEntry::EAppt);

	test(entryArray[0]->StartTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 23, 9, 0, 0, 0)));

	test(entryArray[0]->EndTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 23, 10, 0, 0, 0)));

	// alarmed appt

	entryArray.ResetAndDestroy();

	iCalTestLib->SynCGetEntryViewL().FetchL(KGuidAlarmAppt, entryArray);

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

	test.Printf(_L("Testing the alarmed appt; %S\n"), &entryArray[0]->SummaryL());

	test(entryArray[0]->EntryTypeL() == CCalEntry::EAppt);

	test(entryArray[0]->StartTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 23, 10, 0, 0, 0)));

	test(entryArray[0]->EndTimeL().TimeUtcL() == TTime(TDateTime(2005, EDecember, 23, 11, 30, 0, 0)));

	CCalAlarm* alarm = entryArray[0]->AlarmL();

	CleanupStack::PushL(alarm);

	test(alarm != NULL);

	test(alarm->TimeOffset() == TTimeIntervalMinutes(15));

	CleanupStack::PopAndDestroy(alarm);

	CleanupStack::PopAndDestroy(&entryArray);	

	}

//

void CTestApp::ExportAsVCalendarL(const TDesC& aVCalendarStream, RPointerArray<CCalEntry>& aEntries, const TDesC8& aTimeZone)

	{

    RPIMTestServer serv3;

    User::LeaveIfError(serv3.Connect());

    serv3.SetTimeZoneL(aTimeZone);

	TTime time;

	time.HomeTime();

	TDateTime dateTime=time.DateTime();

	dateTime.SetMinute(0);

	dateTime.SetSecond(0);

	dateTime.SetMicroSecond(0);

	time=dateTime;

    serv3.SetHomeTime(time);

    serv3.Close();

	TInt numSuc;

	iCalTestLib->SynCGetEntryViewL().UpdateL(aEntries, numSuc);

	RFile outFile;

	User::LeaveIfError(outFile.Replace(iCalTestLib->FileSession(), aVCalendarStream, EFileWrite));

	RFileWriteStream writeStream(outFile);

	iCalTestLib->DataExchangeL().ExportL(KUidVCalendar, writeStream, aEntries);

	writeStream.Close();

	outFile.Close();

	}

// Create two entries (summer and winter) and export in different timezones as if to SyncML Server.

//