//! epoch is seconds since 1 January, 1970, without leap seconds.
//!
//! year 0 is "1 BC", year -1 is "2 BC" and so on

use errors::*;
use std::fmt;

fn is_leap_year(year: i16) -> bool {
	0 == year % 4 && (0 != year % 100 || 0 == year % 400)
}

#[test]
fn test_is_leap_year() {
	assert!(!is_leap_year(-500));
	assert!(is_leap_year(-404));
	assert!(is_leap_year(-400));
	assert!(is_leap_year(-396));
	assert!(!is_leap_year(-300));
	assert!(!is_leap_year(-200));
	assert!(!is_leap_year(-100));
	assert!(is_leap_year(-4));
	assert!(!is_leap_year(-3));
	assert!(!is_leap_year(-1));
	assert!(is_leap_year(0));
	assert!(!is_leap_year(1));
	assert!(!is_leap_year(3));
	assert!(is_leap_year(4));
	assert!(!is_leap_year(100));
	assert!(!is_leap_year(200));
	assert!(!is_leap_year(300));
	assert!(is_leap_year(396));
	assert!(is_leap_year(400));
	assert!(is_leap_year(404));
	assert!(!is_leap_year(500));
}

fn month_day_of_year_since_march(month: u8) -> u16 {
	debug_assert!(month >= 1 && month <= 12);
	let month_from_march = if month > 2 { month as u16 - 3} else { month as u16 + 9 };
	(153 * month_from_march + 2) / 5
}

fn month_and_day_from_day_of_year_since_march(day_of_year: i32) -> (u8, u8) {
	let month_from_march = (5 * day_of_year + 2) / 153;
	debug_assert!(month_from_march >= 0 && month_from_march <= 11);

	let day = day_of_year - (153 * month_from_march + 2) / 5 + 1;
	debug_assert!(day >= 1 && day <= 31);

	let month_from_march = month_from_march as u8;

	let month = if month_from_march < 10 { month_from_march + 3 } else { month_from_march - 9 };
	debug_assert!(month >= 1 && month <= 12);

	(month, day as u8)
}

#[test]
fn test_month_day_of_year_since_march() {
	static MONTH_START: [u16; 12] = [306, 337, 0, 31, 61, 92, 122, 153, 184, 214, 245, 275, ];
	static DAYS_IN_MONTHS: [u8; 12] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
	for (m, &s) in MONTH_START.iter().enumerate() {
		assert_eq!(month_day_of_year_since_march(m as u8 + 1), s);
		assert_eq!(month_and_day_from_day_of_year_since_march(s as i32), (m as u8 + 1, 1));
		assert_eq!(month_and_day_from_day_of_year_since_march(s as i32 + DAYS_IN_MONTHS[m] as i32 - 1), (m as u8 + 1, DAYS_IN_MONTHS[m]));
	}
	assert_eq!(month_and_day_from_day_of_year_since_march(365), (2, 29));
}

#[inline(always)]
fn pos_div_rem(n: i32, pos_div: i32) -> (i32, i32) {
	// try to avoid overflows
	debug_assert!(pos_div > 0);
	let res = n / pos_div;
	let rem = n % pos_div;
	debug_assert_eq!(res * pos_div + rem, n);
	if rem < 0 {
		let rem = rem + pos_div;
		let res = res - 1;
		debug_assert_eq!(res * pos_div + rem, n);
		debug_assert!(rem >= 0 && rem < pos_div);
		(res, rem)
	} else {
		debug_assert!(rem >= 0 && rem < pos_div);
		(res, rem)
	}
}

#[inline(always)]
fn pos_div_rem64(n: i64, pos_div: i64) -> (i64, i64) {
	// try to avoid overflows
	debug_assert!(pos_div > 0);
	let res = n / pos_div;
	let rem = n % pos_div;
	debug_assert_eq!(res * pos_div + rem, n);
	if rem < 0 {
		let rem = rem + pos_div;
		let res = res - 1;
		debug_assert_eq!(res * pos_div + rem, n);
		debug_assert!(rem >= 0 && rem < pos_div);
		(res, rem)
	} else {
		debug_assert!(rem >= 0 && rem < pos_div);
		(res, rem)
	}
}

// year 0 is era 0, year-of-era 0
// -> (ear, year_of_era)
fn era_split_year(year: i32) -> (i32, i32) {
	pos_div_rem(year, 400)
}

#[test]
fn test_era_split_year() {
	// -800...-401, -400...-1, 0...399, 400...799
	assert_eq!(era_split_year(-801), (-3, 399));
	assert_eq!(era_split_year(-800), (-2, 0));
	assert_eq!(era_split_year(-799), (-2, 1));
	assert_eq!(era_split_year(-401), (-2, 399));
	assert_eq!(era_split_year(-400), (-1, 0));
	assert_eq!(era_split_year(-399), (-1, 1));
	assert_eq!(era_split_year(-1), (-1, 399));
	assert_eq!(era_split_year(0), (0, 0));
	assert_eq!(era_split_year(1), (0, 1));
	assert_eq!(era_split_year(399), (0, 399));
	assert_eq!(era_split_year(400), (1, 0));
	assert_eq!(era_split_year(401), (1, 1));
	assert_eq!(era_split_year(799), (1, 399));
	assert_eq!(era_split_year(1970), (4, 370));
}

// -> (era, day_of_era)
fn split_days_since_march1_y0_into_era(days: i32) -> (i32, i32) {
	pos_div_rem(days, ERA_DAYS)
}

fn year_of_era_from_day_of_era(day_of_era: i32) -> i32 {
	let res = (day_of_era - day_of_era/1460 + day_of_era/36524 - day_of_era/146096) / 365;
	debug_assert!(res >= 0 && res <= 399);
	res
}

#[test]
fn test_year_of_era_from_day_of_era() {
	for year_of_era in 0..399 {
		let ds = first_day_of_year_in_era_from_year_of_era(year_of_era);
		assert_eq!(year_of_era_from_day_of_era(ds + 0), year_of_era);
		assert_eq!(year_of_era_from_day_of_era(ds + 364), year_of_era);
		// 29. february counts to previous year; so if next ("real") year is leap year,
		// the current year_of_era has a leap day.
		if is_leap_year(year_of_era as i16 + 1) {
			assert_eq!(year_of_era_from_day_of_era(ds + 365), year_of_era);
		}
	}
}

const EPOCH_DAYS_SINCE_MARCH1_Y0: i32 = 719468;

// there are 100 - 4 + 1 leap years in 400 years.
const ERA_DAYS: i32 = 365 * 400 + 100 - 4 + 1; // 146097

fn first_day_of_year_in_era_from_year_of_era(year_of_era: i32) -> i32 {
	365 * year_of_era + year_of_era / 4 - year_of_era / 100
}

// days since march 1st in 1 BC (year "0")
fn days_since_march1_y0(year: i16, month: u8, day: u8) -> i32 {
	// group 400 years as one era, but split between february and
	// march; count jan/feb to previous year, make march 1st start
	// of year
	let year = year as i32 - if month <= 2 { 1 } else { 0 };

	let (era, year_of_era) = era_split_year(year);

	let day_of_year = month_day_of_year_since_march(month) + day as u16 - 1;
	let day_of_era = first_day_of_year_in_era_from_year_of_era(year_of_era) + day_of_year as i32;

	era as i32 * ERA_DAYS + day_of_era
}

fn split_days_since_march1_y0(days: i32) -> (i32, u8, u8) {
	let (era, day_of_era) = split_days_since_march1_y0_into_era(days);
	let year_of_era = year_of_era_from_day_of_era(day_of_era);
	let day_of_year = day_of_era - first_day_of_year_in_era_from_year_of_era(year_of_era);

	let (month, day) = month_and_day_from_day_of_year_since_march(day_of_year);

	let year = 400 * era + year_of_era + if month <= 2 { 1 } else { 0 };

	(year as i32, month, day)
}

#[test]
fn test_days_since_march1_y0() {
	assert_eq!(days_since_march1_y0(-1, 3, 1), -366);
	assert_eq!(days_since_march1_y0(0, 3, 1), 0);
	assert_eq!(days_since_march1_y0(1, 3, 1), 365);
	assert_eq!(days_since_march1_y0(1970, 1, 1), EPOCH_DAYS_SINCE_MARCH1_Y0);
	assert_eq!(days_since_march1_y0(1970, 1, 1),
		/* regular days in years: */ 365 * 1969
		/* days from leap years: */ + (1969 / 4 - 15)
		/* days from march 1st year 0 to january 1st year 1: */ + 306);

	assert_eq!(split_days_since_march1_y0(-366), (-1, 3, 1));
	assert_eq!(split_days_since_march1_y0(0), (0, 3, 1));
	assert_eq!(split_days_since_march1_y0(365), (1, 3, 1));
	assert_eq!(split_days_since_march1_y0(EPOCH_DAYS_SINCE_MARCH1_Y0), (1970, 1, 1));
}

#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)]
pub struct Tm {
	pub year: i16, // absolute year: 1 is "1 AD", 0 is "1 BC".
	pub month: u8, // 01...12
	pub day: u8, // 01..31
	pub hour: u8, // 00..23
	pub minute: u8, // 00..59
	pub second: u8, // 00..59
}

#[allow(unused)]
impl Tm {
	pub fn from_epoch(epoch: i64) -> Result<Self> {
		let (day, time_of_day) = pos_div_rem64(epoch, 86400);
		let days_since_march1_y0 = day + EPOCH_DAYS_SINCE_MARCH1_Y0 as i64;
		ensure!((days_since_march1_y0 as i32) as i64 == days_since_march1_y0, "days in epoch out of range");
		let days_since_march1_y0 = days_since_march1_y0 as i32;

		let (year, month, day) = split_days_since_march1_y0(days_since_march1_y0);
		ensure!((year as i16) as i32 == year, "year in epoch out of range");
		let year = year as i16;

		let (minute_of_day, second) = pos_div_rem(time_of_day as i32, 60);
		let (hour, minute) = pos_div_rem(minute_of_day, 60);

		Ok(Tm{
			year,
			month,
			day,
			hour: hour as u8,
			minute: minute as u8,
			second: second as u8,
		})
	}

	fn days_since_epoch(&self) -> i32 {
		let days = days_since_march1_y0(self.year as i16, self.month, self.day);
		days - EPOCH_DAYS_SINCE_MARCH1_Y0
	}

	fn day_seconds(&self) -> u32 {
		self.second as u32
			+ 60 * self.minute as u32
			+ 3600 * self.hour as u32
	}

	pub fn epoch(&self) -> i64 {
		86400 * self.days_since_epoch() as i64 + self.day_seconds() as i64
	}

	#[allow(non_snake_case)]
	pub fn parse_YYYYMMDDHHmmSS(s: &str) -> Result<Self> {
		ensure!(s.len() == 14, "Tm string must be exactly 14 digits long");
		ensure!(s.as_bytes().iter().all(|&b| b >= b'0' && b <= b'9'), "Tm string must be exactly 14 digits long");
		let year = s[0..4].parse::<i16>()?;
		ensure!(year >= 1, "year must be >= 1");
		ensure!(year <= 9999, "year must be <= 9999");

		fn p(s: &str, min: u8, max: u8, name: &'static str) -> ::errors::Result<u8> {
			let v = s.parse::<u8>()?;
			ensure!(v >= min && v <= max, "{} {} out of range {}-{}", name, v, min, max);
			Ok(v)
		}

		let month  = p(&s[4..6], 1, 12, "month")?;
		let day    = p(&s[6..8], 1, 31, "day")?;
		let hour   = p(&s[8..10], 0, 23, "hour")?;
		let minute = p(&s[10..12], 0, 59, "minute")?;
		let second = p(&s[12..14], 0, 59, "second")?;

		if 2 == month {
			ensure!(day < 30, "day {} out of range in february", day);
			ensure!(is_leap_year(year) || day < 29, "day {} out of range in february (not a leap year)", day);
		} else {
			static DAYS_IN_MONTHS: [u8; 12] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
			let max_days = DAYS_IN_MONTHS[month as usize - 1];
			ensure!(day <= max_days, "day {} out of range for month {}", day, month);
		}

		Ok(Tm{ year, month, day, hour, minute, second })
	}

	#[allow(non_snake_case)]
	pub fn format_YYYYMMDDHHmmSS<W>(&self, f: &mut W) -> fmt::Result
	where
		W: fmt::Write + ?Sized
	{
		if self.year < 0 || self.year > 9999 { return Err(fmt::Error); }
		write!(f, "{:04}{:02}{:02}{:02}{:02}{:02}",
			self.year, self.month, self.day,
			self.hour, self.minute, self.second
		)
	}
}