// 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:
//

#include "ASSrvStaticUtils.h"

// System includes

// User includes
#include "ASShdOpCodes.h"
//
#include "ASSrvAlarm.h"

// Type definitions

// Constants
const TInt KReturnFirstObjectLessThanSecond = -1;
const TInt KReturnFirstObjectGreaterThanSecond = 1;
const TInt KReturnObjectsAreEqual = 0;
const TInt KNumberOfSecondsInMinute = 60;

// Enumerations

// Classes referenced


//
// ----> ASSrvStaticUtils (source)
//

//*************************************************************************************
/**
 * Validate the alarm. Checks the characteristics applied to the alarm
 * are valid.
 */
TInt ASSrvStaticUtils::ValidateAlarm(TASSrvAlarm& aAlarm)
	{
	if	(aAlarm.Message().Length() < 0 || aAlarm.Message().Length() > KMaxAlarmMessageLength)
		return KErrArgument;
	else if (aAlarm.SoundName().Length() < 0 || aAlarm.SoundName().Length() > KMaxAlarmSoundNameLength)
		return KErrArgument;

	// Check repeat flags in conjunction with session alarms
	if	(aAlarm.Characteristics().IsSet(EAlarmCharacteristicsSessionSpecific) && aAlarm.RepeatDefinition() != EAlarmRepeatDefintionRepeatOnce)
		return KErrArgument;

	const TTimeIntervalSeconds KAllowNoWindow = 0;
	const TBool KAllowBlanketInThePastOnceOnlyAlarms = ETrue;

	// The only valid return types are KErrNone (everything is fine) or 
	// KErrLocked (repeat workdays alarm, but no workdays are defined).
	const TInt error = aAlarm.ValidateAndEnable(KAllowNoWindow, KAllowBlanketInThePastOnceOnlyAlarms);
	if	(!(error == KErrNone || error == KErrLocked))
		return error;
	
	// Even if the alarm is locked (because there aren't any workdays
	// defined), its still valid.
	return KErrNone;
	}


//*************************************************************************************
/**
 * Check that the sound play intervals are valid. Performs basic boundary 
 * checking to ensure that the start time + interval duration does not overlap
 * with a subsequent definition.
 *
 * @return  An error value indicating whether or not the array is valid. KErrNone
 *          for a valid array or KErrGeneral if the array is inappropriate.
 */
TInt ASSrvStaticUtils::ValidateSoundPlayIntervals(RArray<TASSrvAlarmSoundDetails>& aIntervals)
	{
	const TUint KOffsetZero = 0;

	// Sort array of alarm sound details by start time
	TLinearOrder<TASSrvAlarmSoundDetails> order(ASSrvStaticUtils::CompareSoundPlayIntervalStartTimes);
	aIntervals.Sort(order);

	// Compare entries - there must be at least one.
	const TInt count = aIntervals.Count();
	if	(!count)
		return KErrGeneral;

	// The first item in any array must always have an interval of 0 minutes before
	// the alarm will sound (i.e. the client will be audibly notified as soon as the
	// alarm fires).
	if	(aIntervals[0].OffsetInMinutes() != KOffsetZero)
		return KErrArgument;

	for(TInt ii=0; ii < count-1; ii++)
		{
		const TASSrvAlarmSoundDetails& interval1 = aIntervals[ii];
		const TASSrvAlarmSoundDetails& interval2 = aIntervals[ii + 1];
		//
		if	(SoundPlayIntervalsOverlap(interval1, interval2))
			return KErrGeneral;
		}

	return KErrNone;
	}


//*************************************************************************************
/**
 * Fault the server
 */
void ASSrvStaticUtils::Fault(TASSrvFault aFault)
	{
	_LIT(KAlarmServerFault, "ALARMSERVER-FAULT");
	User::Panic(KAlarmServerFault, aFault);
	}


//*************************************************************************************
/**
 * Panic the server
 */
void ASSrvStaticUtils::Panic(TASSrvPanic aPanic)
	{
	_LIT(KAlarmServerPanic, "ALARMSERVER-INTERNAL");
	User::Panic(KAlarmServerPanic, aPanic);
	}


//*************************************************************************************
/**
 * Compare two alarm categories and return a value indicating which is less.
 */
TInt ASSrvStaticUtils::CompareCategories(const TAlarmCategory& aCategory1, const TAlarmCategory& aCategory2)
	{
	//
	// Semantics - returns:
	//
	// 1) zero, if the two objects are equal
	// 2) a negative value, if the first object is less than the second.
	// 3) a positive value, if the first object is greater than the second.
	//
	if	(aCategory1.iUid < aCategory2.iUid)
		return KReturnFirstObjectLessThanSecond;
	else if (aCategory1.iUid > aCategory2.iUid)
		return KReturnFirstObjectGreaterThanSecond;
	//
	return KReturnObjectsAreEqual;
	}


//*************************************************************************************
/**
 * Compare two alarm ids and return a value indicating which is less.
 */
TInt ASSrvStaticUtils::CompareAlarmIds(const TAlarmId& aId1, const TAlarmId& aId2)
	{
	if	(aId1 < aId2)
		return KReturnFirstObjectLessThanSecond;
	else if (aId1 > aId2)
		return KReturnFirstObjectGreaterThanSecond;
	//
	return KReturnObjectsAreEqual;
	}


//*************************************************************************************
/**
 * Compare two alarms and return a value indicating which is less.
 */
TInt ASSrvStaticUtils::CompareAlarms(const TASSrvAlarm& aAlarm1, const TASSrvAlarm& aAlarm2)
	{
	if	(aAlarm1.NextDueTime() < aAlarm2.NextDueTime())
		{
		return KReturnFirstObjectLessThanSecond;
		}
	else if (aAlarm1.NextDueTime() > aAlarm2.NextDueTime())
		{
		return KReturnFirstObjectGreaterThanSecond;
		}
	// If you're reading this comment in the year 2141 and you've been adding an 
	// alarm every second since 2005, you may begin to experience problems as we are
	// now making the assumption that the alarm id counter will never roll-over.
	return ASSrvStaticUtils::CompareAlarmIds(aAlarm1.Id(), aAlarm2.Id());
	}


//*************************************************************************************
/**
 * Compare two alarms and return a boolean if they are the same
 */
TBool ASSrvStaticUtils::CompareAlarmsExact(const TASSrvAlarm& aAlarm1, const TASSrvAlarm& aAlarm2)
	{
	return (CompareAlarmIds(aAlarm1.Id(), aAlarm2.Id()) == KReturnObjectsAreEqual);
	}


//*************************************************************************************
/**
 * Return the version of the Alarm Server
 */
TVersion ASSrvStaticUtils::ASVersion()
	{
	return TVersion(KAlarmServerMajorVN, KAlarmServerMinorVN, KAlarmServerBuildVN);
	}


//*************************************************************************************
/**
 * Return the name of the Alarm Server
 */
const TDesC& ASSrvStaticUtils::ASName()
	{
	return KAlarmServerName;
	}


//*************************************************************************************
/**
 * Rounds any time down to the minute
 */
void ASSrvStaticUtils::RoundTimeDownToTheMinute(TTime& aTime)
	{
	TDateTime time(aTime.DateTime());
	time.SetSecond(0);
	time.SetMicroSecond(0);
	aTime = time;
	}


//*************************************************************************************
/**
 * Panic the client
 */
void ASSrvStaticUtils::PanicClient(const RMessage2& aMessage, TAlarmServerInitiatedClientPanic aPanic)
	{
	_LIT(KServerIntiatedSessionPanic, "ALARMSERVER");
	aMessage.Panic(KServerIntiatedSessionPanic, aPanic);
	}


//*************************************************************************************
/**
 * Return the current utc time, to the nearest second
 */
TTime ASSrvStaticUtils::UtcTimeNow()
	{	
	TTime NowInUTC;	
	NowInUTC.UniversalTime();
	TDateTime dateTime(NowInUTC.DateTime());
	dateTime.SetMicroSecond(0); // Remove microsecond element.
	NowInUTC = dateTime;
	return NowInUTC;
	}

//*************************************************************************************
/**
 * Return the current local time, to the nearest second
 */
TTime ASSrvStaticUtils::LocalTimeNow()
	{	
  	TTime now;
  	now.HomeTime();
  	TDateTime dateTime(now.DateTime());
  	dateTime.SetMicroSecond(0);
  	return dateTime;
	}
	
//*************************************************************************************
/**
 * Return (via reference) today's date at the specified time.
 */
void ASSrvStaticUtils::TodayAtTheSpecifiedTime(const TTime& aTime, TTime& aReturn)
	{
	// Reset the cycle and sound state ready to start playing
	const TDateTime todaysDate = ASSrvStaticUtils::UtcTimeNow().DateTime();
	TDateTime baselineDateTime = aTime.DateTime();
	//
	baselineDateTime.SetYear(todaysDate.Year());
	baselineDateTime.SetMonth(todaysDate.Month());
	baselineDateTime.SetDay(todaysDate.Day());
	baselineDateTime.SetMicroSecond(0);
	aReturn = baselineDateTime;
	}


//*************************************************************************************
/**
 * Internalize the sound play intervals from the specified stream and return
 * them on the cleanup stack.
 */
RArray<TASSrvAlarmSoundDetails>* ASSrvStaticUtils::InternalizeSoundPlayIntervalsLC(RReadStream& aStream)
	{
	const TInt count = aStream.ReadInt32L();
	if	(!count)
		User::Leave(KErrArgument);
	//
	RArray<TASSrvAlarmSoundDetails>* newIntervals = new(ELeave) RArray<TASSrvAlarmSoundDetails>(count);
	CleanupStack::PushL(TCleanupItem(ASSrvStaticUtils::CleanupCloseDeleteSoundDetailsArray, newIntervals));
	//
	for(TInt i=0; i<count; i++)
		{
		const TUint offset = aStream.ReadUint32L();
		const TUint duration = aStream.ReadUint32L();
		//
		User::LeaveIfError(newIntervals->Append(TASSrvAlarmSoundDetails(offset, duration)));
		}
	//
	return newIntervals;
	}
//*************************************************************************************
/**
This method will return a descriptor created in such a way that
it holds the path to the directory containing the Alarm Servers private data.
*/
void ASSrvStaticUtils::GetPrivateDirL(RFs& aFsSession, TDes& aDirName)
	{
	//Sets the session path to the process's private directory 
	User::LeaveIfError(aFsSession.PrivatePath(aDirName));
	//Alarmserver.ini is supposed to be on drive C:
	TDriveName driveName(TDriveUnit(EDriveC).Name());
	aDirName.Insert(0,driveName); //drive name goes before the path
	}

//*************************************************************************************
/**
This method will return a descriptor created in such a way that
it holds the whole search path to the Alarmserver.ini file.
*/
void ASSrvStaticUtils::GetServerPathL(RFs& aFsSession, TDes& aFileName)
	{
	//Sets the session path to the process's private directory on C:
	GetPrivateDirL(aFsSession, aFileName);
	aFileName.Append(KAlarmServerBackupFile); //filename goes after the path
	}

//*************************************************************************************
/**
 * Calculate days until the next active alarm day.
 */
void ASSrvStaticUtils::DaysUntilNextActiveAlarmDay(
	TTimeIntervalDays& aDaysFromNow,
	TTimeIntervalDays& aRollOverDays,
	TDay aCurrentDayInWeek,
	TUint aActiveDays)
	{
	TInt daysToAddFromNow = 7;
	TInt daysForRollOver = 0;

	for(TInt i=6; i>=0; --i)
		{
		daysForRollOver = daysToAddFromNow;

		const TInt day = (aCurrentDayInWeek + i) % 7;
		const TInt dayMask = (1 << day);

		if (dayMask & aActiveDays)
			{
			daysToAddFromNow = i;
			}
		}

	aDaysFromNow = daysToAddFromNow;
	aRollOverDays = daysForRollOver;
	}


//*************************************************************************************
/**
 * Update the specified alarm for next 24 hours repeat. Depending on the current
 * time the alarm may repeat within the next day, or it may repeat tomorrow.
 */
void ASSrvStaticUtils::CalculateNext24HoursRepeat(TASShdAlarm& aAlarm, TTimeIntervalSeconds aAllowableWindow)
	{
	__ASSERT_DEBUG(aAlarm.RepeatDefinition() == EAlarmRepeatDefintionRepeatNext24Hours, ASSrvStaticUtils::Panic(ASSrvStaticUtils::EASSrvPanicInvalidAlarmRepeat));
	
	// Get the current due time.
	const TDateTime alarmTimeAsDateTime = aAlarm.NextDueTime().DateTime();
	
	// Get the current time.
	TTime timeNow(UtcTimeNow());
	
	// Set the new due time.
	TDateTime nextDueTimeAsDateTime = timeNow.DateTime();   // Take the current date.
	nextDueTimeAsDateTime.SetHour(alarmTimeAsDateTime.Hour());
	nextDueTimeAsDateTime.SetMinute(alarmTimeAsDateTime.Minute());
	nextDueTimeAsDateTime.SetSecond(0);
	nextDueTimeAsDateTime.SetMicroSecond(0);
	
    TTime nextDueTime(nextDueTimeAsDateTime);
	
	// Allow for the startup window. This ensures that any alarm which causes the
	// device to be brought out of standby isn't silently ignored.
	timeNow -= aAllowableWindow;
	
	// If the due time has passed then set it for the next day.
	if (nextDueTime < timeNow)
	    {
	    nextDueTime += TTimeIntervalDays(1);
	    }
	//
	aAlarm.NextDueTime()=nextDueTime;
	}


//*************************************************************************************
/**
 * Cleanup an RArray<TAlarmId>*
 */
void ASSrvStaticUtils::CleanupCloseDeleteAlarmIdArray(TAny* aArray)
	{
	RArray<TAlarmId>* array = reinterpret_cast<RArray<TAlarmId>*>(aArray);
	array->Close();
	delete array;
	}


//*************************************************************************************
/**
 * Cleanup an RArray<TAlarmCategory>*
 */
void ASSrvStaticUtils::CleanupCloseDeleteCategoryArray(TAny* aArray)
	{
	RArray<TAlarmCategory>* array = reinterpret_cast<RArray<TAlarmCategory>*>(aArray);
	array->Close();
	delete array;
	}


//*************************************************************************************
/**
 * Cleanup an RArray<TASSrvAlarmSoundDetails>*
 */
void ASSrvStaticUtils::CleanupCloseDeleteSoundDetailsArray(TAny* aArray)
	{
	RArray<TASSrvAlarmSoundDetails>* array = reinterpret_cast<RArray<TASSrvAlarmSoundDetails>*>(aArray);
	array->Close();
	delete array;
	}


//
//
//


//*************************************************************************************
/**
 * Compare two alarm sound play interval start times and return a value indicating which is less.
 */
TInt ASSrvStaticUtils::CompareSoundPlayIntervalStartTimes(const TASSrvAlarmSoundDetails& aAlarmSound1, const TASSrvAlarmSoundDetails& aAlarmSound2)
	{
	if	(aAlarmSound1.OffsetInMinutes() < aAlarmSound2.OffsetInMinutes())
		return KReturnFirstObjectLessThanSecond;
	else if (aAlarmSound1.OffsetInMinutes() > aAlarmSound2.OffsetInMinutes())
		return KReturnFirstObjectGreaterThanSecond;
	//
	return KReturnObjectsAreEqual;
	}


//*************************************************************************************
/**
 * Compare two alarm sound play intervals return ETrue if they overlap, else EFalse.
 */
TBool ASSrvStaticUtils::SoundPlayIntervalsOverlap(const TASSrvAlarmSoundDetails& aDetails1, const TASSrvAlarmSoundDetails& aDetails2)
	{
	TInt offsetInSeconds = aDetails1.OffsetInMinutes() * KNumberOfSecondsInMinute;
	offsetInSeconds += aDetails1.DurationInSeconds();
	//
	const TInt offsetOfOtherItemInSeconds = aDetails2.OffsetInMinutes() * KNumberOfSecondsInMinute;
	//
	return (offsetInSeconds > offsetOfOtherItemInSeconds);
	}