// 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 "TEAlarmTestAlarmPlayConfig.h"
#include <asclisession.h>
#include "consoleantestclient.h"

CTEAlarmTestAlarmPlayConfigStep::~CTEAlarmTestAlarmPlayConfigStep()
	{
	iSoundIntervals->Reset();
	delete iSoundIntervals;
	}
	
CTEAlarmTestAlarmPlayConfigStep::CTEAlarmTestAlarmPlayConfigStep()
	{
	SetTestStepName(KTEAlarmTestAlarmPlayConfigStep);
	}


TVerdict CTEAlarmTestAlarmPlayConfigStep::doTestStepL()
	{
	TESTL(GetAndCheckAlarmPlayIntervalsL());
	
	__UHEAP_MARK;
	// Get Alarm(s) from Config
	CArrayFixFlat<TASShdAlarm>*  alarmArray = new(ELeave) CArrayFixFlat<TASShdAlarm>(1);
	CleanupStack::PushL(alarmArray);
	
	TESTL(GetAlarmsFromConfigL(ConfigSection(), *alarmArray));

	TInt alarmCount = alarmArray->Count();

	for(TInt i = 0; i < alarmCount; i++)
		{
		// Add the Alarm
    	TESTL((iSession.AlarmAdd(alarmArray->At(i))==KErrNone));
		INFO_PRINTF5(_L("Alarm[%d] Added: Id=%d, State=%d, Status=%d"), i, alarmArray->At(i).Id(), alarmArray->At(i).State(), alarmArray->At(i).Status());
		}

	if( alarmArray->Count() > 0 )
		{
		TESTL(StartIntervalVerifierL(alarmArray->At(0).Id()));
		}
	else
		{
		INFO_PRINTF1(_L("AlarmPlayConfig: No Alarms specified; skipping Alarm Play Interval Tests"));
		}
	CleanupStack::PopAndDestroy(alarmArray);
	__UHEAP_MARKEND;
	return TestStepResult();			
	}


TBool CTEAlarmTestAlarmPlayConfigStep::GetAndCheckAlarmPlayIntervalsL()
	{
	// Get Alarm Play Interval from Config, and Verify that it matches what the client has.
	iSoundIntervals = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(5);

	// Get Interval info from Config
	TESTL(GetIntervalsFromConfigL(ConfigSection(),*iSoundIntervals));

	// Verify that Interval info matches GetAlarmPlayIntervalsL().
	CArrayFixFlat<TASCliSoundPlayDefinition>* intervalArrayFromClient = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(5);
	CleanupStack::PushL(intervalArrayFromClient);
	iSession.GetAlarmPlayIntervalsL(*intervalArrayFromClient);
	INFO_PRINTF2(_L("AlarmPlayConfig: NumIntervals from Client=%d"), intervalArrayFromClient->Count());

	TESTL(CompareAlarmPlayIntervals(*iSoundIntervals, *intervalArrayFromClient));

	CleanupStack::PopAndDestroy(intervalArrayFromClient);
	return ETrue;
	}


TBool CTEAlarmTestAlarmPlayConfigStep::StartIntervalVerifierL(TAlarmId aAlarmId)
	{
	TESTL(GetIntervalRepeatFromConfig(ConfigSection(), iRepeatSetting));
	TESTL(GetTimerContingencyFromConfig(ConfigSection(), iTimerContingency));

	// Instantiate the various objects we need:
	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler();
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);
	
	CActiveAlertListener* alarmListener = new(ELeave) CActiveAlertListener(*this, iCAASClient);
	CleanupStack::PushL(alarmListener);
	CActiveAlertListener* soundStartListener = new(ELeave) CActiveAlertListener(*this, iCAASClient);
	CleanupStack::PushL(soundStartListener);
	CActiveAlertListener* soundStopListener = new(ELeave) CActiveAlertListener(*this, iCAASClient);
	CleanupStack::PushL(soundStopListener);
	CInactivityTimer* inactivityTimer = CInactivityTimer::NewLC(*this);

	INFO_PRINTF3(_L("IntervalVerifier::Verify %d Intervals, with AlarmId %d"), (iSoundIntervals->Count()), (aAlarmId));
	
	TInt timeout;
	if ( iRepeatSetting == EAlarmSoundRepeatSettingStop &&
		 GetIntFromConfig(ConfigSection(), _L("Timeout"), timeout) )
		{
		INFO_PRINTF2(_L("IntervalVerifier::InactivyTimer set for %d seconds."), (timeout));
		inactivityTimer->After(timeout* 1000000);
		}
	
	if (iCAASClient.SetExtendedMode() != KErrNone)
		{
		INFO_PRINTF1(_L("IntervalVerifier::iCAASClient.SetExtendedMode() failed"));
		return EFalse;
		}

	// Setup the control variables
	iExpectedAlarmId = aAlarmId;
	iExpectedEventType = MAlarmEventHandler::EAlarmExpired;
	iExpectedInterval = 0;

	// Start the Active Listeners.
	INFO_PRINTF1(_L("IntervalVerifier::Start Listeners"));
	alarmListener->Start(MAlarmEventHandler::EAlarmExpired);
	soundStartListener->Start(MAlarmEventHandler::ESoundStarted);
	soundStopListener->Start(MAlarmEventHandler::ESoundStopped);

	// Start the Active Scheduler. The HandleAlarmEvent is responsible for stopping it.
	INFO_PRINTF1(_L("IntervalVerifier::Start Scheduler"));
	CActiveScheduler::Start();
	
	INFO_PRINTF1(_L("IntervalVerifier::Scheduler Completed"));

	// Cleanup after yourself.
	CleanupStack::PopAndDestroy(inactivityTimer);
	CleanupStack::PopAndDestroy(soundStopListener);
	CleanupStack::PopAndDestroy(soundStartListener);
	CleanupStack::PopAndDestroy(alarmListener);

	CActiveScheduler::Install(NULL);
	CleanupStack::PopAndDestroy(scheduler);

	if (TestStepResult()==EPass)
		{
		return ETrue;
		}
	else
		{
		INFO_PRINTF1(_L("IntervalVerifier::TestStepResult() != EPass"));
		return EFalse;
		}
	}

void CTEAlarmTestAlarmPlayConfigStep::HandleAlertEvent(MAlarmEventHandler::TAlertEvent aEventType, TAlarmId aAlarmId)
	{
	INFO_PRINTF4(_L("IntervalVerifier::AlertEvent Type=%d, AlarmId=%d, Interval=%d"), aEventType, aAlarmId, iExpectedInterval);

	if (aAlarmId != iExpectedAlarmId)
		{
		return;
		}

	if (aEventType != iExpectedEventType)
		{
		INFO_PRINTF3(_L("IntervalVerifier::AlertEvent Type Mismatch (%d != %d)"), aEventType, iExpectedEventType);
		SetTestStepResult(EFail);
		StopIntervalVerifier();
		}
	else if (TimeDiff(aAlarmId, aEventType) > iTimerContingency) // seconds
		{
		INFO_PRINTF2(_L("IntervalVerifier::EventTime exceeds contingency (%d seconds) "), iTimerContingency.Int());
		SetTestStepResult(EFail);
		StopIntervalVerifier();
		}
	else
		{
		switch(aEventType)
			{
		case(MAlarmEventHandler::EAlarmExpired):
			iExpectedEventType = ESoundStarted;
			break;
		case(MAlarmEventHandler::ESoundStarted):
			iExpectedEventType = ESoundStopped;
			break;
		case(MAlarmEventHandler::ESoundStopped):
			iExpectedEventType = ESoundStarted;
			// To complete the test, we want to make sure that we get an
			// "extra" interval.
			if (++iExpectedInterval > iSoundIntervals->Count())
				{
				StopIntervalVerifier();
				}
			break;
			}
		}
	}

TTimeIntervalSeconds CTEAlarmTestAlarmPlayConfigStep::TimeDiff(TAlarmId aAlarmId, MAlarmEventHandler::TAlertEvent aEventType)
	{
	// Get the current time:
	TTime timeNow;
	timeNow.UniversalTime();

	// Determine original expiry time for alarm
	TASShdAlarm alarm;
	if (iSession.GetAlarmDetails(aAlarmId, alarm) != KErrNone)
	// We didn't find the currently expired alarm. This should never happen.
		{
		INFO_PRINTF2(_L("IntervalVerifier::TimeDiff failed to find alarm with Id=%d"), aAlarmId);
		return iTimerContingency.Int() + 1; // Forces the test to fail.
		}

	TTime expectedTime;
	expectedTime = alarm.OriginalExpiryTime();
	TInt err = GetExpectedEventTime(expectedTime, aEventType);
	if(err != KErrNone)
		{
		INFO_PRINTF2(_L("IntervalVerifier::TimeDiff->GetExpectedEventTime() returned %d"), err);
		return iTimerContingency.Int() + 1; // Forces the test to fail.
		}

	TDateTime expTimeDT = expectedTime.DateTime();
	TDateTime timeNowDT = timeNow.DateTime();
	// Displayed date => DD/MM/YYYY HH:MM:SS
	INFO_PRINTF7(_L("IntervalVerifier::TimeDiff - Expected Time=%02d:%02d:%02d, Event Time=%02d:%02d:%02d"),
			expTimeDT.Hour(), expTimeDT.Minute(), expTimeDT.Second(),
			timeNowDT.Hour(), timeNowDT.Minute(), timeNowDT.Second());

	TTimeIntervalSeconds diff;
	(timeNow > expectedTime)?
			timeNow.SecondsFrom(expectedTime, diff):
			expectedTime.SecondsFrom(timeNow, diff);
	return diff;
	}

TInt CTEAlarmTestAlarmPlayConfigStep::GetExpectedEventTime(TTime& aExpectedTime, MAlarmEventHandler::TAlertEvent aEventType)
	{
	if ( iSoundIntervals->Count() == 0 )
		{
		// We only expect one event: EAlarmExpired, so don't change aExpectedTime:
		return KErrNone;
		}

	if ( iExpectedInterval < iSoundIntervals->Count() )
		{
		// Get original expiry time
		if (aEventType != EAlarmExpired)
			{
			aExpectedTime += TTimeIntervalMinutes(iSoundIntervals->At(iExpectedInterval).Offset().Int());
			if (aEventType != ESoundStarted)
				{
				// Only event left is ESoundStopped.
				aExpectedTime += TTimeIntervalSeconds(iSoundIntervals->At(iExpectedInterval).Duration().Int());
				}
			}
		}
	else
		{
		// we've exceeded the intervals; our test depends on the repeat setting
		switch (iRepeatSetting)
			{
		case(EAlarmSoundRepeatSettingLoop):
			{
			TASCliSoundPlayDefinition lastInterval = iSoundIntervals->At(iSoundIntervals->Count()-1);

			// How many times have we been around?
			TInt loopCount = (iExpectedInterval) / (iSoundIntervals->Count());
			// Restart time is offset by (last Offset + last Duration) * loopCount.
			aExpectedTime += TTimeIntervalMinutes(lastInterval.Offset().Int() * loopCount);
			aExpectedTime += TTimeIntervalSeconds(lastInterval.Duration().Int() * loopCount);
			
			TInt adjustedInterval = (iExpectedInterval) % (iSoundIntervals->Count());
			// We can safely assume that the aEventType is *not* EAlarmExpired
			aExpectedTime += TTimeIntervalMinutes(iSoundIntervals->At(adjustedInterval).Offset().Int());
			if (aEventType == ESoundStopped)
				{
				aExpectedTime += TTimeIntervalSeconds(iSoundIntervals->At(adjustedInterval).Duration().Int());
				}
			}
			break;
		case(EAlarmSoundRepeatSettingRepeatLast):
			{
			TASCliSoundPlayDefinition secondToLastInterval = iSoundIntervals->At(iSoundIntervals->Count()-2);
			TASCliSoundPlayDefinition lastInterval = iSoundIntervals->At(iSoundIntervals->Count()-1);

			TTimeIntervalMinutes lastOffsetDuration = lastInterval.Offset().Int() - secondToLastInterval.Offset().Int();
			

			// Determine the time that the last interval's sound stopped:
			TInt repeatCount = 1 + iExpectedInterval - (iSoundIntervals->Count());

			aExpectedTime += TTimeIntervalMinutes(lastOffsetDuration.Int() * repeatCount );

			// We can safely assume that the aEventType is *not* EAlarmExpired
			aExpectedTime += TTimeIntervalMinutes(lastInterval.Offset().Int());
			if (aEventType == ESoundStopped)
				{
				aExpectedTime += TTimeIntervalSeconds(lastInterval.Duration().Int());
				}
			}
			break;
		case(EAlarmSoundRepeatSettingStop):
			INFO_PRINTF3(_L("IntervalVerifier::Interval Index(%d) >= Interval Count(%d). RepeatSetting=Stop"),
						iExpectedInterval, iSoundIntervals->Count());
			return KErrGeneral;
		default:
			INFO_PRINTF3(_L("IntervalVerifier::Unexpected RepeatSetting(%d) with Interval Index(%d)"),
						iRepeatSetting, iExpectedInterval);
			return KErrCorrupt;
			}
		}
	return KErrNone;
	}

void CTEAlarmTestAlarmPlayConfigStep::InactivityTimerExpired()
	{
	INFO_PRINTF1(_L("IntervalVerifier::InactivityTimerExpired."));
	TEST(iRepeatSetting == EAlarmSoundRepeatSettingStop);
	TEST(iExpectedInterval <= iSoundIntervals->Count() );
	StopIntervalVerifier();
	}

void CTEAlarmTestAlarmPlayConfigStep::StopIntervalVerifier()
	{
	INFO_PRINTF1(_L("IntervalVerifier::Stop Scheduler"));
	CActiveScheduler::Stop();
	}

/*
 * Initializes the Active Object and adds itself to the Scheduler.
 */
CActiveAlertListener::CActiveAlertListener(MAlarmEventHandler& aHandler, RANTestClient& aClient) : CActive(EPriorityStandard), iHandler(aHandler), iClient(aClient)
	{
	CActiveScheduler::Add(this);
	}

/*
 * Cleanups after the Active Object.
 */
CActiveAlertListener::~CActiveAlertListener()
	{
	Deque();
	}

/*
 * Starts the Active Objects by regitering for a asynchronous notification
 * Called by the test step.
 */
TBool CActiveAlertListener::Start(MAlarmEventHandler::TAlertEvent aEventTypeToWaitFor)
	{
	if (IsActive())
		{
		return EFalse;
		}

	switch(aEventTypeToWaitFor)
		{
	case(MAlarmEventHandler::EAlarmExpired):
	case(MAlarmEventHandler::ESoundStarted):
	case(MAlarmEventHandler::ESoundStopped):
		iEventType = aEventTypeToWaitFor;
		break;
	default:
		return EFalse;
		}
	RegisterForNextEvent();
	return ETrue;
	}

void CActiveAlertListener::DoCancel()
	{
	iClient.CancelNotifications();
	}

/*
 * We've receive an event, be sure to pass it along to the test step for proper handling...
 */
void CActiveAlertListener::RunL()
	{
	if (iStatus == KErrNone)
		{
		if (iEventType == MAlarmEventHandler::EAlarmExpired)
			{
			iAlarmId = iExpiredAlarm.Id();
			}
		RegisterForNextEvent();
		}
	iHandler.HandleAlertEvent(iEventType, iAlarmId);
	}

/*
 * Register For the next event.
 */
void CActiveAlertListener::RegisterForNextEvent()
	{
	switch(iEventType)
		{
	case(MAlarmEventHandler::EAlarmExpired):
		iClient.NotifyOnAlarm(iExpiredAlarm, iStatus);
		break;
	case(MAlarmEventHandler::ESoundStarted):
		iClient.NotifyOnSoundStart(iAlarmId, iFileName, iStatus);
		break;
	case(MAlarmEventHandler::ESoundStopped):
		iClient.NotifyOnSoundStop(iAlarmId, iStatus);
		break;
	default:
		// We should have never gotten to here:
		User::Invariant();
		}
	SetActive();
	}

/*
 * This object is used for verifying the RepeatSetting=Stop behavior.
 */
CInactivityTimer* CInactivityTimer::NewLC(MAlarmEventHandler& aHandler)
	{
	CInactivityTimer* timer = new(ELeave) CInactivityTimer(aHandler);
	CleanupStack::PushL(timer);
	timer->ConstructL();
	return timer;
	}

/*
 * Let's the test step know that the timer expired.
 */
void CInactivityTimer::RunL()
	{
	iHandler.InactivityTimerExpired();
	}
	
/*
 * Initializes the object
 */
CInactivityTimer::CInactivityTimer(MAlarmEventHandler& aHandler) : CTimer(EPriorityStandard), iHandler(aHandler)
	{
	CActiveScheduler::Add(this);
	}
	
CTEAlarmTestAPCSetIntervalsStep::~CTEAlarmTestAPCSetIntervalsStep()
	{
	}
	
CTEAlarmTestAPCSetIntervalsStep::CTEAlarmTestAPCSetIntervalsStep()
	{
	SetTestStepName(KTEAlarmTestAPCSetIntervalsStep);
	}

TVerdict CTEAlarmTestAPCSetIntervalsStep::doTestStepL()
	{
	// Check result from preamble and setup test step result.
	if(TestStepResult() != EPass)
		{
		return TestStepResult();
		}
	
	__UHEAP_MARK;
	// Get Alarm Play Interval from Config, and Verify that it matches what the client has.
	CArrayFixFlat<TASCliSoundPlayDefinition>* intervalsFromConfig = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(5);
	CleanupStack::PushL(intervalsFromConfig);

	// Get Interval info from Config
	TESTL(GetIntervalsFromConfigL(ConfigSection(),*intervalsFromConfig));

	INFO_PRINTF2(_L("Loaded Intervals From Config - Count=%d"), intervalsFromConfig->Count());

	// Verify that Interval info matches GetAlarmPlayIntervalsL().
	CArrayFixFlat<TASCliSoundPlayDefinition>* origIntervalsFromClient = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(5);
	CleanupStack::PushL(origIntervalsFromClient);
		
	iSession.GetAlarmPlayIntervalsL(*origIntervalsFromClient);
	INFO_PRINTF2(_L("Loaded Intervals From Client - Count=%d"), origIntervalsFromClient->Count());

	INFO_PRINTF1(_L("Make sure there are differences between the current and new intervals:"));
	TESTL(!CompareAlarmPlayIntervals(*intervalsFromConfig, *origIntervalsFromClient));

	INFO_PRINTF2(_L("Setting AlarmPlayIntervals, Count = %d"), intervalsFromConfig->Count());

	if( 0 == intervalsFromConfig->Count() )
		{
		TRAPD(err, iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig));
		TESTL(err == KErrArgument || err == KErrGeneral);
		}
	else if ( 0 == origIntervalsFromClient->Count() )
		{
		TRAPD(err, iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig));
		TESTL(err == KErrNotSupported );
		}
	else
		{
		iSession.SetAlarmPlayIntervalsL(*intervalsFromConfig);
		}
		
	CArrayFixFlat<TASCliSoundPlayDefinition>* updatedIntervalsFromClient = new(ELeave) CArrayFixFlat<TASCliSoundPlayDefinition>(5);
	CleanupStack::PushL(updatedIntervalsFromClient);

	iSession.GetAlarmPlayIntervalsL(*updatedIntervalsFromClient);
	INFO_PRINTF2(_L("Loaded Intervals From Client - Count=%d"), updatedIntervalsFromClient->Count());

	if (origIntervalsFromClient->Count() == 0)
		{
		INFO_PRINTF1(_L("SoundIntervals are disabled in Client - Setting should have failed"));
		TESTL(CompareAlarmPlayIntervals(*origIntervalsFromClient, *updatedIntervalsFromClient));
		}
	else if (intervalsFromConfig->Count() == 0)
		{
		INFO_PRINTF1(_L("SoundIntervals are enabled in Client - Disabling should have failed"));
		TESTL(CompareAlarmPlayIntervals(*origIntervalsFromClient, *updatedIntervalsFromClient));
		}
	else
		{
		TESTL(CompareAlarmPlayIntervals(*intervalsFromConfig, *updatedIntervalsFromClient));
		}

	CleanupStack::PopAndDestroy(updatedIntervalsFromClient);
	CleanupStack::PopAndDestroy(origIntervalsFromClient);
	CleanupStack::PopAndDestroy(intervalsFromConfig);
	__UHEAP_MARKEND;
	return TestStepResult();
	}