// 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 <s32file.h>
#include <e32test.h> 

#include <txtrich.h>
#include <conpics.h>

#include <calentryview.h>
#include <calrrule.h>
#include <calcategory.h>
#include <calcontent.h>
#include <caluser.h>
#include <calalarm.h>

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

RTest test(_L("t_testcopy"));

static const TTime KStartTime(TDateTime(2005, ENovember, 23, 12, 0, 0, 0));

_LIT(KTestFile, "t_testcopy");

TBufC8<25> _SmallContent(_L8("small content"));
TBufC8<25> _MimeType(_L8("mime type"));

class CTestApp : public CBase, public MCalTestOomCallBack
	{
public:
	static CTestApp* NewL();
	~CTestApp();
	
	void SetEntryDetailsL(CCalEntry& aEntry);
	
	void TestCopyL();
	void OomTestCopyL();

public: // from MCalOomTestCallBack
	void OomTestL(TType aType, TInt aFailAt);

private:
	void ConstructL();
	
private:
	CCalTestLibrary* iCalTestLib;

	};
	
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(KTestFile());
	iCalTestLib->OpenFileL(KTestFile());
	}
	
CTestApp::~CTestApp()
	{
	delete iCalTestLib;
	}
	
void CTestApp::OomTestCopyL()
	{
	test.Printf(_L("Starting out of memory test\n"));
	CCalSession& calSession = iCalTestLib->GetSession();
	CalTestOom::OutOfMemoryTestL(*this, EClient, calSession);
	CalTestOom::OutOfMemoryTestL(*this, EServer, calSession);
 	}
	
void CTestApp::OomTestL(TType /*aType*/, TInt /*aFailAt*/)
	{
	test.Printf(_L("."));
	TestCopyL();
	}
	
void CTestApp::SetEntryDetailsL(CCalEntry& aEntry)
	{
	iCalTestLib->SetEntryStartAndEndTimeL(&aEntry, KStartTime, KStartTime + TTimeIntervalHours(1));
	
	// create a repeat rule
	TCalTime dtStart;
	dtStart.SetTimeLocalL(KStartTime);
	TCalTime until;
	until.SetTimeLocalL(KStartTime + TTimeIntervalDays(7));
	
	TCalRRule rRule(TCalRRule::EDaily);
	rRule.SetDtStart(dtStart);
	rRule.SetUntil(until);
	rRule.SetInterval(1);
	aEntry.SetRRuleL(rRule);
	
	// add an exception
	RArray<TCalTime> exceptions;
	CleanupClosePushL(exceptions);
	TCalTime exception;
	exception.SetTimeLocalL(KStartTime + TTimeIntervalDays(3));
	exceptions.AppendL(exception);
	aEntry.SetExceptionDatesL(exceptions);
	CleanupStack::PopAndDestroy(&exceptions);
	
	// add an rdate
	RArray<TCalTime> rDates;
	CleanupClosePushL(rDates);
	TCalTime rDate;
	rDate.SetTimeLocalL(KStartTime + TTimeIntervalDays(3) + TTimeIntervalHours(3));
	rDates.AppendL(rDate);
	aEntry.SetExceptionDatesL(rDates);
	CleanupStack::PopAndDestroy(&rDates);
	
	// add a category predefined and an extended
	CCalCategory* predefinedCategory = CCalCategory::NewL(CCalCategory::ECalBusiness);
	aEntry.AddCategoryL(predefinedCategory);
	CCalCategory* extendedCategory = CCalCategory::NewL(_L("Extended Category"));
	aEntry.AddCategoryL(extendedCategory);
	
	// oom test this
	aEntry.CategoryListL();
	
	CCalCategory* extendedCategory2 = CCalCategory::NewL(_L("dummy category"));
	aEntry.AddCategoryL(extendedCategory2);
	aEntry.DeleteCategoryL(2);
	
	// set a different time zone rule
	// ?
	
	// set the description
	aEntry.SetDescriptionL(_L("The Description"));
	
	// set the summary
	aEntry.SetSummaryL(_L("The Summary"));
	
	// set the organizer
	CCalUser* organizer = CCalUser::NewL(_L("organizer@symbian.com"));
	aEntry.SetOrganizerL(organizer);
	
	// set an attendee
	CCalAttendee* attendee = CCalAttendee::NewL(_L("attendee@symbian.com"));
	aEntry.AddAttendeeL(attendee);

	// set the phone owner
	RPointerArray<CCalAttendee>& attendList = aEntry.AttendeesL();
	aEntry.SetPhoneOwnerL(attendList[0]);
	
	// set priority
	aEntry.SetPriorityL(1);
	
	// add an alarm
	CCalAlarm* alarm = CCalAlarm::NewL();
	CleanupStack::PushL(alarm);
	
	alarm->SetTimeOffset(15);
	alarm->SetAlarmSoundNameL(_L("alarm sound"));
	
	CCalContent* content = CCalContent::NewL();
	CleanupStack::PushL(content);
	
	content->SetContentL(_MimeType.AllocLC(), _SmallContent.AllocLC(), CCalContent::EDispositionUnknown);
	CleanupStack::Pop(2);
	alarm->SetAlarmAction(content);
	CleanupStack::Pop(content);
	aEntry.SetAlarmL(alarm);
	CleanupStack::PopAndDestroy(alarm);
	}

void CTestApp::TestCopyL()
	{
	// create the original entry
	HBufC8* guidEntry = NULL;
	CCalEntry* originalEntry = iCalTestLib->CreateCalEntryL(CCalEntry::ETodo, guidEntry);
	CleanupStack::PushL(originalEntry);
	SetEntryDetailsL(*originalEntry);
		
	HBufC8* guidCopy = NULL;
	CCalEntry* copiedEntry = iCalTestLib->CreateCalEntryL(CCalEntry::ETodo, guidCopy);
	CleanupStack::PushL(copiedEntry);
	
	// copy and compare the entries
	copiedEntry->CopyFromL(*originalEntry);
	test(copiedEntry->CompareL(*originalEntry));
	
	// Save the copy in the DB
	RPointerArray<CCalEntry> calEntries;
	CleanupClosePushL(calEntries);
	calEntries.AppendL(copiedEntry);
	TInt numSuc;
	iCalTestLib->SynCGetEntryViewL().StoreL(calEntries, numSuc);
	CleanupStack::PopAndDestroy(&calEntries); //copiedEntry.Close()
	CleanupResetAndDestroyPushL(calEntries);
	
	// Read the copy out of the DB
	// and compare the fetched entry with the copy that was stored
	iCalTestLib->SynCGetEntryViewL().FetchL(copiedEntry->UidL(), calEntries);
	test(copiedEntry->CompareL(*calEntries[0]));
	test(originalEntry->CompareL(*calEntries[0]));
	calEntries.ResetAndDestroy();
	
	// Read the copy out of the DB
	// copy the the fetched entry and then compare with the original
	iCalTestLib->SynCGetEntryViewL().FetchL(copiedEntry->UidL(), calEntries);
	HBufC8* guidCopy2 = NULL;
	CCalEntry* copiedEntry2 = iCalTestLib->CreateCalEntryL(CCalEntry::ETodo, guidCopy2);
	CleanupStack::PushL(copiedEntry2);
	copiedEntry2->CopyFromL(*calEntries[0]);
	test(copiedEntry2->CompareL(*calEntries[0]));
	calEntries.ResetAndDestroy();
	
	// cleanup	
	CleanupStack::PopAndDestroy(copiedEntry2);
	CleanupStack::PopAndDestroy(&calEntries);
	CleanupStack::PopAndDestroy(copiedEntry);
	CleanupStack::PopAndDestroy(originalEntry);
	}

static void doMainL()
	{
	CTestApp* testApp = CTestApp::NewL();
	CleanupStack::PushL(testApp);
	
	testApp->TestCopyL();
	testApp->OomTestCopyL();
	
	CleanupStack::PopAndDestroy(testApp);
	}

/**

@SYMTestCaseID     PIM-T-TESTCOPY-0001

*/

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

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