int DateTime::DayOfYear() const
{
    int year, month, day;
    GetDateFromTimeValue( Value(), year, month, day);
    const unsigned* monthTable = IsLeapYear(year) ? monthStartLeap : monthStart;

    return monthTable[ month - 1 ] + day;
}

int TDateTime::IsLeapYear()
{
	unsigned  int year=0;
	unsigned  int month=0;
	unsigned  int day=0;
	DecodeDate(year, month, day);	
	return IsLeapYear(year);
}

 static double DayFromMonth(double year, double month)
 {
     int iMonth = (int) MathUtils::floor(month);
     if (iMonth < 0 || iMonth >= 12) {
         return MathUtils::kNaN;
     }
     return DayFromYear((int)year) + kMonthOffset[(int)IsLeapYear((int)year)][iMonth];
 }

	int Date::DayOfYear(int year, int month, int day)
	{
		static const int DAYS_BEFORE[2][13] = {
			{ -1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 },
			{ -1, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 }
		};

		return DAYS_BEFORE[IsLeapYear(year)][month] + day - 1;
	}

	int Date::DaysInMonth(int year, int month)
	{
		static const int DAYS_IN_MONTH[2][13] = {
			{ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
			{ 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
		};

		return DAYS_IN_MONTH[IsLeapYear(year)][month];
	}

Calendar Calendar::GetAfterTwoMonthDay() const {
	if (this->Month == 12) {
		if (!IsLeapYear(this->Year + 1)) return this->Day >= 28 ? Calendar(this->Year + 1, 2, 28) : Calendar(this->Year + 1, 2, this->Day);
		else return this->Day >= 29 ? Calendar(this->Year + 1, 2, 29) : Calendar(this->Year + 1, 2, this->Day);
	}
	else if (this->Month == 11) return Calendar(this->Year + 1, 1, this->Day);
	else if (this->Month == 7 && this->Day == 31) return Calendar(this->Year, 9, 30);
	else return Calendar(this->Year, this->Month + 2, this->Day);
}

Calendar Calendar::GetAfterAWeekDay() const {
	auto AfterAWeekDate = [this](const int AbleToSimpleAddBorderDay) { 
		return this->Day <= AbleToSimpleAddBorderDay ? Calendar(this->Year, this->Month, this->Day + 7) : Calendar(this->Year, Month + 1, this->Day - AbleToSimpleAddBorderDay);
	};
	if (this->Month == 12 && this->Day > 24) return Calendar(this->Year + 1, 1, this->Day - 24);
	else if (!IsNo31Month(this->Month)) return AfterAWeekDate(24);
	else if (this->Month != 2) return AfterAWeekDate(23);
	else return AfterAWeekDate((IsLeapYear(this->Year) ? 22 : 21));
}

int32 FDateTime::DaysInYear( int32 Year )
{
	if (IsLeapYear(Year))
	{
		return 366;
	}

	return 365;
}

void NextDay(){
day++;
if(day>DayOfMonth[month][IsLeapYear(year)]){
day=1;month++;
}
if(month>12){
month=1;year++;
}
}

STATIC
BOOLEAN
ValidDay (
  IN  EFI_TIME  time
  )
{
  if (time.Day > DayOfMonth[time.Month - 1]) {
    return FALSE;
  }
  //
  // Pay attention to month==2
  //
  if (time.Month == 2 && ((IsLeapYear (time) && time.Day > 29) || (!IsLeapYear (time) && time.Day > 28))) {
    return FALSE;
  }

  return TRUE;
}

//	////////////////////////////////////////////////////////////////////////////
inline unsigned int MonthDayMax(unsigned int in_year, unsigned int in_month)
{
	return((!YearMonthOk(in_year, in_month)) ? 0 :
		(((in_month == 1) || (in_month == 3) ||
		(in_month == 5) || (in_month == 7) || (in_month == 8) ||
		(in_month == 10) || (in_month == 12)) ? 31 : ((in_month == 4) ||
		(in_month == 6) || (in_month == 9) || (in_month == 11)) ? 30 :
		(28 + ((IsLeapYear(in_year)) ? 1 : 0))));
}

STATIC
BOOLEAN
EFIAPI
IsDayValid (
  IN  EFI_TIME  *Time
  )
{
  ASSERT (Time->Day >= 1);
  ASSERT (Time->Day <= mDayOfMonth[Time->Month - 1]);
  ASSERT (Time->Month != 2 || IsLeapYear (Time) || Time->Day <= 28);

  if (Time->Day < 1 ||
      Time->Day > mDayOfMonth[Time->Month - 1] ||
      (Time->Month == 2 && !IsLeapYear (Time) && Time->Day > 28)) {
    return FALSE;
  }
  return TRUE;
}

int CMyCalendar::MonthDays(int year,int month)
{
	if(month==2)
	{
		if(IsLeapYear(year))
			return 29;
		return 28;
	}
	return sMonthDays[month];
}

unsigned CTimer::GetDaysOfMonth (unsigned nMonth, unsigned nYear)
{
	if (   nMonth == 1
	    && IsLeapYear (nYear))
	{
		return 29;
	}

	return s_nDaysOfMonth[nMonth];
}

//returns the length of any month, ie length of November would be 30
int cTimeAndDate::LengthOfMonth(int month) const {
        int ret=-1;
	switch(month) {
 		case 9: case 4: case 6: case 11: ret=30; break;
   		case 1: case 3: case 5: case 7: case 8: case 10: case 12: ret=31; break;
		case 2: if(IsLeapYear()) ret=29; else ret=28; break;
  		default: ret=-1; //invalid month
    	}
     	return ret;
}

/******************************************************************************
 *  RtlTimeFieldsToTime		[[email protected]]
 *
 */
BOOLEAN WINAPI RtlTimeFieldsToTime(
	PTIME_FIELDS tfTimeFields,
	PLARGE_INTEGER Time)
{
	int CurYear, CurMonth;
	long long int rcTime;
	TIME_FIELDS TimeFields = *tfTimeFields;

	rcTime = 0;

	/* FIXME: normalize the TIME_FIELDS structure here */
	while (TimeFields.Second >= SECSPERMIN)
	{ NormalizeTimeFields(&TimeFields.Second, &TimeFields.Minute, SECSPERMIN);
	}
	while (TimeFields.Minute >= MINSPERHOUR)
	{ NormalizeTimeFields(&TimeFields.Minute, &TimeFields.Hour, MINSPERHOUR);
	}
	while (TimeFields.Hour >= HOURSPERDAY)
	{ NormalizeTimeFields(&TimeFields.Hour, &TimeFields.Day, HOURSPERDAY);
	}
	while (TimeFields.Day > MonthLengths[IsLeapYear(TimeFields.Year)][TimeFields.Month - 1])
	{ NormalizeTimeFields(&TimeFields.Day, &TimeFields.Month, SECSPERMIN);
	}
	while (TimeFields.Month > MONSPERYEAR)
	{ NormalizeTimeFields(&TimeFields.Month, &TimeFields.Year, MONSPERYEAR);
	}

	/* FIXME: handle calendar corrections here */
	for (CurYear = EPOCHYEAR; CurYear < TimeFields.Year; CurYear++)
	{ rcTime += YearLengths[IsLeapYear(CurYear)];
	}
	for (CurMonth = 1; CurMonth < TimeFields.Month; CurMonth++)
	{ rcTime += MonthLengths[IsLeapYear(CurYear)][CurMonth - 1];
	}
	rcTime += TimeFields.Day - 1;
	rcTime *= SECSPERDAY;
	rcTime += TimeFields.Hour * SECSPERHOUR + TimeFields.Minute * SECSPERMIN + TimeFields.Second;
	rcTime *= TICKSPERSEC;
	rcTime += TimeFields.Milliseconds * TICKSPERMSEC;
	*Time = *(LARGE_INTEGER *)&rcTime;

	return TRUE;
}

/**
 * Converts a tuple of Year, Month and Day to a Date.
 * @param year  is a number between 0..MAX_YEAR
 * @param month is a number between 0..11
 * @param day   is a number between 1..31
 */
Date ConvertYMDToDate(Year year, Month month, Day day)
{
	/* Day-offset in a leap year */
	int days = _accum_days_for_month[month] + day - 1;

	/* Account for the missing of the 29th of February in non-leap years */
	if (!IsLeapYear(year) && days >= ACCUM_MAR) days--;

	return DAYS_TILL(year) + days;
}

int DayRank(int year, int month, int date)
{
	int days = 0, i;
	int flag = IsLeapYear(year);
	if (flag) MONTH[1] = 29;
	else MONTH[1] = 28;
	for (i = 0; i < month - 1; ++i) days += MONTH[i];
	days += date;
	return days;
}

int main(int argc, char* argv[]){
	
	int year = 0;
	if(argc == 2)
		year = atoi(argv[1]);
	if(IsLeapYear(year))
		printf("%d is a leap year\n", year);
	else
		printf("%d is not a leap year\n", year);
	return 0;
}

int Date::Get() const
{
	if(IsNull(*this))
		return Null;
	int y400 = (year / 400 ) - 2;
	int ym = year - y400 * 400;
	return y400 * (400 * 365 + 100 - 3) +
	        ym * 365 + s_month_off[month - 1] + (day - 1) +
	       (ym - 1) / 4 - (ym - 1) / 100 + (ym - 1) / 400 + 1 +
	       (month > 2) * IsLeapYear(ym);
}