// Copyright (c) 2004-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:

//

// User includes

#include "SCHENTRY.H"

#include "SchLogger.h"

//	

NONSHARABLE_CLASS(TScheduleEntryHourly) : public TScheduleEntry

	{

public:

	TScheduleEntryHourly(TScheduleEntryInfo2& aInfo);

	void CalculateNextPossibleRunDate(TTime& aTime) const;

	};

NONSHARABLE_CLASS(TScheduleEntryDaily) : public TScheduleEntry

	{

public:

	TScheduleEntryDaily(TScheduleEntryInfo2& aInfo);

	void CalculateNextPossibleRunDate(TTime& aTime) const;

	};

NONSHARABLE_CLASS(TScheduleEntryMonthly) : public TScheduleEntry

	{

public:

	TScheduleEntryMonthly(TScheduleEntryInfo2& aInfo);

	void CalculateNextPossibleRunDate(TTime& aTime) const;

	};

NONSHARABLE_CLASS(TScheduleEntryYearly) : public TScheduleEntry

	{

public:

	TScheduleEntryYearly(TScheduleEntryInfo2& aInfo);

	void CalculateNextPossibleRunDate(TTime& aTime) const;

	};

//	

TScheduleEntry* ScheduleEntryFactory::CreateL(TScheduleEntryInfo2& aInfo)

	{

	switch (aInfo.IntervalType())

		{

		case EHourly:

			{

			return new(ELeave) TScheduleEntryHourly(aInfo);

			}

		case EDaily:

			{

			return new(ELeave) TScheduleEntryDaily(aInfo);

			}

		case EMonthly:

			{

			return new(ELeave) TScheduleEntryMonthly(aInfo);

			}

		case EYearly:

			{

			return new(ELeave) TScheduleEntryYearly(aInfo);

			}

		}

	User::Leave(KErrArgument);

	return NULL;//never gets to here!!

	}

//	

//TScheduleEntry (generic code)

TScheduleEntry::TScheduleEntry(TScheduleEntryInfo2& aInfo)

:	iEntryInfo(aInfo)

	{

	TTsTime time;

	time.SetUtcTime(Time::MaxTTime());

	iDueTime = time;

	}

const TTsTime& TScheduleEntry::DueTime() const

	{

	return iDueTime;

	}

TInt TScheduleEntry::Offset()

	{

	return (_FOFF(TScheduleEntry, iLink));

	}

const TScheduleEntryInfo2& TScheduleEntry::Info() const

	{

	return iEntryInfo;

	}

/**

returns the next due time for this schedule entry.  aTime is the minimum time

for which this due time should be.*/

const TTsTime& TScheduleEntry::NextScheduledTime(const TTsTime& aTime)

	{

	// update start time in case of any timezone/DST changes

	// do this before calculating next scheduled time so that it is taken into

	// account in the calculation

	iEntryInfo.ProcessOffsetEvent();

	// if start time = max time then algorithm below doesnt work

	// so we need to jump out of it here.

	if (iEntryInfo.StartTime().GetUtcTime() == Time::MaxTTime() 

		|| iEntryInfo.StartTime().GetLocalTime() == Time::MaxTTime() 

		|| aTime.GetUtcTime() < (iEntryInfo.StartTime().GetUtcTime() + iEntryInfo.ValidityPeriod())) 

		iDueTime = iEntryInfo.StartTime();

	else

		{

		// Work out when this schedule entry can next run, by adding interval steps

		// Due times should be UTC based or local time based, 

		// in accordance with the start time set by the user

		TTime nextDueTime;

		if (iEntryInfo.StartTime().IsUtc())

			{

			nextDueTime = iEntryInfo.StartTime().GetUtcTime();

			while (aTime.GetUtcTime() > (nextDueTime + iEntryInfo.ValidityPeriod()))	

				CalculateNextPossibleRunDate(nextDueTime);

			iDueTime.SetUtcTime(nextDueTime);

			}

		else	//is hometime based

			{

			nextDueTime = iEntryInfo.StartTime().GetLocalTime();

			while (aTime.GetLocalTime() > (nextDueTime + iEntryInfo.ValidityPeriod()))	

				CalculateNextPossibleRunDate(nextDueTime);

			iDueTime.SetLocalTime(nextDueTime);

			}

		}

	return iDueTime;	

	}

//subclass-specific code...

TScheduleEntryHourly::TScheduleEntryHourly(TScheduleEntryInfo2& aInfo)

			:TScheduleEntry(aInfo)

	{

	}

void TScheduleEntryHourly::CalculateNextPossibleRunDate(TTime& aTime) const

	{

	aTime+=TTimeIntervalHours(Info().Interval());

	}

TScheduleEntryDaily::TScheduleEntryDaily(TScheduleEntryInfo2& aInfo)

			:TScheduleEntry(aInfo)

	{

	}

void TScheduleEntryDaily::CalculateNextPossibleRunDate(TTime& aTime) const

	{

	aTime+=TTimeIntervalDays(Info().Interval());

	}

TScheduleEntryMonthly::TScheduleEntryMonthly(TScheduleEntryInfo2& aInfo)

			:TScheduleEntry(aInfo)

	{

	}

void TScheduleEntryMonthly::CalculateNextPossibleRunDate(TTime& aTime) const

	{

	aTime+=TTimeIntervalMonths(Info().Interval());

	}

TScheduleEntryYearly::TScheduleEntryYearly(TScheduleEntryInfo2& aInfo)

			:TScheduleEntry(aInfo)

	{

	}

void TScheduleEntryYearly::CalculateNextPossibleRunDate(TTime& aTime) const

	{

	aTime+=TTimeIntervalYears(Info().Interval());

	}