// Copyright (c) 2000-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:
// Implementation of the TChineseCalendar class.
//

#include "chinesecalendar.h"
#include "arithmeticaldate.h"
#include "gregoriancalendar.h"

#if defined(_DEBUG)
_LIT(KCalconPanic,"Calcon");
#endif

const TUint KMonthInvalid=0;
const TUint K29DayMonth=1;
const TUint K30DayMonth=2;
const TUint K29DayLeapMonth=3;
const TUint K30DayLeapMonth=4;

const TUint KMonthMask=1<<15;
const TUint KLeapMonthShift=28;

const TInt KNoOfYearsInCycle = 60;

enum TCalconPanic
	{
	ECalconChineseFromFixedMonthInvalid=0,
	ECalconChineseToFixedLeapYearInvalid,
	ECalconGetDataYearOutOfRange,
	ECalconGetDataMonthOutOfRange,
	ECalconGetNewYearYearOutOfRange
	};

TUint TCalconData::GetData(TInt aCycle, TInt aYear, TInt aMonth) const
	{
	__ASSERT_DEBUG((aYear>=0 && aYear<=59), User::Panic(_L("Calcon"), ECalconGetDataYearOutOfRange));	//year range is 0..59
	__ASSERT_DEBUG((aMonth>=0 && aMonth<=12), User::Panic(_L("Calcon"), ECalconGetDataMonthOutOfRange));//month range is 0..12

	TInt y=(aCycle*KNoOfYearsInCycle)+aYear;
	y-=(KFirstYear-1);	//there are KFirstYear-1 entries missing from the head of the table
	TUint16 x=iCalConDataMonth[y];

	TUint mask=KMonthMask>>aMonth;
	
	TInt flag=K29DayMonth;
	if (x & mask)
		flag=K30DayMonth;

	TUint leapMonth=iCalConDataYear[y]>>KLeapMonthShift;
	leapMonth--;

	if ((TUint)aMonth==leapMonth)
		flag+=2;	//--> K29/30DayLeapMonth
	
	if ((aMonth==12) && (leapMonth==0))
		flag=KMonthInvalid;//month doesn't exist

	return flag;
	}

TUint TCalconData::GetNewYear(TInt aCycle, TInt aYear) const
	{
	__ASSERT_DEBUG((aYear>=0 && aYear<=59), User::Panic(_L("Calcon"), ECalconGetNewYearYearOutOfRange));
	TInt y=(aCycle*KNoOfYearsInCycle)+aYear;
	y-=(KFirstYear-1);
	return (iCalConDataYear[y] & 0x0fffffff);
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    ChineseToDateTime
// Arguments:   TDateTime &
//
// Comments:    This function converts the date held within
//				the TChineseCalendar class to a TDateTime format and 
//				places it in the TDateTime class provided.
//
// Return:      void
//------------------------------------------------------
void TChineseCalendar::ChineseToDateTime(TDateTime &aDT)
	{
	TArithmeticalDate gregDate;
	TGregorianCalendar greg(iJulianDay);

	greg.GregFromJulianDay(gregDate,iJulianDay);
	aDT.Set(0,EJanuary,0,0,0,0,0);

	aDT.SetDay(gregDate.iDay - KCalConvMonthOffsetByOne);
	aDT.SetMonth((TMonth)(gregDate.iMonth - KCalConvMonthOffsetByOne));
	aDT.SetYear(gregDate.iYear);
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    DateTimeToChinese
// Arguments:   TDateTime &
//
// Comments:    Sets the date held in the given TDateTime
//				class to the TChineseCalendar class
//
// Return:      void
//------------------------------------------------------
void TChineseCalendar::DateTimeToChinese(const TDateTime &aDT)
	{
	TArithmeticalDate gregDate;
	TGregorianCalendar greg;

	gregDate.iDay = aDT.Day() + KCalConvMonthOffsetByOne;
	gregDate.iMonth = (TInt)aDT.Month() + KCalConvMonthOffsetByOne;
	gregDate.iYear = aDT.Year();

	iJulianDay = greg.GregToJulianDay(gregDate);
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    SetDate
// Arguments:   TChineseDate&
//
// Comments:    this function sets the julian day value
//				in the base class from the given 
//				TChineseDate
//
// Return:      None
//------------------------------------------------------
TInt TChineseCalendar::SetDate(const TChineseDate &aDate)
	{
	TReal jD;
	TChineseDate ChinDate = aDate;
	
	if(!ValidDate(ChinDate))
		return KErrArgument;
	
	if (!ChineseToFixed(aDate,jD))
		return KErrArgument;

	if (jD<KFirstJulianDate || jD>KLastJulianDate)
		return KErrArgument;

	iJulianDay = (TInt)jD;
	return KErrNone;
	}
//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    GetDate
// Arguments:   TChineseDate &
//
// Comments:    This function Determines the chinese date and 
//				places it in the TChineseDate class provided
//				for the julian day value held internally in the 
//				Chinese class.
//
// Return:      None
//------------------------------------------------------
TInt TChineseCalendar::GetDate(TChineseDate &aDate)
	{
	return ChineseFromFixed(aDate,iJulianDay);
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    ChineseToFixed
// Arguments:   TChineseDate , TReal &
//				TChineseDate members start at 1 (not zero)
//
// Comments:    This function converts a chinese date to 
//				to a julian day value.
//
// Return:      TBool ETrue if date valid, else EFalse
//------------------------------------------------------
TBool TChineseCalendar::ChineseToFixed(const TChineseDate& aDate, TReal &aJulianDay) const
	{
	TInt cycle=aDate.iCycle-KFirstCycle;	//cycle starts from zero
	TInt year=aDate.iYear-1;				//year is 0..59

	TInt days=0;

	TInt targetMonth=aDate.iMonth;			//targetMonth is 1..12
	TBool leap=aDate.iLeapMonth;
	if (leap)
		{
		targetMonth++;
		if (iData.GetData(cycle, year, targetMonth-1)<3)
			return EFalse;	//not a leap month
		}

	TInt month=1;
	while (month<=targetMonth)
		{
		TInt daysFlag=iData.GetData(cycle, year, month-1);
		
//We need to handle case where targetMonth is a leap month
//Eg if Chinese month==6 targetMonth will be 6
//Eg but if Chinese month 5 is a leap month, month 6 will be 5(leap) so we need to take it into account
//BUT Eg if Chinese momth== 7(leap) we've already taken this into account.
		if (month==targetMonth)	
			if ((leap) || (daysFlag<3))
				break;

		switch (daysFlag)
			{
			case KMonthInvalid:
				return EFalse;
			case K29DayMonth:
				days+=29;
				break;
			case K30DayMonth:
				days+=30;
				break;
			case K29DayLeapMonth:
				__ASSERT_DEBUG(!leap, User::Panic(KCalconPanic,ECalconChineseToFixedLeapYearInvalid));
				leap=ETrue;
				targetMonth++;
				days+=29;
				break;
			case K30DayLeapMonth:
				__ASSERT_DEBUG(!leap, User::Panic(KCalconPanic,ECalconChineseToFixedLeapYearInvalid));
				leap=ETrue;
				targetMonth++;
				days+=30;
				break;
			}
		month++;
		}

//Check that if days==30, the requested month actually has 30 days
	TInt checkMonth = aDate.iMonth;
	if (leap)
		checkMonth++;	//this is the month requested by the user
	TUint daysFlag=iData.GetData(cycle, year, checkMonth-1);

	if ((aDate.iDay==30) && ((daysFlag==K29DayMonth) || (daysFlag==K29DayLeapMonth)))
		return EFalse;

	days+=aDate.iDay-1;
	
	days+=iData.GetNewYear(cycle, year);//add the New Year
	aJulianDay=days;
	return ETrue;
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    ChineseFromFixed
// Arguments:   TChineseDate &, TReal
//
// Comments:    this function converts a julian day value to
//				a chinese date in the form TChineseDate
//
// Return:      None
//------------------------------------------------------
TInt TChineseCalendar::ChineseFromFixed(TChineseDate &aDate, const TReal& aJulianDay) const
	{
	if ((aJulianDay<KFirstJulianDate)
		|| (aJulianDay>KLastJulianDate))
		return KErrArgument;

	TInt cycleIndex=0;

	while ((cycleIndex < KLastCycle-KFirstCycle) 
			&& (aJulianDay >= iData.GetNewYear(cycleIndex+1,0)))
		cycleIndex++;
	
	aDate.iCycle=cycleIndex + KFirstCycle;
	TInt chineseNewYear;
	TInt yearCount=0;
	if (cycleIndex==0)
		yearCount=KFirstYear-1;

	while (yearCount<60 && aJulianDay >= iData.GetNewYear(cycleIndex,yearCount))
		yearCount++;
		
	aDate.iYear=yearCount;
	chineseNewYear = iData.GetNewYear(cycleIndex,--yearCount);
	
	TInt addedNumberOfDays = 0;
	TInt previousAddedNumberOfDays = 0;
	TInt monthCount = 1;
	aDate.iMonth = 0;

	TInt monthNumber; // 0=No month exists, 1 = 29 day month, 2 = 30 day month, 3 = 29 day leap month, 4 = 30 day leap month

	while (aJulianDay >= (chineseNewYear + addedNumberOfDays))
		{
		previousAddedNumberOfDays = addedNumberOfDays;
		monthNumber = iData.GetData(cycleIndex,yearCount,monthCount-1);

		switch (monthNumber)
			{
		case KMonthInvalid:
			__ASSERT_DEBUG(0, User::Panic(_L("Calcon"),ECalconChineseFromFixedMonthInvalid));
			break;
		case K29DayMonth:
			addedNumberOfDays += 29;
			aDate.iMonth++;
			aDate.iLeapMonth = EFalse;
			break;
		case K30DayMonth:
			addedNumberOfDays += 30;
			aDate.iMonth++;
			aDate.iLeapMonth = EFalse;
			break;
		case K29DayLeapMonth:
			addedNumberOfDays += 29;
			aDate.iLeapMonth = ETrue;
			break;
		case K30DayLeapMonth:
			addedNumberOfDays += 30;
			aDate.iLeapMonth = ETrue;
			break;
			}
		monthCount++;
		}

	aDate.iDay = (TInt)aJulianDay - chineseNewYear-previousAddedNumberOfDays;
	aDate.iDay++;
	return KErrNone;
	}

//------------------------------------------------------
// Class:       TChineseCalendar
// Function:    ValidDate
// Arguments:   TChineseDate &
//
// Comments:    This function Determines whether the given
//				date is a valid chinese date
//
// Return:      TBool - ETrue if date is valid, else EFalse
//------------------------------------------------------
TBool TChineseCalendar::ValidDate(const TChineseDate &aDate) const
	{
	//do some trivial checks to ensure that the date is in the range of the lookup table
	if (aDate.iYear==0 || aDate.iYear>KNoOfYearsInCycle)
		return EFalse;

	if (aDate.iCycle < KFirstCycle)
		return EFalse;

	if (aDate.iCycle==KFirstCycle && aDate.iYear < KFirstYear)
		return EFalse;
	
	if (aDate.iCycle > KLastCycle)
		return EFalse;

	if ( (aDate.iCycle==KLastCycle) && (aDate.iYear>KLastYear))
		return EFalse;

	if (aDate.iDay==0 || aDate.iDay>30)
		return EFalse;

	return ETrue;
	}

TReal TChineseCalendar::JulianDate() __SOFTFP
	{
	return iJulianDay;
	}