// Copyright (c) 2005-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 "TEAlarmTestMultipleAlarmsStep.h"

#include "TEAlarmTestMANEventObserver.h"

// Config Parameter names

_LIT(KAlarmNN,"Alarm%02d");

_LIT(KEventNN,"Event%02d");

_LIT(KActionNN,"Action%02d");

// Config subparameter values

_LIT(KStateInPreparation,	"InPreparation");

_LIT(KStateQueued,			"Queued");

_LIT(KStateNotifying,		"Notifying");

_LIT(KStateWaitingToNotify,	"WaitingToNotify");

_LIT(KStateSnoozed,			"Snoozed");

_LIT(KStateNotified,		"Notified");

_LIT(KVisible,				"Visible");

_LIT(KNotVisible,			"NotVisible");

_LIT(KSoundOn,				"Playing");

_LIT(KSoundOff,				"NotPlaying");

_LIT(KTimeFormatPattern, "%H:%T:%S.%*C3");

_LIT(KZeroTime,"20050601:130000.000000");

// Message strings

_LIT(KExpiresInDSeconds, " expires in %d seconds");

_LIT(KExpiresNow, " expires NOW");

_LIT(KObserverDying, "Observer is dying (%S)");

_LIT(KErrorDS, "ERROR (%d)     %S");

_LIT(KErrorUnexpectedEvent, "ERROR Unexpected event %d");

_LIT(KLitSS, "%S: %S");

_LIT(KLitSSIgnoringEvent, "%S: %S       Ignoring the event because of UserWait mode.");

_LIT(KLitSSExpectedS, "%S: %S       Expected %S");

_LIT(KLitAlarmStateDSSS, "A%02d   state=%S   visible=%S   sound playing=%S");

_LIT(KAlarmStateCheckPassedOK, "Alarm State check PASSED OK.");

_LIT(KAlarmStateOnlyCheckPassedOK, "Alarm StateOnly check PASSED OK.");

_LIT(KDoDelayedActionReconnectToCAASSuccess, \

				"::DoDelayedActionL(): Reconnected to ConsoleAAS successfully");		

_LIT(KDoDelayedActionReconnectToASSuccess, \

				"::DoDelayedActionL(): Reconnected to AlarmServer successfully");

_LIT(KDoDelayedActionCAASMaxAlarmsSetToD, \

				"::DoDelayedActionL(): ConsoleAAS.MAXALARMS SET TO %d");

_LIT(KUnexpectedAlarmState, "TEST FAILED: State of an Alarm is not as expected");

_LIT(KUnexpectedEvent, "TEST FAILED: SEQUENCE OF EVENTS IS NOT AS EXPECTED");

_LIT(KUnknownFailure, "TEST FAILED: Don't know what's actually happened");

_LIT(KAlarmStateSummaryStart, "* * * ALARM STATE SUMMARY * * *");

_LIT(KAlarmStateSummaryEnd, "* * * SUMMARY ENDS        * * *");

_LIT(KLoadedDAlarms, "GetAlarmsFromConfigL: Loaded %d Alarms");

_LIT(KLoadedDEvents, "GetEventsFromConfigL: Loaded %d Events");

// //

//

// CTestStep inherited methods

//

// //

CTEAlarmTestMultipleAlarmsStep::CTEAlarmTestMultipleAlarmsStep()

	{

	SetTestStepName(KTEAlarmTestMultipleAlarmsStep);

	iInUserWaitMode = EFalse;

	iStarted = Time::NullTTime();

	}

CTEAlarmTestMultipleAlarmsStep::~CTEAlarmTestMultipleAlarmsStep()

	{

	iCAASClient.CancelNotifications();

	iBunchOfObservers.ResetAndDestroy();	// RPointerArray<CMANEventObserver>

	iBunchOfDelayedHandlers.ResetAndDestroy(); // RPointerArray<CMANDelayedActionHandler>

	delete iAlarmListPtr;					// CArrayFixFlat<TAlarmEntry>*

	iEventList.Close();						// RArray<TEventEntry>

	CActiveScheduler* sched = CActiveScheduler::Current();

	delete sched;

	CActiveScheduler::Install(NULL);

	}

TVerdict CTEAlarmTestMultipleAlarmsStep::doTestStepPreambleL()

	{

	// Need to call base class doTestPreambleL() to start AS and CAAS

	TESTL(CTEAlarmTestStepBase::doTestStepPreambleL()==EPass);

	// Alarm list

	iAlarmListPtr = new (ELeave) CArrayFixFlat<TAlarmEntry>(KGranularity);

	// Active Scheduler

	CActiveScheduler* sched = new (ELeave) CActiveScheduler;

	CActiveScheduler::Install(sched);

	// Read config from ini file	

	TESTL(GetAlarmsFromConfigL(ConfigSection(), *iAlarmListPtr));

	TESTL(GetEventsFromConfigL(ConfigSection(), iEventList));

	// Fine

	return TestStepResult();

	}

TVerdict CTEAlarmTestMultipleAlarmsStep::doTestStepL()

	{

	StartEventObserversL();

	User::After(500000);

	iStarted.UniversalTime();

	RegisterAlarmsL();

	// Process Sequence of Events

	CActiveScheduler::Start();

	// Finish

	return TestStepResult();			

	}

// //

//

// CTEAlarmTestMultipleAlarmsStep own methods HANDLE EVENTS and DO ACTIONS

//

// //

void CTEAlarmTestMultipleAlarmsStep::HandleEventL(TEventEntry aCurrentEvent)

	{

	GetAlarmListIdxbyAlarmId(aCurrentEvent);

	LogEventL(aCurrentEvent);

	if (aCurrentEvent.iError!=KErrNone)

		{

		return;

		}

	if (aCurrentEvent.IsAction())

		{

		DoDelayedActionL(aCurrentEvent);

		if (iInUserWaitMode)

			{

			return;

			}

		}

	if (aCurrentEvent.IsEvent())

		{

		// an Event

		DoProcessEventL(aCurrentEvent);

		if (iInUserWaitMode)

			{

			return;

			}

		if (!DidWeExpectThisEvent(aCurrentEvent))

			{

			// Test Failed: Unexpected Event

			ReportFailureAndStopL(EUnexpectedEvent);

			return;

			}

		}

	// check what's next on the EventList

	TEventEntry nextEvent = aCurrentEvent;

	if (aCurrentEvent.IsEvent())

		{

		// if we've just processed an event, then get next event from EventList

		if (!GetNextEvent(nextEvent))

			{

			// if it's the last item on the list

			return;

			}

		}

	else

		{

		// if we've just did an action, then have

		// to deal with current item on the EventList

		nextEvent = iEventList[iCurrentEventIdx];

		}

	// as long as next item is action, do it immediately

	// if next item is an event, then break and wait for next event

	do	{

		if (nextEvent.IsEvent())  

			{

			// go wait for next event

			break;

			}

		LogEventL(nextEvent);

		if (!DoImmediateActionL(nextEvent))

			{

			// needs asynchronous handling (like UserWait or failure)

			if (iCurrentEventIdx < iEventList.Count()-1 )

				{

				GetNextEvent(nextEvent);

				}

			return; 

			}

	} while (GetNextEvent(nextEvent));

	}

TBool CTEAlarmTestMultipleAlarmsStep::GetNextEvent(TEventEntry& aEvent)

	{

	if ( iCurrentEventIdx >= iEventList.Count()-1 )

		{

		CActiveScheduler::Stop();

		return EFalse;

		}	

	aEvent = iEventList[++iCurrentEventIdx];

	return ETrue;

	}

TBool CTEAlarmTestMultipleAlarmsStep::DidWeExpectThisEvent(const TEventEntry& aEvent)

	{

	return (iEventList[iCurrentEventIdx]==aEvent);

	}

void CTEAlarmTestMultipleAlarmsStep::DoProcessEventL(const TEventEntry& aEvent)

	{

	switch (aEvent.iType)

		{

	case EEventSetAlarm:

		AlarmAt(aEvent.iAlarmIdx).iNotifying = ETrue;

		break;

	case EEventVisible:

		AlarmAt(aEvent.iAlarmIdx).iVisible = aEvent.iVisible;

		break;

	case EEventSoundStart:

		AlarmAt(aEvent.iAlarmIdx).iSoundPlaying = ETrue;

		break;

	case EEventSoundStop:

		AlarmAt(aEvent.iAlarmIdx).iSoundPlaying = EFalse;

		break;

	case EEventDelete:

		if (aEvent.iAlarmIdx != KBogusAlarmIdx)

			{

			AlarmAt(aEvent.iAlarmIdx).iNotifying = EFalse;

			}

		else // this is a DeleteAll command

			{

			for (TInt i = iAlarmListPtr->Count()-1; i >= 0; i--)

				{

				AlarmAt(i).iNotifying = EFalse;

				}

			}

		break;

	case EEventSetState:

		// Do nothing

		break;

	default:	

		ERR_PRINTF2(KErrorUnexpectedEvent, aEvent.iType);

		User::Leave(KErrArgument);

		break;

		}

	}

TBool CTEAlarmTestMultipleAlarmsStep::DoImmediateActionL(const TEventEntry& aEvent)

	{

	switch (aEvent.iType)

		{

		case EActionCheckState:

			UpdateAlarmDetails(aEvent.iAlarmIdx);

			LogAlarmStateL(aEvent.iAlarmIdx);

			if ( !CheckAlarmState(aEvent) )

				{

				// Test Failed: Alarm is in an unexpected state

				ReportFailureAndStopL(EUnexpectedAlarmState);

				return EFalse;

				}

			else

				{

				INFO_PRINTF1(KAlarmStateCheckPassedOK);

				}

			break;

		case EActionCheckStateOnly:

			UpdateAlarmDetails(aEvent.iAlarmIdx);

			LogAlarmStateL(aEvent.iAlarmIdx);

			if ( !CheckAlarmStateOnly(aEvent) )

				{

				// Test Failed: Alarm is in an unexpected state

				ReportFailureAndStopL(EUnexpectedAlarmState);

				return EFalse;

				}

			else

				{

				INFO_PRINTF1(KAlarmStateOnlyCheckPassedOK);

				}

			break;

		case EActionSnooze:

			{

			TASShdAlarm& shdAlarm = ShdAlarmAt(aEvent.iAlarmIdx);				

			TTime snoozeTime;

			snoozeTime.UniversalTime();

			snoozeTime += TTimeIntervalSeconds(aEvent.iPeriod);

			iCAASClient.SnoozeAlarm(shdAlarm.Id(), snoozeTime);

			}

			break;

		case EActionPauseSound:

			{

			TASShdAlarm& shdAlarm = ShdAlarmAt(aEvent.iAlarmIdx);				

			TTime pauseTime;

			pauseTime.UniversalTime();

			pauseTime += TTimeIntervalSeconds(aEvent.iPeriod);

			iCAASClient.PauseSoundForAlarm(shdAlarm.Id(), pauseTime);

			}

			break;

		case EActionSilence:

			{

			TAlarmId alarmId = ShdAlarmAt(aEvent.iAlarmIdx).Id();

			iCAASClient.SilenceAlarm(alarmId);

			}

			break;

		case EActionClear:

			if (aEvent.iAlarmIdx==KAllAlarms)

				{

				iCAASClient.AcknowledgeAll();

				}

			else 

				{

				TAlarmId alarmId = ShdAlarmAt(aEvent.iAlarmIdx).Id();

				iCAASClient.AcknowledgeAlarm(alarmId);

				}

			break;

		case EActionUserWait:

			if (!iInUserWaitMode)

				{

				UserWaitL(aEvent.iPeriod);

				return EFalse;

				}

			break;

		case EActionReconnectToAS:

			if (!iInUserWaitMode)

				{

				ReconnectToASL();

				return EFalse;

				}

			break;

		case EActionAddAlarm:

			AddAlarm(aEvent.iAlarmIdx);

			break;

		case EActionDeleteAlarm:

			{

			TAlarmId alarmId = ShdAlarmAt(aEvent.iAlarmIdx).Id();

			iSession.AlarmDelete(alarmId);

			}

			break;

		case EException:	// ...fall through

		case EUnknown:		// ...fall through

		default:

				{

				ReportFailureAndStopL(EUnexpectedAlarmState);

				return EFalse;

				}

		}

	return ETrue;

	}

TBool CTEAlarmTestMultipleAlarmsStep::DoDelayedActionL(const TEventEntry& aEvent)

	{

	switch (aEvent.iType)

		{

		case EActionUserWait:

					// UserWait period completed

					if (iInUserWaitMode)

						{

						iInUserWaitMode = EFalse;

						}

					else

						{

						TESTL(EFalse);

						}

					break;

		case EActionReconnectToAS:

					// time to reconnect to Alarm Server

					if (iInUserWaitMode)

						{

						iInUserWaitMode = EFalse;

						// connect to Alarm Server

						TESTL(iSession.Connect()==KErrNone);

						// connect to ConsoleAlarmAlertServer

						TESTL(iCAASClient.Connect()==KErrNone);

						INFO_PRINTF1(KDoDelayedActionReconnectToCAASSuccess);

						if (iMaxAlarms>0)

							{

							iCAASClient.SetExtendedMode();

							iCAASClient.SetMaxAlarms(iMaxAlarms);

							INFO_PRINTF2(KDoDelayedActionCAASMaxAlarmsSetToD, iMaxAlarms);		

							} 

						// connect to Alarm Server

						TESTL(iSession.Connect()==KErrNone);

						INFO_PRINTF1(KDoDelayedActionReconnectToASSuccess);

						// restore observers

						StartEventObserversL();

						}

					else

						{

						TESTL(EFalse);

						}

					break;

		case EActionAddAlarm:

					AddAlarm(aEvent.iAlarmIdx);

					return EFalse;

		case EActionCheckState:		// ...fall through

		case EActionCheckStateOnly:	// ...fall through

		case EActionSnooze:			// ...fall through

		case EActionClear:			// ...fall through

		case EActionPauseSound:		// ...fall through

		case EActionSilence:		// ...fall through

		case EActionDeleteAlarm:	// ...fall through

		case EException:			// ...fall through

		case EUnknown:				// ...fall through

		default:	

					TESTL(EFalse);

		}

	return ETrue;

	}

// //

//

// CTEAlarmTestMultipleAlarmsStep -> ALARMS and OBSERVERS

//

// //

TInt CTEAlarmTestMultipleAlarmsStep::GetAlarmListIdxbyAlarmId(TEventEntry& aEvent)

	{

	if (aEvent.iAlarmId==KNullAlarmId) 

		{

		return KBogusAlarmIdx;

		}

	TInt nofAlarms = iAlarmListPtr->Count();

	for (TInt idx=0; idx<nofAlarms; idx++)

		{

		if ( ShdAlarmAt(idx).Id() == aEvent.iAlarmId )

			{

			return aEvent.iAlarmIdx = idx;

			}

		}

	return KBogusAlarmIdx;

	}

void CTEAlarmTestMultipleAlarmsStep::AddObserverL(const TEventEntry& aEvent)

	{

	CMANEventObserver* pObserver = CMANEventObserver::NewL(aEvent, iCAASClient, *this);

	CleanupStack::PushL(pObserver);

	iBunchOfObservers.AppendL(pObserver);

	CleanupStack::Pop();

	}

void CTEAlarmTestMultipleAlarmsStep::AddDelayedHandlerL(const TEventEntry& anAction)

	{

	CMANDelayedActionHandler* pHandler = 

					CMANDelayedActionHandler::NewL(anAction, *this);

	CleanupStack::PushL(pHandler);

	iBunchOfDelayedHandlers.AppendL(pHandler);

	CleanupStack::Pop();

	}

void CTEAlarmTestMultipleAlarmsStep::StartEventObserversL()

	{

	for (TEventType eventType=EEventSetAlarm; 

				eventType<=EEventDelete; 

					eventType=TEventType(eventType+1))

		{

		TEventEntry event(eventType);

		AddObserverL(event);

		}

	}

void CTEAlarmTestMultipleAlarmsStep::RegisterAlarmsL()

	{

	TEventEntry	event(EActionAddAlarm);

	TInt nofAlarms = iAlarmListPtr->Count();

	for (TInt idx=0; idx<nofAlarms; idx++)

		{

		event.iAlarmIdx = idx;

		event.iPeriod = AlarmAt(idx).iDelay;

		AddDelayedHandlerL(event);

		}

	}