// 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 <caldataexchange.h>
#include <calentryview.h>
#include <calrrule.h>
#include <calalarm.h>
#include <caliterator.h>
#include <caldataformat.h>
#include <calsession.h>

#include "caltestlib.h"
#include "caltestoom.h"

LOCAL_D RTest test(_L("T_VCAL5OOM"));
_LIT8(KOOMEntryGuid,  "OOM_Entry_Guid");

_LIT(KTestCalendarFile,	"c:t_vcal5oom");
_LIT(KVCalFile,			"c:\\t_vcal5oom.vcs");

class CTestApp : public CBase, public MCalTestOomCallBack
	{
public:
	enum TOOMTestCase
		{
		ETestAllEntry,
		ETestTemporaryEntry,
		EAmountTestCases
		};
public:
	static CTestApp* NewL();
	~CTestApp();
	
	void CreateAppointmentL();
	void CreateAnniversaryEntryL();
	void CreateTimedAlarmedApptEntryL();
	
	CCalEntry* CreateTodoLC(TBool isOOMTest);
	
	void ExportAsVCalendarL(const TDesC& aVCalendarFile);
	void ExportAsVCalendarL(const TDesC& aVCalendarFile, CCalEntry* aEntry);
	
	void DoOomTestL();
	
	
public: // from MCalOomTestCallBack
	void OomTestL(TType aType, TInt aFailAt);
	
private:
	void ConstructL();

private:
	CCalTestLibrary* iCalTestLib; //owned
	
	TInt iOOMTestCase;
	};
	
CTestApp* CTestApp::NewL()
	{
	CTestApp* self = new(ELeave) CTestApp;
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}
	
void CTestApp::ConstructL()
	{
	iCalTestLib = CCalTestLibrary::NewL();
	iCalTestLib->ReplaceFileL(KTestCalendarFile);
	iCalTestLib->OpenFileL(KTestCalendarFile);
	}
		
CTestApp::~CTestApp()
	{
	delete iCalTestLib;
	}
	
void CTestApp::DoOomTestL()
	{
	CCalSession& calSession = iCalTestLib->GetSession();
	
	for (iOOMTestCase = 0 ; iOOMTestCase < EAmountTestCases; ++iOOMTestCase)
		{
		test.Printf(_L("Starting oom test %d\n"), iOOMTestCase);
		CalTestOom::OutOfMemoryTestL(*this, EClient, calSession);
		CalTestOom::OutOfMemoryTestL(*this, EServer, calSession);
		}
	}
	
void CTestApp::OomTestL(TType /*aType*/, TInt /*aFailAt*/)
	{
	test.Printf(_L("."));
	
	switch (iOOMTestCase)
		{
		case ETestAllEntry:
			{
			ExportAsVCalendarL(KVCalFile);
			}
			break;
		case ETestTemporaryEntry:
			{
			CCalEntry* entry = CreateTodoLC(ETrue);
			ExportAsVCalendarL(KVCalFile, entry);
			CleanupStack::PopAndDestroy(entry);
			}
			break;
		default:
			{
			User::Leave(KErrGeneral);
			}
		}
	}

// Create an appointment with Unicode text
//
void CTestApp::CreateAppointmentL()
	{
	TTime today;
	today.HomeTime();
	TCalTime startTime;
	startTime.SetTimeLocalL(TDateTime(today.DateTime().Year(),today.DateTime().Month(),today.DateTime().Day(),9,0,0,0));
	TCalTime endTime;
	endTime.SetTimeLocalL(startTime.TimeLocalL() + TTimeIntervalMinutes(60));
	HBufC8* guid = NULL;
	CCalEntry* entry = iCalTestLib->CreateCalEntryL(CCalEntry::EAppt, guid);
	CleanupStack::PushL(entry);
	entry->SetStartAndEndTimeL(startTime, endTime);
	TBuf16<60> apptSummary;
	apptSummary.AppendFormat(_L16("Here are some European letters: %c%c%c%c%c%c%c%c%c%c. "), 0x0117, 0x010d, 0x00f1, 0x00df, 0x00d8, 0x0142, 0x0151, 0x016f, 0x0131, 0x00c9);
	entry->SetSummaryL(apptSummary);
	
	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 = NULL;
	CCalEntry* entry = iCalTestLib->CreateCalEntryL(CCalEntry::EAnniv, guid);
	CleanupStack::PushL(entry);
	TBuf16<60> text;
	text.AppendFormat(_L16("Here are some Han characters: %c%c%c%c%c%c%c%c%c%c. "),   0x7f0c, 0x7a92, 0x6d90, 0x6272, 0x5934, 0x5973, 0x55ce, 0x516c, 0x4ec0, 0x4e00);
	entry->SetSummaryL(text);
	TCalTime annivTime;
	annivTime.SetTimeLocalL(TTime(TDateTime(1998,EJune,24,0,0,0,0)));
	
	entry->SetStartAndEndTimeL(annivTime, annivTime);  
	
	TCalRRule rRule(TCalRRule::EYearly);
	
	rRule.SetDtStart(annivTime);  
	TCalTime maxTime;
	maxTime.SetTimeUtcL(TCalTime::MaxTime());
	rRule.SetUntil(maxTime);
	rRule.SetInterval(1);
	entry->SetRRuleL(rRule);
	
	TCalTime exception;
	exception.SetTimeLocalL(TTime(TDateTime(2000,EJune,24,0,0,0,0)));
	RArray<TCalTime> exceptions;
	CleanupClosePushL(exceptions);
	exceptions.AppendL(exception);
	entry->SetExceptionDatesL(exceptions);
	CleanupStack::PopAndDestroy(&exceptions);
	
	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()
	{
	TTime today;
	today.HomeTime();
	TCalTime startTime;
	startTime.SetTimeLocalL(TDateTime(today.DateTime().Year(),today.DateTime().Month(),today.DateTime().Day(),10,0,0,0));
	TCalTime endTime;
	endTime.SetTimeLocalL(startTime.TimeLocalL() + TTimeIntervalMinutes(90));
	HBufC8* guid = NULL;
	CCalEntry* entry = iCalTestLib->CreateCalEntryL(CCalEntry::EAppt, guid);
	CleanupStack::PushL(entry);
	entry->SetStartAndEndTimeL(startTime, endTime);
	TBuf16<60> text;
	text.AppendFormat(_L16("Here are some Japanese kana: %c%c%c%c%c%c%c%c%c%c. "),    0x30a2, 0x30c0, 0x30d5, 0x30b7, 0x30ba, 0x3091, 0x3093, 0x3055, 0x3074, 0x3080);
	entry->SetSummaryL(text);

	CCalAlarm* alarm = CCalAlarm::NewL();
	CleanupStack::PushL(alarm);
	alarm->SetTimeOffset(TTimeIntervalMinutes(15));
	TBuf16<30> alarmName;
	alarmName.AppendFormat(_L16("%c%c%c%c%c%c%c%c%c%c. "),    0x03a3, 0x03bf, 0x03bc, 0x03b4, 0x03b5, 0x0345, 0x03a9, 0x0392, 0x0395, 0x03a1);
	alarm->SetAlarmSoundNameL(alarmName);
	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);
	}

CCalEntry* CTestApp::CreateTodoLC(TBool isOOMTest)
	{
	HBufC8* guid = NULL; 
	
	CCalEntry* todo = NULL;
	if(isOOMTest)
		{
		guid = KOOMEntryGuid().AllocLC();
		todo = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodAdd, 0);
		CleanupStack::Pop(guid);
		}
	else
		{
		todo = iCalTestLib->CreateCalEntryL(CCalEntry::ETodo, guid);
		}

	CleanupStack::PushL(todo);
	TTime now;		  
	now.UniversalTime();
	
	TCalTime startTime;
	startTime.SetTimeLocalL(now + TTimeIntervalDays(5));
	TCalTime endTime;
	endTime.SetTimeLocalL(now + TTimeIntervalDays(5) + TTimeIntervalMinutes(500));
	
	todo->SetStartAndEndTimeL(startTime, endTime);
	
	TBuf16<60> text;
	text.AppendFormat(_L16("A Selection of Dingbats: %c%c%c%c%c%c%c%c%c "), 0x2780, 0x270d, 0x27ab, 0x2704, 0x2706, 0x2707, 0x272d, 0x2729, 0x270f, 0x278b);
	todo->SetSummaryL(text);
	TCalTime now2;
	now2.SetTimeLocalL(now);
	todo->SetCompletedL(ETrue, now2);
	
	return todo;
	}

void CTestApp::ExportAsVCalendarL(const TDesC& aVCalendarFile)
	{
	RPointerArray<CCalEntry> entryArray;
	CleanupResetAndDestroyPushL(entryArray);

	CCalIter* calIter = NULL;
	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;
	CleanupClosePushL(outFile);

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


	RFileWriteStream writeStream(outFile);
	CleanupClosePushL(writeStream);
	
	CCalDataExchange* dataExchange = NULL;
	dataExchange = CCalDataExchange::NewL(iCalTestLib->GetSession());
	CleanupStack::PushL(dataExchange);
	
	dataExchange->ExportL(KUidVCalendar, writeStream, entryArray);
	
	CleanupStack::PopAndDestroy(dataExchange);
	CleanupStack::PopAndDestroy(); // writeStream.Close()
	CleanupStack::PopAndDestroy(); // outFile.Close()
	CleanupStack::PopAndDestroy(); // entryArray.Close()
	}

void CTestApp::ExportAsVCalendarL(const TDesC& aVCalendarStream, CCalEntry* aEntry)
	{
	RFile outfile;
	CleanupClosePushL(outfile);
	User::LeaveIfError(outfile.Replace(iCalTestLib->FileSession(),aVCalendarStream,EFileWrite));
	
	RFileWriteStream writeStream(outfile);
	CleanupClosePushL(writeStream);
	
	RPointerArray<CCalEntry> entryArray;
	CleanupClosePushL(entryArray);
	entryArray.AppendL(aEntry);

	CCalDataExchange* dataExchange = NULL;
	dataExchange = CCalDataExchange::NewL(iCalTestLib->GetSession());

	CleanupStack::PushL(dataExchange);
	dataExchange->ExportL(KUidVCalendar, writeStream, entryArray);
	
	writeStream.CommitL();
	
	CleanupStack::PopAndDestroy(dataExchange);
	CleanupStack::PopAndDestroy(); // entryArray.Close();
	CleanupStack::PopAndDestroy(); // writeStream.Close();
	CleanupStack::PopAndDestroy(); // outfile.Close();
	}	



static void doMainL()
	{
	CTestApp* testApp = CTestApp::NewL();
	CleanupStack::PushL(testApp);
	
	// create entries	
	testApp->CreateAppointmentL();
	testApp->CreateAnniversaryEntryL();
	testApp->CreateTimedAlarmedApptEntryL();
	
	// export a vCalendar stream

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

	testApp->ExportAsVCalendarL(KVCalFile);
	
	// export a single vCalendar object

	test.Next(_L("Exporting a single vTodo object"));

	CCalEntry* todo = testApp->CreateTodoLC(EFalse);
	testApp->ExportAsVCalendarL(KVCalFile, todo);
	CleanupStack::PopAndDestroy(todo);
	
	// Start the oom tests
	
	test.Next(_L("Starting the oom tests"));

	testApp->DoOomTestL();

	CleanupStack::PopAndDestroy(testApp);
	}

static void CleanupFilesL()
	{
	CCalTestLibrary* testLibrary = CCalTestLibrary::NewL(EFalse);
	CleanupStack::PushL(testLibrary);
	testLibrary->DeleteFileL(KVCalFile, EFalse);

	CleanupStack::PopAndDestroy(testLibrary);
	}
	
/**

@SYMTestCaseID     PIM-T-VCAL5OOM-0001

*/

TInt E32Main()
	{	
	__UHEAP_MARK;
	test.Start(_L("@SYMTESTCaseID:PIM-T-VCAL5OOM-0001 T_VCAL5OOM"));

	test.Title();
	CActiveScheduler* scheduler = new CActiveScheduler;
	CActiveScheduler::Install(scheduler);
	CTrapCleanup* theCleanup = CTrapCleanup::New();
	TRAPD(ret,doMainL());	
	test(ret==KErrNone);
	TRAP_IGNORE(CleanupFilesL());
	delete theCleanup;	
	delete scheduler;
	test.End();
	test.Close();
	__UHEAP_MARKEND;
	return(KErrNone);
	}