// 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:
// Implementation of CASSrvNotifyingAlarmMngr
// 
//

/**
 @file
 @internalTechnology
*/

#include "ASSrvNotifyingAlarmMngr.h"
#include "ASSrvServerWideData.h"
#include "ASSrvTimer.h"
#include "ASSrvAlarmQueue.h"
#include "ASSrvNotificationCoordinator.h"

/**
Standard 2 phase constructor
*/
CASSrvNotifyingAlarmMngr* CASSrvNotifyingAlarmMngr::NewL(CASSrvNotificationCoordinator& aParent, CASSrvServerWideData& aServerWideData)
	{
	CASSrvNotifyingAlarmMngr* self = new (ELeave) CASSrvNotifyingAlarmMngr(aParent, aServerWideData);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

/**
Destructor
*/
CASSrvNotifyingAlarmMngr::~CASSrvNotifyingAlarmMngr()
	{
	ServerWideData().Timer().NotifyAlarmExpiredCancel(*this);
	iCurrentlyNotifyingAlarmIds.Close();
	}

/**
Standard 2nd phase constractor
*/
void CASSrvNotifyingAlarmMngr::ConstructL()
	{
	ServerWideData().Timer().NotifyAlarmExpiredL(*this);
	}

/**
Standard private constructor
*/
CASSrvNotifyingAlarmMngr::CASSrvNotifyingAlarmMngr(CASSrvNotificationCoordinator& aParent, CASSrvServerWideData& aServerWideData)
:iParent(aParent), iServerWideData(aServerWideData)
	{
	}

/**
Set the maximum number of alarms supported by Alert Server
*/
void CASSrvNotifyingAlarmMngr::SetMaxNumberOfAlarms(TInt aMaxAlarms)
	{
	iMaxNumberOfAlarms = aMaxAlarms;
	}

/**
@see MASSrvAlarmTimerObserver
*/
void CASSrvNotifyingAlarmMngr::MATimerHandleAlarmExpired(TAlarmTimerEvent aEvent, TAlarmId aAlarmId)
	{
	if (aEvent != EAlarmTimerEventAlarmExpired)
		{
		return;
		}

	CASSrvAlarmQueue& queue = ServerWideData().Queue();
	TASSrvAlarm* justExpiredAlarm = queue.QueueAlarmById(aAlarmId);

	if (SoleNotifyingAlarmHasSoundPaused())
	// If there's 1 alarm notifying and it has it's sound paused,
		{
		// then we'll snooze it and take it's place.
		TASSrvAlarm* pausedAlarm = queue.QueueAlarmById(iCurrentlyNotifyingAlarmIds[0]);
		pausedAlarm->SetState(EAlarmStateSnoozed);
		SetAsNextNotifyingAlarm(aAlarmId);
		}
	else if (AllowMoreNotifyingAlarms())
	// If the number of notifying alarm is less than maximum allowed
		{
		if (iParent.SetAlarmInProgress())
		// Alert server hasn't replied to the previous alarm...
			{
			// set the alarm state to waiting to notify
			justExpiredAlarm->SetState(EAlarmStateWaitingToNotify);
			}
		else 
			{
			SetAsNextNotifyingAlarm(aAlarmId);
			}
		}
	else
	// The max number of allowed alarm has reached, set the state of the just 
	// expired alarm depending on its exipry time
		{
		TAlarmId youngestAlarmId(YoungestNotifyingAlarmId());
		TASSrvAlarm* youngestAlarm = queue.QueueAlarmById(youngestAlarmId);
		if	(justExpiredAlarm->OriginalExpiryTime() < youngestAlarm->OriginalExpiryTime() && !justExpiredAlarm->HasSoundPaused())
			{
			// The alarm that just expired is actually older than an alarm
			// we're notifying about. This kind of thing can occur
			// when somebody adds an alarm to the alarm server which is 
			// in the past, e.g a day in the past, and the alarm server is 
			// already notifying about an alarm which is 1 minute old.
			//
			// In this case, an alarm which we were notifying about should no
			// longer in the notifying queue, therefore we set its state back
			// to "waiting to notify" and then proceed to notify about this
			// new alarm.
			youngestAlarm->SetState(EAlarmStateWaitingToNotify);
			SetAsNextNotifyingAlarm(aAlarmId);
			}
		else
			{
			justExpiredAlarm->SetState(EAlarmStateWaitingToNotify);
			}
		}
	}

/**
Return the server data object.
*/
CASSrvServerWideData& CASSrvNotifyingAlarmMngr::ServerWideData() const
	{
	return iServerWideData;
	}

/**
Set the alarm with the given alarm id to be the next notifying alarm
@param aAlarmId the id of the alarm to set to notifying state
*/
void CASSrvNotifyingAlarmMngr::SetAsNextNotifyingAlarm(TAlarmId aAlarmId)
	{
	// This function shouldn't be called if max # of alarm has reached
	__ASSERT_DEBUG(AllowMoreNotifyingAlarms(), 
		ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultNotifyAlarmExceedMax));

	CASSrvAlarmQueue& queue = ServerWideData().Queue();
	TASSrvAlarm* alarm = queue.QueueAlarmById(aAlarmId);

	// Update the alarm we are notifying about
	if (iCurrentlyNotifyingAlarmIds.Append(aAlarmId) != KErrNone)
		{
		ASSrvStaticUtils::Panic(ASSrvStaticUtils::EASSrvPanicOutOfMemory);
		}

	// Now we can start notifying this new alarm. Because this class observes all
	// state or status changes, we will be notified about the change and will
	// update the Alarm Alert Server accordingly.
	TAlarmState state(EAlarmStateNotifying);
#ifdef _DEBUG
	if (iParent.PreventUserNotification())
		{
		state = EAlarmStateNotified;
		// Remove the alarm from notifying list
		iCurrentlyNotifyingAlarmIds.Remove(iCurrentlyNotifyingAlarmIds.Count() - 1);
		}
#endif
	alarm->SetState(state);
	}

TBool CASSrvNotifyingAlarmMngr::AmNotifyingAboutAlarm() const
	{
	return (iCurrentlyNotifyingAlarmIds.Count() > 0);
	}

/**
Locate and initiate notifications for the next alarm in the queue that is waiting
@param aUpdate if true, update alert server if next alarm is not available
*/
void CASSrvNotifyingAlarmMngr::FindAndExecuteNextAlarmAwaitingNotification(TBool aUpdate)
	{
	if(AllowMoreNotifyingAlarms() && ServerWideData().Queue().HaveAdditionalAlarmsToNotify())
		{
		TASSrvAlarm& alarm = ServerWideData().Queue().NextAlarmWaitingForNotification();
		SetAsNextNotifyingAlarm(alarm.Id());
		}
	else if (aUpdate && !AmNotifyingAboutAlarm())
		{
		// Alarm server has no more alarm to notify, so update Alert Server
		// visibility and flags
		iParent.UpdateAlarmAlertServer(KNullAlarmId);
		}
	}

/**
Check if the given alarm is in the alarm notifying list
*/
TBool CASSrvNotifyingAlarmMngr::AlarmIsNotifying(TAlarmId aAlarmId) const
	{
	if (iCurrentlyNotifyingAlarmIds.Find(aAlarmId) != KErrNotFound)
		{
		return ETrue;
		}
	return EFalse;	
	}

/**
Check if alert server can accept more notifying alarm
*/
TBool CASSrvNotifyingAlarmMngr::AllowMoreNotifyingAlarms() const
	{
	if (iCurrentlyNotifyingAlarmIds.Count() < iMaxNumberOfAlarms)
		{
		return ETrue;
		}
	return EFalse;	
	}

/*
Returns the Alarm Id for the "youngest" notifying alarm, ie. with the largest (latest) OriginalExpiryTime.
*/
TAlarmId CASSrvNotifyingAlarmMngr::YoungestNotifyingAlarmId() const
	{
	// This function shouldn't be called if there are no notifying alarms
	__ASSERT_DEBUG(iCurrentlyNotifyingAlarmIds.Count(), 
		ASSrvStaticUtils::Fault(ASSrvStaticUtils::EASSrvFaultNoNotifyingAlarms));

	CASSrvAlarmQueue& queue = ServerWideData().Queue();

	TAlarmId youngestAlarm(iCurrentlyNotifyingAlarmIds[0]);
	TTime latestTime(queue.QueueAlarmById(youngestAlarm)->OriginalExpiryTime());

	for(TInt i = iCurrentlyNotifyingAlarmIds.Count()-1; i >= 1 ; i--)
		{
		TASSrvAlarm* currentAlarm = queue.QueueAlarmById(iCurrentlyNotifyingAlarmIds[i]);

		if	(latestTime < currentAlarm->OriginalExpiryTime())
			{
			youngestAlarm = currentAlarm->Id();
			latestTime = queue.QueueAlarmById(youngestAlarm)->OriginalExpiryTime();
			}
		}

	return youngestAlarm;
	}


/*
Determine if there is only 1 Notifying Alarm and if has it's Sound Paused.
@return ETrue if this is true. Otherwise EFalse
*/
TBool CASSrvNotifyingAlarmMngr::SoleNotifyingAlarmHasSoundPaused() const
	{
	if( iCurrentlyNotifyingAlarmIds.Count() != 1 )
		{
		return EFalse;
		}

	TASSrvAlarm* notifyingAlarm = ServerWideData().Queue().QueueAlarmById(iCurrentlyNotifyingAlarmIds[0]);

	if	(notifyingAlarm->HasSoundPaused())
		{
		return ETrue;
		}

	return EFalse;
	}

/**
Remove an alarm from the notifying alarm list
@param aAlarmId the id of the alarm to be removed
@return ETrue if the alarm was in the notifying list before removal. Otherwise EFalse
*/
TBool CASSrvNotifyingAlarmMngr::RemoveNotifyingAlarm(TAlarmId aAlarmId)
	{
	TInt alarmIndex(iCurrentlyNotifyingAlarmIds.Find(aAlarmId));
	if (alarmIndex == KErrNotFound)
		{
		return EFalse;
		}
	
	iCurrentlyNotifyingAlarmIds.Remove(alarmIndex);
	return ETrue;
	}

/**
Remove all alarms from the notifying alarm list
*/
void CASSrvNotifyingAlarmMngr::RemoveAllNotifyingAlarms()
	{
	iCurrentlyNotifyingAlarmIds.Reset();
	}

/**
Return the number of the notifying alarm
*/
TInt CASSrvNotifyingAlarmMngr::NumberOfNotifyingAlarm()
	{
	return iCurrentlyNotifyingAlarmIds.Count();
	}

/**
Set all notifying alarm to Notified state
*/
void CASSrvNotifyingAlarmMngr::AcknowledgeAllNotifyingAlarms()
	{
	CASSrvAlarmQueue& queue = ServerWideData().Queue();

	TInt count(iCurrentlyNotifyingAlarmIds.Count());
	for (TInt i = 0; i < count; i++)
		{
		TASSrvAlarm* alarm = queue.QueueAlarmById(iCurrentlyNotifyingAlarmIds[i]);
		alarm->SetState(EAlarmStateNotified);
		}
		
	// Because we disabled the AlarmObservers, we have to
	// manually remove the alarms
	iCurrentlyNotifyingAlarmIds.Reset();
	}