// 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());
	}