// Copyright (c) 2006-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:

//

// Local includes

#include "caltestlib.h"

#include <calentry.h>

#include <calentryview.h>

#include <calalarm.h>

#include <calcategory.h>

#include <calinstance.h>

#include <calinstanceview.h>

#include <calrrule.h>

// System includes

#include <e32test.h>

#include <s32file.h>

#include <asshdalarm.h>

#include <asshddefs.h>

#include <asclisession.h>

LOCAL_D RTest test(_L("tCal_alarmattach"));

_LIT8(KGUID3, "GUID_TestDeleteSnoozedAlarmL"); /* do not use it for other tests */

class CCalAlarmAttachTest : public CBase

	{

public:

	static CCalAlarmAttachTest* NewLC();

 	void DoTestL();

	~CCalAlarmAttachTest();

	void TestDeleteSnoozedAlarmL() ;

	void TestDeleteAlarmL() ;

	void TestFetchEntryAlarmContentL();

	void TestDeleteAlarmWithAlarmContentL();

	void TestCopyEntryWithAlarmContentL();

	void TestCopyTwiceEntryWithAlarmContentL();

    void TestUpdateEntryHavingAlarmcontentL();

private:

	void ConstructL();

	void CreateEntriesL();

	void TestAlarmL( CCalEntry* aEntry, const TDesC8& expectedContent,

        const TDesC8& expectedMimeType );

	void FetchEntryL( const TDesC8& expectedContent, 

        const TDesC8& expectedMimeType );

	void ClearAllAlarmsL();

	TInt CountAlarmsL(TAlarmId& aFirstAlarmId);

	CCalAlarm* StoreEntryWithAlarmContentLC(const TDesC8& aUid);

private:

	CCalTestLibrary* iTestLib;

	RASCliSession		iAlarmServer;

	};

_LIT8(KGUID1, "A_Global_UID1");

_LIT(KCalName, "TestCalendar");

_LIT8(KContent, "C:\\test.jpg");

_LIT8(KMimeType, "mime type");

_LIT(KSummary, "Summary");

_LIT(KDescription, "Description");

/**

* Tests behaviour of the alarm attachments.

*

* Create 3 entries, a parent, and two child entries. The first child entry has

* an alarm attachment and stores the entry. The second child also has an 

* attachment and stores the entry. The second child's alarm attachment data 

* should overwrite the first child's alarm data.

*/

void CCalAlarmAttachTest::CreateEntriesL()

	{

    //-----------------------------------------------------------------------

	// Create parent entry with repeat rule

    //-----------------------------------------------------------------------

	RPointerArray<CCalEntry> entries;

	CleanupResetAndDestroyPushL(entries);

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

	CCalEntry* parentEntry = CCalEntry::NewL(CCalEntry::EEvent, guid, CCalEntry::EMethodNone, 0);

	CleanupStack::Pop(guid);

	CleanupStack::PushL(parentEntry);

	TCalTime calTime1;

	calTime1.SetTimeUtcL(TDateTime(2007,EFebruary,15, 13, 30, 0, 0));

	TCalTime calTime2;

	calTime2.SetTimeUtcL(TDateTime(2007,EFebruary,15, 14, 30, 0, 0));

	parentEntry->SetStartAndEndTimeL(calTime1, calTime2);

	parentEntry->SetSummaryL(_L("Test for Alarms"));

	TCalRRule rptRule;

    rptRule.SetDtStart( calTime1 );

    rptRule.SetType( TCalRRule::EDaily );

    rptRule.SetInterval( 1 );

    rptRule.SetCount(5);

	parentEntry->SetRRuleL(rptRule);

	entries.AppendL(parentEntry);

    // Store parent entry.

	TInt entriesStored = 0;

	iTestLib->SynCGetEntryViewL().StoreL(entries, entriesStored);

	CleanupStack::Pop(parentEntry);

	CleanupStack::PopAndDestroy(&entries);

    //-----------------------------------------------------------------------

	// Create child entry with recurrence id on 17th and with alarm attachment.

    //-----------------------------------------------------------------------

	RPointerArray<CCalEntry> entriesToStore1;

	CleanupResetAndDestroyPushL(entriesToStore1);

	TCalTime recurrenceId;

	recurrenceId.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0));

	HBufC8* parentGuid = KGUID1().AllocLC();

	CCalEntry* childEntry1 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid, 

        CCalEntry::EMethodNone, 0, recurrenceId, CalCommon::EThisOnly);

	CleanupStack::Pop(parentGuid);

	CleanupStack::PushL(childEntry1);

	TCalTime calTime3;

	calTime3.SetTimeUtcL(TDateTime(2007,EFebruary,21, 13, 30, 0, 0));

	TCalTime calTime4;

	calTime4.SetTimeUtcL(TDateTime(2007,EFebruary,21, 14, 30, 0, 0));

	childEntry1->SetStartAndEndTimeL(calTime3, calTime4);

	// Add an attachment to the alarm.

	CCalAlarm* alarm = CCalAlarm::NewL();

	CleanupStack::PushL(alarm);

	alarm->SetTimeOffset(1);

	CCalContent* almContent = CCalContent::NewL();

	CleanupStack::PushL(almContent);

	// Add content and mimetype for the alarm.

	_LIT8(KContent, "C:\\test.jpg");

	_LIT8(KMimeType, "mime type");

	HBufC8* content = KContent().AllocLC();

	HBufC8* mimetype = KMimeType().AllocLC();

    // Takes ownership of content and mimetype.

	almContent->SetContentL(content, mimetype, CCalContent::EDispositionInline);

	alarm->SetAlarmAction(almContent); // Takes ownership of almContent.

	childEntry1->SetAlarmL(alarm);

	CleanupStack::Pop(mimetype);

	CleanupStack::Pop(content);    

	CleanupStack::Pop(almContent); 

	CleanupStack::PopAndDestroy(alarm);

	TInt entriesStored1 = 0;

	entriesToStore1.AppendL(childEntry1);

	iTestLib->SynCGetEntryViewL().StoreL(entriesToStore1, entriesStored1);

	CleanupStack::Pop(childEntry1);

    // Test if the alarm details retrieved are as expected.

	CCalEntry* entry1 = entriesToStore1[0];

	TestAlarmL(entry1, KContent(), KMimeType());

    // Fetch the entry and ensure the alarm details are still as expected.

    FetchEntryL( KContent(), KMimeType() );

	CleanupStack::PopAndDestroy(&entriesToStore1);

    //-----------------------------------------------------------------------

	// Create another child entry with recurrence id and range same as above. 

    // The entry should be updated.

    //-----------------------------------------------------------------------

	RPointerArray<CCalEntry>	entriesToStore2;

	CleanupResetAndDestroyPushL(entriesToStore2);

	HBufC8* parentGuid1 = KGUID1().AllocLC();

	TCalTime recurrenceId1;

	recurrenceId1.SetTimeUtcL(TDateTime(2007,EFebruary,17, 13, 30, 0, 0));

	CCalEntry* childEntry2 = CCalEntry::NewL(CCalEntry::EEvent, parentGuid1, 

        CCalEntry::EMethodNone, 0, recurrenceId1, CalCommon::EThisOnly);

	CleanupStack::Pop(parentGuid1);

	CleanupStack::PushL(childEntry2);

	TCalTime calTime5;

	calTime5.SetTimeUtcL(TDateTime(2007,EFebruary,22, 13, 30, 0, 0));

	TCalTime calTime6;

	calTime6.SetTimeUtcL(TDateTime(2007,EFebruary,22, 14, 30, 0, 0));

	childEntry2->SetStartAndEndTimeL(calTime5, calTime6);

	childEntry2->SetSummaryL(_L("Update the child entry1"));

	childEntry2->SetPriorityL(2);

	// Add attachment to the alarm.

	CCalAlarm* alarm1 = CCalAlarm::NewL();

	CleanupStack::PushL(alarm1);

	alarm1->SetTimeOffset(1);

	CCalContent* almContent1 = CCalContent::NewL();

	CleanupStack::PushL(almContent1);

	// Add alarm attachment to the entry.

	_LIT8(KContent1, "C:\\longtail.jpg");

    _LIT8(KMimeType1, "mime type 2");

	HBufC8* content1 = KContent1().AllocLC();

	HBufC8* mimetype1 = KMimeType1().AllocLC();

	almContent1->SetContentL(content1, mimetype1, CCalContent::EDispositionInline);

	alarm1->SetAlarmAction(almContent1);

	childEntry2->SetAlarmL(alarm1);

	CleanupStack::Pop(mimetype1);

	CleanupStack::Pop(content1);

	CleanupStack::Pop(almContent1);

	CleanupStack::PopAndDestroy(alarm1);

	entriesToStore2.AppendL(childEntry2);

    // Store the child entry.

	TInt entriesStored2 = 0;

	iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2);

    // Store the entry again. The stream id for the alarm action will be 

    // re-used (in CAgnEntry). RAgendaServ::UpdateEntryL() will call 

    // CAgnEntry::UpdateAlarmAction() instead of StoreAlarmAction().

	iTestLib->SynCGetEntryViewL().StoreL(entriesToStore2, entriesStored2);

	CleanupStack::Pop(childEntry2);

	CCalEntry* entry2 = entriesToStore2[0];

	// Test if the alarm details are retrieved as expected. 

	TestAlarmL(entry2, KContent1(), KMimeType1());

    // Fetch the entry and ensure the alarm details are still as expected.

    FetchEntryL( KContent1(), KMimeType1() );

	CleanupStack::PopAndDestroy(&entriesToStore2);

	}

/**

* Test the alarm properties of the entry that has alarm content.

*

* @param aEntry The calendar entry to test.

* @param expectedContent The expected content in aEntry.

* @param expectedMimeType The expected mime type in aEntry.

*/	

void CCalAlarmAttachTest::TestAlarmL( CCalEntry* aEntry, 

    const TDesC8& expectedContent, const TDesC8& expectedMimeType )

	{

	CCalAlarm* almEntry = aEntry->AlarmL();

	CleanupStack::PushL(almEntry);

    test( almEntry != NULL );

	CCalContent* alarmcontent1 = almEntry->AlarmAction();

    test( alarmcontent1 != NULL );

	const TDesC8& content = alarmcontent1->Content();

    test( content == expectedContent );

	const TDesC8& mimetype = alarmcontent1->MimeType();

    test( mimetype == expectedMimeType );

    CleanupStack::PopAndDestroy(almEntry);

	}

/**

* Fetches all entries and checks the alarm properties for the child entry.

* There should be two entries, a parent and the child entry.

*

* @param expectedContent The expected content of the child entry.

* @param expectedMimeType The expected mime type of the child entry.

*/

void CCalAlarmAttachTest::FetchEntryL( const TDesC8& expectedContent,

        const TDesC8& expectedMimeType )

    {

	RPointerArray<CCalEntry> entriesFetched;

	CleanupResetAndDestroyPushL(entriesFetched);

	HBufC8* parentGuid1 = KGUID1().AllocLC();

	iTestLib->SynCGetEntryViewL().FetchL(parentGuid1->Des(), entriesFetched);

    // 1 parent and 1 child entry.

	test(entriesFetched.Count() == 2); 

    // The child entry should be the second entry.

	CCalEntry* childEntry = entriesFetched[1];

	TPtrC summary = childEntry->SummaryL();

	// Test if the alarm details are retrieved as expected. 

	TestAlarmL(childEntry, expectedContent, expectedMimeType);

    CleanupStack::PopAndDestroy(parentGuid1);

	CleanupStack::PopAndDestroy(&entriesFetched);

	}

void CCalAlarmAttachTest::ClearAllAlarmsL()

	{

	iTestLib->CleanDatabaseL();

	// Delete all alarms

	RArray<TAlarmCategory> categories;

	CleanupClosePushL(categories);

	iAlarmServer.GetAvailableCategoryListL(categories);

	TInt count = categories.Count();

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

		{

		const TAlarmCategory& category = categories[i];

		test(iAlarmServer.AlarmDeleteAllByCategory(category, EFalse) == KErrNone);

		}

	CleanupStack::PopAndDestroy(&categories);

	// Restore alarm sound

	iAlarmServer.SetAlarmSoundState(EAlarmGlobalSoundStateOn);

	}

void CCalAlarmAttachTest::DoTestL()

	{

	CreateEntriesL();

	}

CCalAlarmAttachTest* CCalAlarmAttachTest::NewLC()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CCalAlarmAttachTest::ConstructL()

	{

	iTestLib = CCalTestLibrary::NewL();

	iTestLib->ReplaceFileL(KCalName());

	iTestLib->OpenFileL(KCalName());

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

	}

CCalAlarmAttachTest::~CCalAlarmAttachTest()

	{

	iAlarmServer.Close();

	delete iTestLib;

	}

static void PrintEventDetails(TInt aEvent)

	{

	switch(aEvent)

		{

	case EAlarmChangeEventState:

		test.Printf(_L("\tEvent => EAlarmChangeEventState\n"));

		break;

	case EAlarmChangeEventStatus:

		test.Printf(_L("\tEvent => EAlarmChangeEventStatus\n"));

		break;

	case EAlarmChangeEventCharacteristics:

		test.Printf(_L("\tEvent => EAlarmChangeEventCharacteristics\n"));

		break;

	case EAlarmChangeEventAlarmDeletion:

		test.Printf(_L("\tEvent => EAlarmChangeEventAlarmDeletion\n"));

		break;

	case EAlarmChangeEventAlarmAddition:

		test.Printf(_L("\tEvent => EAlarmChangeEventAlarmAddition\n"));

		break;

	case EAlarmChangeEventTimerExpired:

		test.Printf(_L("\tEvent => EAlarmChangeEventTimerExpired\n"));

		break;

	case EAlarmChangeEventSoundPlaying:

		test.Printf(_L("\tEvent => EAlarmChangeEventSoundPlaying\n"));

		break;

	case EAlarmChangeEventSoundStopped:

		test.Printf(_L("\tEvent => EAlarmChangeEventSoundStopped\n"));

		break;

	case EAlarmChangeEventPlayIntervalsChanged:

		test.Printf(_L("\tEvent => EAlarmChangeEventPlayIntervalsChanged\n"));

		break;

	case EAlarmChangeEventGlobalSoundStateChanged:

		test.Printf(_L("\tEvent => EAlarmChangeEventGlobalSoundStateChanged\n"));

		break;

	case EAlarmChangeEventHeadQueueItemChanged:

		test.Printf(_L("\tEvent => EAlarmChangeEventHeadQueueItemChanged\n"));

		break;

	case EAlarmChangeEventUndefined:

		test.Printf(_L("\tEvent => EAlarmChangeEventUndefined\n"));

		break;

	case EAlarmChangeEventAlarmUIVisible:

		test.Printf(_L("\tEvent => EAlarmChangeEventAlarmUIVisible\n"));	

		break;

	case EAlarmChangeEventAlarmUIInvisible:

		test.Printf(_L("\tEvent => EAlarmChangeEventAlarmUIInvisible\n"));	

		break;		

	case EAlarmChangeEventAlarmData:

		test.Printf(_L("\tEvent => EAlarmChangeEventAlarmData\n"));	

		break;			

	default:

		test.Printf(_L("\tEvent => Opss %d?\n"), aEvent);	

		break;

		}

	}

TInt CCalAlarmAttachTest::CountAlarmsL(TAlarmId& aFirstAlarmId)

	{

	RArray< TAlarmId > alarmIdArr;

	iAlarmServer.GetAlarmIdListL(alarmIdArr);

	const TInt KCount = alarmIdArr.Count();

	if (KCount > 0)

		{

		aFirstAlarmId = alarmIdArr[0];

		}

	TASShdAlarm alarmDetails;

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

		{

		User::LeaveIfError(iAlarmServer.GetAlarmDetails(alarmIdArr[i], alarmDetails));

		RDebug::Print(_L("alarm %d, state=%d, id=%d"), i, alarmDetails.State(), alarmIdArr[i]);

		}

	RDebug::Print(_L("alarm count: %d"), KCount);

	alarmIdArr.Close();

	return KCount;

	}

void CCalAlarmAttachTest::TestDeleteSnoozedAlarmL()

	{

	CCalEntryView &view = iTestLib->SynCGetEntryViewL() ;

	CCalEntryView *calentryview = &view ;

	TInt num ;	

	ClearAllAlarmsL() ;	

	test.Printf(_L("Going to check deletion of snoozed alarms\n")) ;

	/* create repeating parent entry	*/

	HBufC8* guid = KGUID3().AllocLC(); // ownership of guid gets transferred

 	CCalEntry *entry = CCalEntry::NewL(CCalEntry::ETodo, guid, CCalEntry::EMethodNone, 0) ;

	CleanupStack::Pop(guid);	

	CleanupStack::PushL(entry) ;

	TTime now1;

	now1.UniversalTime();

	now1 += TTimeIntervalSeconds(30);

	TCalTime startTime ;

	TCalTime endTime ;	

	startTime.SetTimeUtcL(now1) ;

	endTime.SetTimeUtcL(now1 + TTimeIntervalSeconds(30)) ;

	entry->SetStartAndEndTimeL(startTime, endTime) ;

	TCalRRule rrule(TCalRRule::EDaily) ;

	rrule.SetDtStart(startTime);

	TCalTime endRTime ;		

	endRTime.SetTimeUtcL(now1 + TTimeIntervalDays(7)) ;	

	rrule.SetUntil(endRTime);

	rrule.SetInterval(1);	

	entry->SetRRuleL(rrule) ;

	CCalAlarm *alarm = CCalAlarm::NewL() ;

	CleanupStack::PushL(alarm) ;			

	alarm->SetTimeOffset(TTimeIntervalMinutes(0)) ;

	entry->SetAlarmL(alarm) ; //ownership does not get transferred

	RPointerArray<CCalEntry> entryarr ;		

	entryarr.AppendL(entry) ; //ownership does not got transferred			

	calentryview->StoreL(entryarr, num) ;

	entryarr.Close() ;		

	CleanupStack::PopAndDestroy(alarm) ;	

	CleanupStack::PopAndDestroy(entry) ;	

	/* Now let the alarm go off */

	TAlarmId alarmId;

	TInt cnt = CountAlarmsL(alarmId);

	test(cnt > 0) ;

	TRequestStatus status = 0;

	test.Printf(_L("Waiting one minute for the alarm to go off...\n")) ;

	for(;;)

		{

		iAlarmServer.NotifyChange(status, alarmId);

		User::WaitForRequest(status);

		PrintEventDetails(status.Int());

		if	(status.Int() == EAlarmChangeEventTimerExpired)

			{			

			break; // alarm expired

			}

		}

	/* snooze the alarm */

	TTime snooze = now1 + TTimeIntervalMinutes(2);	

	iAlarmServer.__DbgSnoozeAlarm(alarmId, snooze);