// 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 "ASTstAlarmTest.h"

#include "testserver.h"

#include <tz.h>

// Globals

static TTime TheOriginalTime;

static TTime TheInitialAlarmTime;

static TTime TheCurrentTime;

TBool AlarmSetInThePastTest = EFalse;

// Definitions:

/* These two #defines make the code a lot safer, since the enums in TDay

	are not tied to any specific values. All code expecting specific values

	need to use them relative to EMonday  (DoW = Day of week) */

#define DoWNumber(x)   ((TInt)(x-EMonday))

#define DoWFlag(x)   (1<<((TInt)(x-EMonday)))

_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);

	}

static void AdjustToNextWorkDay(TTime& aSetTime, const TTime& aCurrentTime)

	{

	TDateTime setDT=aSetTime.DateTime();

	TDateTime currDT=aCurrentTime.DateTime();

	setDT.SetYear(currDT.Year());

	setDT.SetDay(0);	// ensure SetMonth cannot fail.

	setDT.SetMonth(currDT.Month());

	setDT.SetDay(currDT.Day());

	aSetTime=setDT;

	TUint workdays=TLocale().WorkDays();

	TheAlarmTest(workdays!=0, __LINE__);

	TUint dayFlag;

#if defined(_DEBUG)

		{

		FOREVER

			{

			dayFlag=DoWFlag(aSetTime.DayNoInWeek());

			if	(workdays&dayFlag && aSetTime>aCurrentTime)

				return;

			aSetTime+=TTimeIntervalDays(1);

			}

		}

#else

	if (AlarmSetInThePastTest)

		{

		//When moving forwards the system time the Next alarm time will be in the past

		FOREVER

			{

			dayFlag=DoWFlag(aSetTime.DayNoInWeek());

			if(workdays&dayFlag )

				return;

			aSetTime+=TTimeIntervalDays(1);

			}

		}

	else

		{

		FOREVER

			{

			dayFlag=DoWFlag(aSetTime.DayNoInWeek());

			if(workdays&dayFlag && aSetTime>aCurrentTime)

				return;

			aSetTime+=TTimeIntervalDays(1);

			}

		}

#endif

	}

static void TestCompareTimeL(const TTime& aExpectedTime, const TTime& aAlarmTime, TInt aLineNum)

//

//  Compare times to required degree of precision

//

	{

	// determine the difference, in seconds

	TTimeIntervalSeconds timeDiffSeconds;

	const TInt error = aExpectedTime.SecondsFrom(aAlarmTime, timeDiffSeconds);

	TheAlarmTest(error == KErrNone, __LINE__);

	// check the times are within 1min

	// as alarms are rounded to the minute

	const TTimeIntervalSeconds maxDiff(60);

	const TTimeIntervalSeconds minDiff(-60);

	if ((timeDiffSeconds > maxDiff) || (timeDiffSeconds < minDiff))

		{

		TheAlarmTest.Test().Printf(

			_L("Compared times more than 1 minute different (%is) at line %u"),

			timeDiffSeconds.Int(),

			aLineNum);

		TRAP_IGNORE(PrintTimeL(aExpectedTime, _L("Expected time: ")));

		TRAP_IGNORE(PrintTimeL(aAlarmTime, _L("Alarm time: ")));

		TheAlarmTest(EFalse, __LINE__);

		}

	}

static void TestClockAlarmsL(const RArray<TAlarmId>& aIds)

//

//	We expect and TheAlarmTest.TheTest that:

//

//	1) Once alarm to remain unchanged at initial alarm time unless time in past

//	2) Next24 to advance to the first 'initial alarm time' falling due after the original time

//	3) Daily to advance to the first 'initial alarm time' falling due after the currrent time

//	4) Weekday to advance to the 'initial alarm time' on the next weekday

//	5) Weekly to advance to the 'initial alarm time' in the next week

//

	{

	TASShdAlarm alarm;

	TheCurrentTime.HomeTime();

	//

	for (TInt i=0; i<aIds.Count(); i++)

		{

		const TAlarmId id = aIds[i];

		//

		TInt r = TheAlarmTest.Session().GetAlarmDetails(id, alarm);

		if	(r != KErrNone)

			{

			// Its acceptable for the first item to be missing

			// due to a date/time change. The first item is a repeat-once

			// alarm, scheduled 1 hour in the past (i.e one hour before the

			// current time). As soon as the date/time changes, this alarm

			// will be removed from the alarm queue because it is before

			// the new date time.

			TheAlarmTest(r == KErrNotFound && i==0, __LINE__);

			}

		else

			TheAlarmTest(r == KErrNone, __LINE__);

		//

		if (alarm.Status() != EAlarmStatusEnabled)

			continue;

		//

		TTime setTime(TheInitialAlarmTime);

		switch(alarm.RepeatDefinition())

			{

		case EAlarmRepeatDefintionRepeatOnce:

			{

			TestCompareTimeL(TheInitialAlarmTime, alarm.NextDueTime(), __LINE__);

			break;

			}

		case EAlarmRepeatDefintionRepeatNext24Hours:

			{

			// Should be be within 24 hours of the original time

			TTimeIntervalDays daysBetweenInitialAndOriginal(TheOriginalTime.DaysFrom(TheInitialAlarmTime));

			setTime+=daysBetweenInitialAndOriginal;

			setTime+=TTimeIntervalHours(24);

			TestCompareTimeL(setTime, alarm.NextDueTime(), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatDaily:

			{

			// Should be within next 24 hours of current time at initial time

			TTimeIntervalDays daysBetweenInitialAndCurrent(TheCurrentTime.DaysFrom(TheInitialAlarmTime));

			setTime+=daysBetweenInitialAndCurrent;

#if!defined(_DEBUG)

			// UREL

			if (!(alarm.NextDueTime()<TheCurrentTime))  // Alarm not in the past

#endif

			setTime+=TTimeIntervalHours(24);

			TestCompareTimeL(setTime, alarm.NextDueTime(), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatWeekly:

			{

			TTimeIntervalDays daysBetweenInitialAndCurrent(TheCurrentTime.DaysFrom(TheInitialAlarmTime));

			TInt weeks=daysBetweenInitialAndCurrent.Int()/7;

			if (weeks!=0)

				setTime+=TTimeIntervalDays(weeks*7);

			setTime+=TTimeIntervalDays(7);

			TestCompareTimeL(setTime, alarm.NextDueTime(), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatWorkday:

			{

			AdjustToNextWorkDay(setTime,TheCurrentTime);

			TestCompareTimeL(setTime, alarm.NextDueTime(), __LINE__);

			}

			break;

		default:

			TheAlarmTest(0, __LINE__);

			break;

			}

		}

	}

static void TestClockUtcAlarmsL(const RArray<TAlarmId>& aIds)

//

//	We expect and TheAlarmTest.TheTest that:

//

//	1) Once alarm to remain unchanged at initial alarm time unless time in past

//	2) Next24 to advance to the first 'initial alarm time' falling due after the original time

//	3) Daily to advance to the first 'initial alarm time' falling due after the currrent time

//	4) Weekday to advance to the 'initial alarm time' on the next weekday

//	5) Weekly to advance to the 'initial alarm time' in the next week

//

	{

	TASShdAlarm alarm;

	TheCurrentTime.HomeTime();

	//

	for (TInt i=0; i<aIds.Count(); i++)

		{

		const TAlarmId id = aIds[i];

		//

		TInt r = TheAlarmTest.Session().GetAlarmDetails(id, alarm);

		if	(r != KErrNone)

			{

			// Its acceptable for the first item to be missing

			// due to a date/time change. The first item is a repeat-once

			// alarm, scheduled 1 hour in the past (i.e one hour before the

			// current time). As soon as the date/time changes, this alarm

			// will be removed from the alarm queue because it is before

			// the new date time.

			TheAlarmTest(r == KErrNotFound && i==0, __LINE__);

			}

		else

			TheAlarmTest(r == KErrNone, __LINE__);

		//

		if	(alarm.Status() != EAlarmStatusEnabled)

			continue;

		//

		TTime setTime(TheInitialAlarmTime);

		switch(alarm.RepeatDefinition())

			{

		case EAlarmRepeatDefintionRepeatOnce:

			{

			TestCompareTimeL(TheInitialAlarmTime, (alarm.NextDueTime() + User::UTCOffset()), __LINE__);

			break;

			}

		case EAlarmRepeatDefintionRepeatNext24Hours:

			{

			// Should be be within 24 hours of the original time

			TTimeIntervalDays daysBetweenInitialAndOriginal(TheOriginalTime.DaysFrom(TheInitialAlarmTime));

			setTime+=daysBetweenInitialAndOriginal;

			setTime+=TTimeIntervalHours(24);

			TestCompareTimeL(setTime, (alarm.NextDueTime() + User::UTCOffset()), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatDaily:

			{

			// Should be within next 24 hours of current time at initial time

			TTimeIntervalDays daysBetweenInitialAndCurrent(TheCurrentTime.DaysFrom(TheInitialAlarmTime));

			setTime+=daysBetweenInitialAndCurrent;

#if!defined(_DEBUG)

			// UREL

			if (!((alarm.NextDueTime() + User::UTCOffset()) < TheCurrentTime ))  // Alarm not in the past

#endif

			setTime+=TTimeIntervalHours(24);

			TestCompareTimeL(setTime, (alarm.NextDueTime() + User::UTCOffset()), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatWeekly:

			{

			TTimeIntervalDays daysBetweenInitialAndCurrent(TheCurrentTime.DaysFrom(TheInitialAlarmTime));

			TInt weeks=daysBetweenInitialAndCurrent.Int()/7;

			if (weeks!=0)

				setTime+=TTimeIntervalDays(weeks*7);

			setTime+=TTimeIntervalDays(7);

			TestCompareTimeL(setTime, (alarm.NextDueTime() + User::UTCOffset()), __LINE__);

			}

			break;

		case EAlarmRepeatDefintionRepeatWorkday:

			{

			AdjustToNextWorkDay(setTime,TheCurrentTime);

			TestCompareTimeL(setTime, (alarm.NextDueTime() + User::UTCOffset()), __LINE__);

			}

			break;

		default:

			TheAlarmTest(0, __LINE__);

			break;

			}

		}

	}

static void TestAdvanceTimeToBeforeNextAlarmsL()

//

//	Advance time by 22 hours, just before next alarms.

//

	{

	TTime newTime=TheOriginalTime;

	newTime+=TTimeIntervalHours(22);

    RPIMTestServer serv;

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

    serv.SetHomeTime(newTime);

    serv.Close();

	User::After(KTimeToWait);

	}

static void TestAdvanceTimeAfterAlarmsL()

//

//	Advance time by a further 24 hours past daily, next24, and weekday

//	alarms if tomorrow is a weekday.

//

	{

	TTime newTime=TheOriginalTime;

	newTime+=TTimeIntervalHours(24);

    RPIMTestServer serv;

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

    serv.SetHomeTime(newTime);

    serv.Close();

	User::After(KTimeToWait);

	}

static void TestSetClockAlarmsL(TInt aAlarmOffsetHours,TInt aAlarmOffsetDays)

//

//	Set five alarms with each having a different alarm repeat mode.

//	Each is set with the same past time an hour ago.

//

	{

	TheAlarmTest.Test().Next(_L("Clock alarms are set properly"));

	TInt n=TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();

	TheAlarmTest(n==0, __LINE__);

	TheCurrentTime=TheOriginalTime;

	TheInitialAlarmTime=TheOriginalTime;

	if (aAlarmOffsetHours!=0)

		TheInitialAlarmTime+=TTimeIntervalHours(aAlarmOffsetHours);

	if (aAlarmOffsetDays!=0)

		TheInitialAlarmTime+=TTimeIntervalDays(aAlarmOffsetDays);

	//

	TASShdAlarm alarm;

	RArray<TInt> array;

	//

	for (TInt i=EAlarmRepeatDefintionRepeatOnce; i<=EAlarmRepeatDefintionRepeatWeekly; i++)

		{

		alarm.Reset();

		alarm.Message().Num(i);

		alarm.NextDueTime() = TheInitialAlarmTime;

		alarm.RepeatDefinition() = TAlarmRepeatDefinition(i);

		const TInt error = TheAlarmTest.Session().AlarmAdd(alarm);

		TheAlarmTest(error == KErrNone, __LINE__);

		array.AppendL(alarm.Id());

		}

	// Check that the alarms were all queued okay

	TestClockAlarmsL(array);

	TheAlarmTest.Test().Next(_L("Time adjusted to before repeats +22hr"));

	//	We expect and test that:

	//

	//	1) Once alarm to remain unchanged at initial time

	//	2) Next24 to remain at 24 hours from initial time

	//	3) Daily to remain at 24 hours from initial time

	//	4) Weekday to remain at next weekday from initial time

	//	5) Weekly to remain at 7 days from initial time

	//

	TestAdvanceTimeToBeforeNextAlarmsL();

	TestClockAlarmsL(array);

	TheAlarmTest.Test().Next(_L("Time adjusted to after repeats +24hr"));

	//	We expect and test that;

	//

	//	1) Once alarm to remain unchanged at initial time

	//	2) Next24 to remain at 24 hours from initial time

	//	3) Daily to advance to 48 hours in udeb and 24 hours in urel from initial time.

	//	4) Weekday to advance two second weekday after

	//	   initial time if day after initial time was a weekday

	//	5) Weekly to remain at 7 days from initial time

	//

	AlarmSetInThePastTest = ETrue;

	TestAdvanceTimeAfterAlarmsL();

	TestClockAlarmsL(array);

	AlarmSetInThePastTest = EFalse;

	// Tidy up and finish

	// Delete the alarm currently tested

	while(array.Count())

		{

		TheAlarmTest(array[array.Count()-1]);

		const TInt error = TheAlarmTest.Session().AlarmDelete(array[array.Count()-1]);

		TheAlarmTest(error == KErrNone || error == KErrNotFound);

		array.Remove(array.Count()-1);

		}

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue() == 0);

	TheAlarmTest.TestClearStoreL();

	array.Close();

	}

static void testNext24hours()

//

//	Test that an alarm set for 1 second ago gets set for tomorrow

//

	{

	TheAlarmTest.Test().Next(_L("Next 24 hours"));

	TInt n=TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();

	TheAlarmTest(n==0, __LINE__);

	TASShdAlarm alarm;

	TTime timeNow;

	timeNow.HomeTime();

	alarm.NextDueTime() = timeNow-TTimeIntervalSeconds(1);

	alarm.RepeatDefinition() = EAlarmRepeatDefintionRepeatNext24Hours;

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

	TheAlarmTest(alarm.Id() != KNullAlarmId, __LINE__);

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

	TheAlarmTest(alarm.Status() == EAlarmStatusEnabled, __LINE__);

	//

	TASShdAlarm alarm2;

	TheAlarmTest(TheAlarmTest.Session().GetAlarmDetails(alarm.Id(), alarm2) == KErrNone, __LINE__);

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

	TheAlarmTest(alarm2.NextDueTime() > timeNow, __LINE__);

	TInt error = TheAlarmTest.Session().AlarmDelete(alarm.Id());

	TheAlarmTest(error == KErrNone, __LINE__);

	}

static void testSetClockUtcAlarmsL(TInt aAlarmOffsetHours,TInt aAlarmOffsetDays)

//

//	Set five alarms with each having a different alarm repeat mode.

//	Each is set with the same past time an hour ago.

//

	{

	TheAlarmTest.Test().Next(_L("Clock UTC alarms are set properly"));

	TInt n=TheAlarmTest.Session().NumberOfAlarmsActiveInQueue();

	TheAlarmTest(n==0, __LINE__);

	TheCurrentTime=TheOriginalTime;

	TheInitialAlarmTime=TheOriginalTime;

	if (aAlarmOffsetHours!=0)

		TheInitialAlarmTime+=TTimeIntervalHours(aAlarmOffsetHours);

	if (aAlarmOffsetDays!=0)

		TheInitialAlarmTime+=TTimeIntervalDays(aAlarmOffsetDays);

	//

	TASShdAlarm alarm;

	RArray<TInt> array;

	//

	for (TInt i=EAlarmRepeatDefintionRepeatOnce; i<=EAlarmRepeatDefintionRepeatWeekly; i++)

		{

		alarm.Reset();

		TAlarmMessage m = alarm.Message();

		m.Num(i);

		alarm.Message()=m;

		alarm.SetUtcNextDueTime(TheInitialAlarmTime - User::UTCOffset());

		alarm.RepeatDefinition()=TAlarmRepeatDefinition(i);

		const TInt error = TheAlarmTest.Session().AlarmAdd(alarm);

		TheAlarmTest(error == KErrNone, __LINE__);

		array.AppendL(alarm.Id());

		}

	// Check that the alarms were all queued okay

	TestClockUtcAlarmsL(array);

	TheAlarmTest.Test().Next(_L("Time adjusted to before repeats +22hr"));

	//	We expect and test that:

	//

	//	1) Once alarm to remain unchanged at initial time

	//	2) Next24 to remain at 24 hours from initial time

	//	3) Daily to remain at 24 hours from initial time

	//	4) Weekday to remain at next weekday from initial time

	//	5) Weekly to remain at 7 days from initial time

	//

	TestAdvanceTimeToBeforeNextAlarmsL();

	TestClockUtcAlarmsL(array);

	TheAlarmTest.Test().Next(_L("Time adjusted to after repeats +24hr"));

	//	We expect and test that;

	//

	//	1) Once alarm to remain unchanged at initial time

	//	2) Next24 to remain at 24 hours from initial time

	//	3) Daily to advance to 48 hours in udeb and 24 hours in urel from initial time.

	//	4) Weekday to advance two second weekday after

	//	   initial time if day after initial time was a weekday

	//	5) Weekly to remain at 7 days from initial time

	//

	AlarmSetInThePastTest = ETrue;

	TestAdvanceTimeAfterAlarmsL();

	TestClockUtcAlarmsL(array);

	AlarmSetInThePastTest = EFalse;

	// Tidy up and finish

	// Delete the alarm currently tested

	while(array.Count())

		{

		TheAlarmTest(array[array.Count()-1]);

		const TInt error = TheAlarmTest.Session().AlarmDelete(array[array.Count()-1]);

		TheAlarmTest(error == KErrNone || error == KErrNotFound);

		array.Remove(array.Count()-1);

		}

	TheAlarmTest(TheAlarmTest.Session().NumberOfAlarmsActiveInQueue() == 0);

	TheAlarmTest.TestClearStoreL();

	array.Close();

	}