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

//

// System includes

#include <e32base.h>

#include <e32test.h>

#include <f32file.h>

// User includes

#include <asshdalarm.h>

#include <asclisession.h>

#include <consolealarmalertservermain.h>

#include <consolealarmalertservermain.h>

#include "testserver.h"

#include "ASTstAlarmTest.h"

#include <asclisoundplay.h>

#ifdef __WINS__

#include "ConsoleANTestClient.h"

#endif

// Type definitions

typedef void (*ThreadTestL)(void);

typedef CArrayFixFlat<TASCliSoundPlayDefinition> CPlayIntervalArray;

// Constants

const TUid KServerUid2={0x1000008D};

const TUid KServerUid3={0x101F502A};

const TUidType serverUid(KNullUid,KServerUid2,KServerUid3);

#define KNewAlarmCycleStartOffsetMinutes        {0,1,2,3,KErrNotFound};

_LIT(KTestIniFile, "c:\\private\\101f5027\\AlarmServer.ini");

// Globals

static RASCliSession TheAlarmServerSession;

#if defined(_DEBUG) && defined(__WINS__)

_LIT(KDateTimeFormat, "%F %*E %*N %D %Y %J:%T:%S%B");

static void PrintTimeL(const TTime& aTime, const TDesC& aPrefix)

	{

	TBuf<30> dateTimeString;

	aTime.FormatL(dateTimeString, KDateTimeFormat);

	TheAlarmTest.Test().Printf(_L("%S %S\n"), &aPrefix, &dateTimeString);

	}

#endif

static void TestClearStoreL()

	{

	// Delete all alarms

	RArray<TAlarmCategory> categories;

	TheAlarmServerSession.GetAvailableCategoryListL(categories);

	TInt count = categories.Count();

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

		{

		const TAlarmCategory category = categories[i];

		TheAlarmTest(TheAlarmServerSession.AlarmDeleteAllByCategory(category, EFalse) == KErrNone, __LINE__);

		}

	categories.Close();

	}

void WaitForNotificationBufferToBeEmptied()

	{

	TRequestStatus status = KErrNone;

	TAlarmId alarmId;

	if	(status == KRequestPending)

		return;

	TheAlarmServerSession.NotifyChange(status, alarmId);

	User::After(1000000);

	if	(status == KRequestPending)

		return;

	User::WaitForRequest(status);

	// Because of event buffering inside the Alarm Server

	// We need to wait until there aren't any more events

	// in the buffer, and then attempt to cancel the request.

	//

	// Trying to cancel a request when the server has

	// already completed the message (because something

	// was in the buffer) results in the server panicing

	// the client.

	FOREVER

		{

		TheAlarmTest(status >= EAlarmChangeEventState && status <= EAlarmChangeEventLast);

		TheAlarmServerSession.NotifyChange(status, alarmId);

		//

		// Wait a second so that we can tell if this really is

		// waiting for an event, or just for the Alarm Server

		// process to be given some scheduling time by the

		// kernel

		User::After(1000000);

		// If its still pending, then we should attempt

		// to cancel the request. Otherwise, if its not

		// pending, then the Alarm Server probably just

		// completed the request based upon the contents

		// of the event buffer.

		if	(status == KRequestPending)

			break;

		else

			{

			// Eat the request and try again

			User::WaitForRequest(status);

			}

		}

	}

void testTimesEqual(const TTime& aTime1, const TTime& aTime2)

	{

	// determine the difference, in seconds

	TTimeIntervalSeconds	timeDiffSeconds;

	const TInt error = aTime2.SecondsFrom(aTime1, timeDiffSeconds);

	TheAlarmTest(error == KErrNone);

	// check the times are within 1 second

	// as the tolerance for notifying alarms should be bigger than 1 second

	const TTimeIntervalSeconds	maxDiff(1);

	const TTimeIntervalSeconds	minDiff(-1);

	TheAlarmTest(((timeDiffSeconds <= maxDiff) && (timeDiffSeconds >= minDiff)));

	}

/**

@SYMTestCaseID PIM-TBASICALARMS-INC092682-0002

@SYMTestType UT

@SYMTestPriority High

@SYMDEF INC092682

@SYMTestCaseDesc Tests that re-enabling of a repeating alarm correctly maintains

the next due alarm ID (the head alarm in the alarm queue).

@SYMTestActions

1. Create a workday alarm due to activate in 30 minutes time.

2. Create a once only alarm due to activate in 90 minutes time.

3. Check that their are 2 active alarms in the queue.

4. Check that workday alarm is due to expire before once only alarm.

5. Disable workday alarm and check that once only alarm is the next due alarm.

6. Advance current time by 1 hour.  The repeating (workday) alarm should be

   rescheduled for the next workday, leaving the once only alarm as the next due

   alarm.

7. Enable workday alarm.

8. Check that once only alarm is next due alarm - workday alarm should be due

   next day now since time was advanced past today's workday alarm time.

@SYMTestExpectedResults The next due alarm is as expected.

*/

static void TestINC092682L()

	{

	TheAlarmTest.Next(_L("@SYMTestCaseID PIM-TBASICALARMS-INC092682-0002 Testing fix for INC092682."));

	//

	// Make sure we start with no alarms.

	//

	TestClearStoreL();

	//

	// 1. Create a workday alarm due to activate in 30 minutes time.

	//

	TASShdAlarm alarm;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatWorkday;

	alarm.Message() = _L("This is workday alarm message");

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(30);

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId workdayId = alarm.Id();

	//

	// 2. Create a once only alarm due to activate in 90 minutes time.

	//

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatOnce;

	alarm.Message() = _L("This is once only alarm message");

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(90);

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId onceOnlyId = alarm.Id();

	//

	// 3. Check that their are 2 active alarms in the queue.

	//

	TheAlarmTest(TheAlarmServerSession.NumberOfAlarmsActiveInQueue() == 2, __LINE__);

	//

	// 4. Check that workday alarm is due to expire before once only alarm.

	//

	TAlarmId nextAlarmId;

	TInt r = TheAlarmServerSession.GetNextDueAlarmId(nextAlarmId);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheAlarmTest(nextAlarmId == workdayId, __LINE__);

	//

	// 5. Disable workday alarm and check that once only alarm is the next due

	// alarm.

	//

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(workdayId, EAlarmStatusDisabled) == KErrNone, __LINE__);

	r = TheAlarmServerSession.GetNextDueAlarmId(nextAlarmId);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheAlarmTest(nextAlarmId == onceOnlyId, __LINE__);

	//

	// 6. Advance current time by 1 hour.  The repeating (workday) alarm should

	// be rescheduled for the next workday, leaving the once only alarm as the

	// next due alarm.

	//

	TTime oneHourLater;

	oneHourLater.HomeTime();

	oneHourLater += TTimeIntervalHours(1);

	RPIMTestServer serv;

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

	serv.SetHomeTime(oneHourLater);

	// Wait for time change notifications to occur.

	User::After(10000);

	// Set again to ensure time value is correct when update occurs.

	serv.SetHomeTime(oneHourLater);

	serv.Close();

	//

	// 7. Enable workday alarm.

	//

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(workdayId, EAlarmStatusEnabled) == KErrNone, __LINE__);

	//

	// 8. Check that once only alarm is next due alarm - workday alarm should be

	// due next day now since time was advanced past today's workday alarm

	// time.

	//

	r = TheAlarmServerSession.GetNextDueAlarmId(nextAlarmId);

	TheAlarmTest(r == KErrNone, __LINE__);

	TheAlarmTest(nextAlarmId == onceOnlyId, __LINE__);

	//

	// Tidy up.

	//

	TestClearStoreL();

	WaitForNotificationBufferToBeEmptied();

	}

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

static void CreateSingleAlarmL()

	{

#ifdef __WINS__

	TheAlarmTest.Next(_L("Adding disabled alarm"));

	//

	TASShdAlarm alarm;

	alarm.Category() = KASCliCategoryClock;

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;

	alarm.Message() = _L("This is an alarm message - alarm 1");

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(1);

	alarm.SoundName() = _L("Arf Arf Woop");

	//

	TTime now;

	now.HomeTime();

	//

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TheAlarmTest.Next(_L("Get alarm details"));

	TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

	TheAlarmTest.Next(_L("Enabling a disabled alarm"));

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

	TheAlarmTest.Next(_L("Waiting for alarm to expire..."));

	TAlarmId alarmId;

	TRequestStatus status;

	FOREVER

		{

		TheAlarmServerSession.NotifyChange(status, alarmId);

		User::WaitForRequest(status);

		if	(status.Int() == EAlarmChangeEventTimerExpired)

			{

			TheAlarmTest(id == alarmId, __LINE__);

			break;

			}

		}

#endif

	}

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

static void CreateAlarmAndIgnoreL()

    {

#ifdef __WINS__

    TheAlarmTest.Next(_L("Adding disabled alarm"));

    //

    TASShdAlarm alarm;

    alarm.Category() = KASCliCategoryClock;

    alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;

    alarm.Message() = _L("This is an alarm message - alarm 1");

    alarm.NextDueTime().HomeTime();

    alarm.NextDueTime() += TTimeIntervalMinutes(1);

    alarm.SoundName() = _L("Arf Arf Woop");

    //

    TTime now;

    now.HomeTime();

    //

    TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

    const TAlarmId id = alarm.Id();

    TheAlarmTest(id != KNullAlarmId, __LINE__);

    // copy the current soundsettings

    CPlayIntervalArray* originalSoundArray = new(ELeave) CPlayIntervalArray(20);

    CleanupStack::PushL(originalSoundArray);

    TheAlarmServerSession.GetAlarmPlayIntervalsL(*originalSoundArray);

    // use shorted one

    CPlayIntervalArray* newSoundArray = new(ELeave) CPlayIntervalArray(10);

    CleanupStack::PushL(newSoundArray);

    const TInt minuteCycle[]=KNewAlarmCycleStartOffsetMinutes;

    TInt i(0);

    TInt offset(minuteCycle[i]);

    while (offset != KErrNotFound)

        {

        const TASCliSoundPlayDefinition item(offset, KDefaultSoundPlayDurationInSeconds);

        newSoundArray->AppendL(item);

        offset = minuteCycle[++i];

        }

    TheAlarmServerSession.SetAlarmPlayIntervalsL(*newSoundArray);

    TheAlarmTest.Next(_L("Get alarm details"));

    TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

    TheAlarmTest.Next(_L("Enabling a disabled alarm"));

    TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

    TheAlarmTest.Next(_L("Waiting for alarm to expire..."));

    TInt numberOfIntervals(newSoundArray->Count());

    TInt count(0);

    TAlarmId alarmId;

    TRequestStatus status;

    FOREVER

        {

        TheAlarmServerSession.NotifyChange(status, alarmId);

        User::WaitForRequest(status);

        if    (status.Int() == EAlarmChangeEventSoundPlaying)

            {

            if(count > numberOfIntervals)

                break;

            count++;

            }

        }

    // this to check that we have gone through all the time intervals in array

    TheAlarmTest(count > newSoundArray->Count(), __LINE__);

    // restore original sound settings

    TheAlarmTest.Test().Next(_L("reset default sound intervals"));

    TheAlarmServerSession.SetAlarmPlayIntervalsL(*originalSoundArray);

    CleanupStack::PopAndDestroy(2);// originalSoundArray, newSoundArray

#endif

    }

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

static void CreateNotificationAlarmL()

	{

	TheAlarmTest.Next(_L("Creating notification alarm"));

	// AlarmAddWithNotification

	TASShdAlarm alarm;

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(1);

	TRequestStatus status;

	TheAlarmServerSession.AlarmAddWithNotification(status, alarm);

	TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TheAlarmTest(status == KRequestPending, __LINE__);

	// Wait for completion

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

	User::WaitForRequest(status);

	// AlarmNotificationCancel

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(1);

	TheAlarmServerSession.AlarmAddWithNotification(status, alarm);

	id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TheAlarmTest(status == KRequestPending, __LINE__);

	TheAlarmServerSession.AlarmNotificationCancelAndDequeue(id);

	// Eat request

	User::WaitForRequest(status);

	TheAlarmTest(status == KErrCancel, __LINE__);

	}

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

static void CreateDailyRepeatingAlarmL()

	{

	TheAlarmTest.Next(_L("Creating daily repeating alarm"));

	// AlarmAddWithNotification

	TASShdAlarm alarm;

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalMinutes(1);

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatDaily;

	TheAlarmServerSession.AlarmAdd(alarm);

	TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	TAlarmId alarmId;

	TRequestStatus status;

	TheAlarmServerSession.NotifyChange(status, alarmId);

	TheAlarmTest(TheAlarmServerSession.SetAlarmStatus(id, EAlarmStatusEnabled) == KErrNone, __LINE__);

	User::WaitForRequest(status);

	}

static void CreateAlarmsForPausingL()

	{

#ifdef __WINS__

	TestClearStoreL();

	TheAlarmTest.Next(_L("Test pausing alarm sounds"));

	//

	// Add an alarm, due in 3 seconds

	TASShdAlarm alarm;

	alarm.NextDueTime().HomeTime();

	alarm.NextDueTime() += TTimeIntervalSeconds(1);

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm) == KErrNone, __LINE__);

	const TAlarmId id = alarm.Id();

	TheAlarmTest(id != KNullAlarmId, __LINE__);

	// Wait for the alarm to go off, and be paused

	User::After(5 * 1000000);

	// The alarm should still be notifying

	TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id, alarm) == KErrNone, __LINE__);

	TheAlarmTest(alarm.State() == EAlarmStateNotifying, __LINE__);

	TheAlarmTest(TheAlarmServerSession.AlarmDelete(id) == KErrNone, __LINE__);

	// Add 2 alarms, due in 3 and 13 seconds

	TTime alarm1time;

	TTime alarm2time;

	alarm1time.HomeTime();

	alarm1time += TTimeIntervalSeconds(3);

	alarm2time = alarm1time + TTimeIntervalSeconds(10);

	TASShdAlarm alarm1;

	alarm1.NextDueTime() = alarm1time;

	alarm1.Message() = _L("alarm 1");

	TASShdAlarm alarm2;

	alarm2.NextDueTime() = alarm2time;

	alarm2.Message() = _L("alarm 2");

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm1) == KErrNone, __LINE__);

	const TAlarmId id1 = alarm1.Id();

	TheAlarmTest(id1 != KNullAlarmId, __LINE__);

	TheAlarmTest(TheAlarmServerSession.AlarmAdd(alarm2) == KErrNone, __LINE__);

	const TAlarmId id2 = alarm2.Id();

	TheAlarmTest(id2 != KNullAlarmId, __LINE__);

	//

	// Wait for the 1st alarm to go off, and be paused

	User::After(5 * 1000000);

	// The 1st alarm should still be notifying

	alarm1.Reset();

	TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id1, alarm1) == KErrNone, __LINE__);

	TheAlarmTest(alarm1.State() == EAlarmStateNotifying, __LINE__);

	// Wait for the time the 2nd alarm is due

	User::After(10 * 1000000);

	// The 1st alarm should be moved to snoozed, so as not to block the 2nd one

	alarm1.Reset();

	alarm2.Reset();

	TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id1, alarm1) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmServerSession.GetAlarmDetails(id2, alarm2) == KErrNone, __LINE__);

	TheAlarmTest.Test().Printf(_L("\tALARM1 State => %u \n"),alarm1.State());

	TheAlarmTest.Test().Printf(_L("\tALARM2 State => %u \n"),alarm2.State());

	TheAlarmTest(alarm1.State() == EAlarmStateSnoozed, __LINE__);

	TheAlarmTest(alarm2.State() == EAlarmStateNotified, __LINE__);

	// the 1st alarm was paused, so the next due time is updated to

	// the end of the pause period (1 minute for console alarm alert server)

	testTimesEqual(alarm1.NextDueTime(), alarm1time + TTimeIntervalMinutes(1));

	TheAlarmTest(alarm2.NextDueTime() == alarm2time, __LINE__);

	// tidy up

	TheAlarmTest(TheAlarmServerSession.AlarmDelete(id1) == KErrNone, __LINE__);

	TheAlarmTest(TheAlarmServerSession.AlarmDelete(id2) == KErrNone, __LINE__);

	WaitForNotificationBufferToBeEmptied();

#endif

	}

//

static void CreateUtcAlarmsForPausingL()

	{

#ifdef __WINS__

	TestClearStoreL();