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

#include "agmsimpleentry.h"

#include "agmdate.h"

#include "agmutil.h"

#include "agmtlsproxy.h"

#include "agmdebug.h"

#include "agmtzrules.h"

#include <vtzrules.h>

const TInt16 KRptLocalOffsetNotSet = KMaxTInt16;

// --------------------------------------- TAgnRpt -------------------------------

TBool TAgnRpt::HourAndMinutesDifferentFromStartTimeL(const TTime& aRptLocalTime) const

	{

	const TDateTime KRptLocalTestDT = aRptLocalTime.DateTime();

	const TDateTime KRptLocalStartDT = StartTimeAsRptLocalL().DateTime();

	if (KRptLocalTestDT.Hour() != KRptLocalStartDT.Hour() ||

		KRptLocalTestDT.Minute() != KRptLocalStartDT.Minute())

		{

		// Hour and minute are not the same, it is possible that they are at the same time in UTC but

		// due to the 'missing hour' the two local times appear different.

		// Compare the UTC times.

		const TDateTime KUtcStartDT = StartTime().UtcL().DateTime();

		const TDateTime KUtcTestDT = ConvertFromRepeatLocalToUtcL(aRptLocalTime).DateTime();

		if (KUtcStartDT.Hour() != KUtcTestDT.Hour() ||

			KUtcStartDT.Minute() != KUtcTestDT.Minute())

			{

			return ETrue;

			}

		}

	return EFalse;

	}

/** Constructs the repeat object. 

The until date is initialised to max time, the repeat interval to 1.

@internalComponent

*/

TAgnRpt::TAgnRpt(CAgnRptDef& aOwningRptDef) :

	iOwningRptDef(aOwningRptDef)

	{

	ClearAll();

	}

/** Constructs a new TAgnRpt object from an existing one.

@internalComponent

@param aRRule The object to be copied. */

TAgnRpt::TAgnRpt(const TAgnRpt& aRRule, CAgnRptDef& aOwningRptDef) :

	iOwningRptDef(aOwningRptDef)

	{

	ClearAll();

	iUntilTime = aRRule.iUntilTime;

	iInterval = aRRule.iInterval;

	iCount = aRRule.iCount;

	iUntiltimeHasBeenSet = aRRule.iUntiltimeHasBeenSet;

	}

void TAgnRpt::ResetCachedStartTimeOffset()

	{

	iStartTimeRptLocalOffset = KRptLocalOffsetNotSet;

	}

void TAgnRpt::ResetCachedUntilTimeOffset()

	{

	iUntilTimeRptLocalOffset = KRptLocalOffsetNotSet;

	}

MAgnCalendarTimeMode::TTimeMode TAgnRpt::TimeMode() const

	{

	return iOwningRptDef.TimeMode();

	}

TTime TAgnRpt::ConvertFromRepeatLocalToUtcL(const TTime& aRptLocalDate) const

	{

	return iOwningRptDef.ConvertFromRepeatLocalToUtcL(aRptLocalDate);

	}

TTime TAgnRpt::ConvertFromUtcToRepeatLocalL(const TTime& aUtcDate) const

	{

	return iOwningRptDef.ConvertFromUtcToRepeatLocalL(aUtcDate);

	}

TTime TAgnRpt::ConvertFromRepeatLocalToSystemLocalL(const TTime& aRptLocalTime) const

	{

	// If TimeMode is floating, avoid unnecessary conversion by using aRptLocalTime	

	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

		{

		return aRptLocalTime;

		}

	const TTime KUtcTime = ConvertFromRepeatLocalToUtcL(aRptLocalTime);

	return AgnDateTime::ConvertToLocalTimeL(KUtcTime);

	}

TTime TAgnRpt::ConvertFromSystemLocalToRepeatLocalL(const TTime& aSysLocalTime) const

	{

	// If TimeMode is floating, avoid unnecessary conversion by using aSysLocalTime	

	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

		{

		return aSysLocalTime;

		}

	const TTime KUtcTime = AgnDateTime::ConvertToLocalTimeL(aSysLocalTime);

	return ConvertFromUtcToRepeatLocalL(KUtcTime);

	}

TTime TAgnRpt::StartTimeAsRptLocalL() const

 	{

 	TTime startTimeRptLocal;

 	GetTimeAsRptLocalL(StartTime(), startTimeRptLocal, iStartTimeRptLocalOffset);

 	return startTimeRptLocal;

 	}

TTime TAgnRpt::UntilTimeAsRptLocalL() const

 	{

 	TTime untilTimeRptLocal;

 	GetTimeAsRptLocalL(UntilTimeL(), untilTimeRptLocal, iUntilTimeRptLocalOffset);

 	return untilTimeRptLocal;

 	}

void TAgnRpt::GetTimeAsRptLocalL(const TAgnCalendarTime& aCalendarTime, TTime& aTimeAsRptLocal, TInt16& aCachedOffset) const

	{

	if (TimeMode() == MAgnCalendarTimeMode::EFloating)

		{

		aTimeAsRptLocal = aCalendarTime.LocalL(); // if the entry is floating, system local is the same as rpt local

		return;

		}

	if (aCachedOffset == KRptLocalOffsetNotSet)

		{

		aCachedOffset = 0;

 		TTime rptLocalTime = ConvertFromUtcToRepeatLocalL(aCalendarTime.UtcL());

		TTimeIntervalMinutes mins;

		rptLocalTime.MinutesFrom(aCalendarTime.UtcL(), mins);

		aCachedOffset = mins.Int();

 		}

	aTimeAsRptLocal = aCalendarTime.UtcL() + TTimeIntervalMinutes(aCachedOffset);

 	}

EXPORT_C const TAgnCalendarTime& TAgnRpt::UntilTimeL() const

 	{

 	//	if iCount is set, the until time will not be set.

 	if (iCount > 0)

 		{

 		TTime time = FindRptUntilTimeLocalL(iCount);

 		if (!iUntiltimeHasBeenSet)

 			{

 			if (TimeMode() == MAgnCalendarTimeMode::EFloating)	

 				{

 				iUntilTime.SetFloatingL(time);	

 				}

 			else

 		 		{

 		 		iUntilTime.SetLocalL(time);	

 				}

			}

 		}

 	if(iUntilTime.UtcL() > AgnDateTime::MaxDate())

	 	{

	 	iUntilTime.SetUtcL(AgnDateTime::MaxDate());	

	 	}

 	return iUntilTime;

 	}

void TAgnRpt::SetUntilTime(const TAgnCalendarTime& aUntilTime)

	{

	iUntilTime = aUntilTime;

	iUntilTimeRptLocalOffset = KRptLocalOffsetNotSet;

	iUntiltimeHasBeenSet = ETrue;

	}

const TAgnCalendarTime& TAgnRpt::StartTime() const

/** Gets the start time as a @see TAgnCalendarTime.

@internalComponent

@return The start time. */

	{

	return iOwningRptDef.StartTime();

	}

void TAgnRpt::ClearAll()

/** Clears all the repeat details. 

The until time is set to max time and the repeat interval to 1.

The cached repeat local time offsets are reset.

@internalComponent

*/

	{

	iUntilTime.SetUtcL(AgnDateTime::MaxDate()); // this can't leave

	iStartTimeRptLocalOffset = KRptLocalOffsetNotSet;

	iUntilTimeRptLocalOffset = KRptLocalOffsetNotSet;

	iInterval = 1;

	iCount = -1;

	iUntiltimeHasBeenSet = EFalse;

	}

TInt TAgnRpt::InvariantL() const

/**

Check that the rpt doesn't violate its invariants

@internalComponent

*/

	{

	if (Type() < EDaily || Type() > EYearlyByDay)

		{

		return (EAgmErrBadRepeat);

		}

	if (Interval() <= 0 || !AgnDateTime::IsValidAgendaTTime(iUntilTime.UtcL()) || StartTime() >= iUntilTime)

		{

		return (EAgmErrBadTime);

		}

	return (KErrNone);

	}

void TAgnRpt::InternalizeL(RReadStream& aStream)

/** Internalises the repeat definition from a read stream, including type, repeat 

details and exception list.

@internalComponent

@param aStream The stream from which the object should be internalised. */

	{

	aStream >> iUntilTime;

	iInterval = aStream.ReadUint16L();

	iStartTimeRptLocalOffset = KRptLocalOffsetNotSet;

	iUntilTimeRptLocalOffset = KRptLocalOffsetNotSet;

	}

void TAgnRpt::ExternalizeL(RWriteStream& aStream) const

/** Externalises the repeat definition to a write stream.

@internalComponent

@param aStream The stream to which the object should be externalised. */

	{

	aStream << iUntilTime;

	aStream.WriteUint16L(iInterval);

	}

TBool TAgnRpt::operator==(const TAgnRpt& aRRule) const

/** Compares two repeat details objects.

@internalComponent

@param aRRule The repeat details to compare with this object.

@return True if all properties agree, otherwise False. */

	{

	return (iInterval == aRRule.iInterval && UntilTimeL() == aRRule.UntilTimeL());

	}

TBool TAgnRpt::operator!=(const TAgnRpt& aRRule) const

	{

	return ( ! (*this == aRRule) );

	}

TUint TAgnRpt::MapDayToBits(TDay aDay) const

/**

 Provides a mapping between the enumeration values of TDay to bit fields

*/

	{

	switch(aDay)

		{

	case EMonday : 	return (EBit1);

	case ETuesday:	return (EBit2);

	case EWednesday:return (EBit3);

	case EThursday:	return (EBit4);

	case EFriday:	return (EBit5);

	case ESaturday:	return (EBit6);

	case ESunday:	return (EBit7);

	default: 

		{

		_DBGLOG_ENTRY(AgmDebug::DebugLog("TAgnRpt: Panic - EAgmErrInvalidWeekDay");)

		DBG_PANIC(EAgmErrInvalidWeekDay);

		}

		}

	return (EBit0);

	}

TUint TAgnRpt::MapDateToBits(TUint aNum) const

/**

 Provides a mapping between the numbers 0 to 30 to bit fields.

 0 = the first day of a month, 30 = the 31st day of the month

*/

	{

	if (aNum > 30)

		{

		_DBGLOG_ENTRY(AgmDebug::DebugLog("TAgnRpt: Panic - EAgmErrInvalidMonthDay");)

		DBG_PANIC(EAgmErrInvalidMonthDay);

		return (EBit0);

		}

	return (1 << aNum);

	}

TTime TAgnRpt::NudgeNextAlignedStartTimeL(const TTime& aRptLocalDate) const

	{

	TTime startTime = StartTimeAsRptLocalL();

	// Find the previous aligned start time from aRptLocalDate

	TTime alignedDate(startTime + aRptLocalDate.DaysFrom(startTime));

	const TTime KUtcAlignedDate = ConvertFromRepeatLocalToUtcL(alignedDate);

	const TTime KUtcLocalDate = ConvertFromRepeatLocalToUtcL(aRptLocalDate);

	// Don't add a day if aRptLocalDate is already 'aligned start time'

	// or if it is before the start of the repeat rule, because DaysFrom

	// already returns 'next aligned start time' in that case

	if ((aRptLocalDate != alignedDate && aRptLocalDate > startTime) || KUtcLocalDate > KUtcAlignedDate)

		{

		// Add a day to get the 'next aligned start time'

		alignedDate += TTimeIntervalDays(1);

		}

	return alignedDate;

	}

TTime TAgnRpt::NudgePreviousAlignedStartTimeL(const TTime& aRptLocalDate) const

	{

	TTime startTime = StartTimeAsRptLocalL();

	// Find the previous aligned start time from aRptLocalDate

	TTime alignedDate(startTime + aRptLocalDate.DaysFrom(startTime));

	const TTime KUtcAlignedDate = ConvertFromRepeatLocalToUtcL(alignedDate);

	const TTime KUtcLocalDate = ConvertFromRepeatLocalToUtcL(aRptLocalDate);

	if ( (aRptLocalDate != alignedDate && aRptLocalDate < startTime) || KUtcLocalDate < KUtcAlignedDate )

		{

		// Subtract a day when aRptLocalDate is before the repeat rule

		// start date, because DaysFrom() is a day out in that case 

		alignedDate -= TTimeIntervalDays(1);

		}

	return alignedDate;

	}

EXPORT_C TTime TAgnRpt::FindRptUntilTimeLocalL(TUint aCount) const

/** Calculates the repeat's end date from the specified number of instances. 

If the end date would be after the agenda model's valid date range, it returns 

a NULL TTime value.

@internalComponent

@param aCount The number of instances.

@return The end date (System Local Time). */

	{

	TTime end = FindRptUntilTimeRptLocalL(aCount);

	return ConvertFromRepeatLocalToSystemLocalL(end);

	}

EXPORT_C TUint16 TAgnRpt::Interval() const

/** Gets the repeat interval.

@return The interval. */

	{

	return (iInterval);

	}

EXPORT_C void TAgnRpt::SetInterval(TUint16 aInterval)

/** Sets the repeat interval. 

This is a number of days for a daily repeat, a number of weeks for a 

weekly repeat, etc. 

@param aInterval The interval. */

	{

	if (aInterval > 0)

		{

		iInterval = aInterval;

		}

	}

EXPORT_C void TAgnRpt::SetCount(TInt aRepCount)

	{

	iCount = aRepCount;

	iUntiltimeHasBeenSet = EFalse;

	}

EXPORT_C TInt TAgnRpt::Count() const

/*

>0 - Indicate how many occurrences of a repeating rule.

 0 - Repeating forever. Note that it is the default value if there is neither Until time nor Count has been set. 

<0 - A Until time has been set but not the count. 

*/	{

	return iCount;

	}

// --------------------------------- TAgnDailyRpt ------------------------------

EXPORT_C TAgnDailyRpt::TAgnDailyRpt(CAgnRptDef& aOwningRptDef) : TAgnRpt(aOwningRptDef)

/**

This is not inline to prevent non-exportable functions causing a linker error in calling code

Constructs a default daily repeat object. 

@internalComponent

*/

	{

	}

/** Constructs a new TAgnDailyRpt object from an existing TAgnDailyRpt object.

@internalComponent

@param aRRule The object to be copied. */

EXPORT_C TAgnDailyRpt::TAgnDailyRpt(const TAgnDailyRpt& aRRule, CAgnRptDef& aOwningRptDef) : 

	TAgnRpt(aRRule, aOwningRptDef)

	{

	}

TAgnRpt::TType TAgnDailyRpt::Type() const

	{

	return TAgnRpt::EDaily;

	}

TBool TAgnDailyRpt::IsAlignedUtcL(const TTime& aDate) const

/**

 Returns true if aDate (UTC) falls on an instance generated by the repeat algorithm 

@internalComponent

*/

	{

	// convert aDate from UTC to Repeat Local

	TTime rptLocalDate = ConvertFromUtcToRepeatLocalL(aDate);

	return IsAlignedRptLocalL(rptLocalDate);

	}

TBool TAgnDailyRpt::IsAlignedRptLocalL(const TTime& aDate) const

/**

Returns true if aDate (Repeat Local) falls on an instance generated by the repeat algorithm 

@internalComponent

*/

	{

	// see if the day falls on an instance

	if ( AgnDateTime::DaysBetweenDates(aDate, StartTimeAsRptLocalL()) % iInterval )

		{

		return EFalse;

		}

	if (HourAndMinutesDifferentFromStartTimeL(aDate))

		{

		return EFalse;

		}

	return ETrue;	

	}

TUint TAgnDailyRpt::InstanceCountL() const

/** Gets the number of instances generated by the repeat algorithm.

@internalComponent

@return The number of instances. */

	{

	// to avoid unnecessary time conversions, date substractions should be done in 

	// the time reference in which start and end dates are stored

	return 1 + (AgnDateTime::DaysBetweenDates(UntilTimeAsRptLocalL(), StartTimeAsRptLocalL()) / iInterval) ;

	}

TTime TAgnDailyRpt::FindRptUntilTimeRptLocalL(TUint aCount) const

	{

	// do calculations in repeat local

	TUint max = (AgnDateTime::MaxDate().DaysFrom(StartTimeAsRptLocalL()).Int() + 1) / iInterval;

	if (aCount > max)

		{

		return AgnDateTime::MaxDate();

		}

	return StartTimeAsRptLocalL() + TTimeIntervalDays(iInterval * (aCount-1));

	}

TTime TAgnDailyRpt::NudgeNextInstanceUtcL(const TTime& aUtcDate) const

/**

If aUtcDate is already a date generated by the repeat algorithm then that is the date returned,

otherwise the next instance from aUtcDate is returned (in UTC time)

@internalComponent

*/

	{

	//                       aDate-start 

	// nextDate = start + ( ------------- + 1) * interval

	//                         interval	

	// (NOTE: (aDate-start)/interval is NOT incremented if the modulus of division is zero )	

	// convert aUtcDate to Repeat Local Time

	TTime thisDate = ConvertFromUtcToRepeatLocalL(aUtcDate);

	TTime next = NudgeNextAlignedStartTimeL(thisDate);

	if (IsAlignedRptLocalL(next))

		{

		return ConvertFromRepeatLocalToUtcL(next);

		}

	thisDate = next;

	// get number of last instance

	TInt instanceNumber = AgnDateTime::DaysBetweenDates(thisDate, StartTimeAsRptLocalL()) / iInterval;

	// if there isn't an instance on our date, we want the next instance

	if (AgnDateTime::DaysBetweenDates(thisDate, StartTimeAsRptLocalL()) % iInterval)

		{

		++instanceNumber;

		}

	// resolve instance number to days since start

	TInt daysFromStartToNextInstance = instanceNumber * iInterval;