// 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 "agmdate.h"
#include "agmtlsproxy.h"
#include "agmtzrules.h"

const TInt KAgnDateMonthsInAYear = 12;

EXPORT_C TTime AgnDateTime::MinDate()
/** Gets the minimum date/time allowed for agenda entries as a TTime. 

This value marks the start of the agenda model's valid date range.

@internalAll
@return The agenda model's minimum date/time. 
*/
	{ 
	//Midnight, January 1st 1900
	return (TTime(MAKE_TINT64(0x00D504A2,0xC672E000))); 
	} 

EXPORT_C TTime AgnDateTime::MaxDate()
/** Gets the maximum date/time allowed for agenda entries as a TTime. 

This value marks the end of the agenda model's valid date range.

@internalAll
@return The agenda model's maximum date/time. 
*/
	{ 
	//Midnight, December 31st 2100
	return (TTime(MAKE_TINT64(0x00eb8d74,0x5a6fc000)));
	} 


void AgnDateTime::AddTo(TDateTime& aDate,TTimeIntervalMonths aMonth)
/** Adds a time interval in months to a date/time. This takes account of the date of the month, which simply 
adding the TTimeIntervalMonths would not do.

@internalAll
@param aDate Reference to a date/time.
@param aMonth The number of months to add to the date/time. 
*/
	{
	TInt month = aDate.Month() + (aDate.Year()*KAgnDateMonthsInAYear) + aMonth.Int();
	TInt day = aDate.Day();
	TInt year = month / KAgnDateMonthsInAYear;
	month %= KAgnDateMonthsInAYear;
	TInt daysInMonth = Time::DaysInMonth(year,TMonth(month))-1;
	if (day > daysInMonth)
		{
		day = daysInMonth;
		}
	aDate.Set(year,TMonth(month),day,aDate.Hour(),aDate.Minute(),aDate.Second(),aDate.MicroSecond());
	}



void AgnDateTime::AddTo(TDateTime& aDate,TTimeIntervalYears aYear)
/** Adds a time interval in years to a date/time.

@internalAll
@param aDate Reference to a date/time. On return, the date is modified and all 
time components are set to zero.
@param aYear The number of years to add to the date/time. 
*/
	{
	AddTo(aDate,TTimeIntervalMonths(aYear.Int() * KAgnDateMonthsInAYear));
	}



TTimeIntervalMonths AgnDateTime::MonthsFrom(const TDateTime& aStartDate,const TDateTime& aEndDate)
/** Calculates the number of whole months between two date/times.

@internalAll
@param aStartDate The date to start calculating from.
@param aEndDate The date to calculate to.
@return The number of whole months between the two date/times. 
*/
	{

	TInt monthsDifference = (aEndDate.Year()-aStartDate.Year())*12+(aEndDate.Month()-aStartDate.Month());

	if (aEndDate.Day() < aStartDate.Day())
		{ // check relative positions within the month
		TInt endDaysInMonth = Time::DaysInMonth(aEndDate.Year(),aEndDate.Month());
		TInt startDaysInMonth = Time::DaysInMonth(aStartDate.Year(),aStartDate.Month());
		if (! ((aEndDate.Day() == (endDaysInMonth-1))&&(aStartDate.Day() == (startDaysInMonth-1))))
		   		--monthsDifference;
		}
	return(monthsDifference);			
	}


TTimeIntervalYears	AgnDateTime::YearsFrom(const TDateTime& aStartDate,const TDateTime& aEndDate)
/** Calculates the number of whole years between two date/times.

@internalAll
@param aStartDate The date to start calculating from.
@param aEndDate The date to calculate to.
@return The number of whole years between the two date/times. 
*/
	{

	TTimeIntervalMonths mos = MonthsFrom(aStartDate,aEndDate);
	TTimeIntervalYears ret = mos.Int() / 12;
	return(ret);			
	}

TBool AgnDateTime::IsLessThan(const TDateTime& aDateLeft, const TDateTime& aDateRight)
/** Tests whether one TDateTime instance is earlier than another.

@internalAll
@param aDateLeft First date/time.
@param aDateRight Second date/time.
@return True if the first date/time specified is earlier than the second. False 
if it is more recent, or they are the same. 
*/
	{
	return aDateLeft.Year() < aDateRight.Year() ||
			(aDateLeft.Year() == aDateRight.Year() && aDateLeft.Month() < aDateRight.Month()) ||
			(aDateLeft.Year() == aDateRight.Year() && 
			aDateLeft.Month() == aDateRight.Month() &&
			aDateLeft.Day() < aDateRight.Day());
	}

/** Is time between min and max time. */
EXPORT_C TBool AgnDateTime::IsValidAgendaTTime(const TTime& aDate)
	{
	return (aDate >= AgnDateTime::MinDate() && aDate <= AgnDateTime::MaxDate());
	}

/** Fetch a pointer to the fixed time mode converter */
const MAgnCalendarTimeMode* AgnDateTime::FixedTimeMode()
	{
	CAgnTlsProxy* proxy = static_cast<CAgnTlsProxy*>(Dll::Tls());
	__ASSERT_DEBUG(proxy != NULL, User::Invariant());
	return static_cast<const MAgnCalendarTimeMode*>(&proxy->FixedTimeMode());
	}

/** Fetch a pointer to the floating time mode converter */
const MAgnCalendarTimeMode* AgnDateTime::FloatingTimeMode()
	{

	CAgnTlsProxy* proxy = static_cast<CAgnTlsProxy*>(Dll::Tls());
	__ASSERT_DEBUG(proxy != NULL, User::Invariant());
	return static_cast<const MAgnCalendarTimeMode*>(&proxy->FloatingTimeMode());
	}

/** Convert a time from system local to UTC, without caching the result. */
EXPORT_C TTime AgnDateTime::ConvertToLocalTimeL(const TTime& aUtcTime)
	{
    CAgnTlsProxy* proxy = CAgnTlsProxy::CreateL(CAgnTlsProxy::TAgnTlsTzRulesType_None);
    CleanupStack::PushL(TCleanupItem(CAgnTlsProxy::Release, proxy));
    TAgnCalendarTime utcTime;
    utcTime.SetUtcL(aUtcTime);
    TTime ret = utcTime.LocalL();
	CleanupStack::PopAndDestroy(proxy);
    return ret;
	}

/** Convert a time from UTC to system local, without caching the result. */
EXPORT_C TTime AgnDateTime::ConvertToUtcTimeL(const TTime& aLocalTime)
	{
    CAgnTlsProxy* proxy = CAgnTlsProxy::CreateL(CAgnTlsProxy::TAgnTlsTzRulesType_None);
    CleanupStack::PushL(TCleanupItem(CAgnTlsProxy::Release, proxy));
    TAgnCalendarTime utcTime;
    utcTime.SetLocalL(aLocalTime);
    TTime ret = utcTime.UtcL();
	CleanupStack::PopAndDestroy(proxy);
    return ret;
	}
  
/** This function resets the hours, minutes, seconds and microseconds to 0 
more quickly than using a TDateTime. */
EXPORT_C TTime AgnDateTime::ResetToMidnight(const TTime& aTime)
	{
	const TInt64 KMicrosecondsInADay (MAKE_TINT64(0x00000014,0x1DD76000));
	const TInt64 newTime((aTime.Int64() / KMicrosecondsInADay) * KMicrosecondsInADay);
	return TTime(newTime);
	}

/** Correctly calculate the number of days between two TTimes. DaysFrom gives unexpected results if the
time of day is different for each TTime. */
TInt AgnDateTime::DaysBetweenDates(const TTime& aTimeLater, const TTime& aTimeEarlier)
	{
	TTime later = AgnDateTime::ResetToMidnight(aTimeLater);
	TTime earlier = AgnDateTime::ResetToMidnight(aTimeEarlier);
	return later.DaysFrom(earlier).Int();
	}