greg 0.2.5

use std::fmt;
use std::str::FromStr;

use super::{
	Date,
	Utc,
	ParseError,
	month
};

impl Date {
	/// Construct from year, month and day, **unchecked**
	///
	/// Just like directly accessing the fields, this method does not prevent you from creating invalid dates.
	pub const fn ymd(y: i64, m: u8, d: u8) -> Self {
		Self {y, m, d}
	}
	/// Construct from year, month and day and assert [`Self::is_valid`]
	///
	///```compile_fail
	/// use greg::calendar::Date;
	/// const INVALID: Date = Date::ymd_checked(2023, 9, 31);
	///```
	pub const fn ymd_checked(y: i64, m: u8, d: u8) -> Self {
		let new = Self {y, m, d};
		assert!(new.is_valid(), "invalid date");
		new
	}
	/// Checks whether fields are in the valid range & valid in combination
	///
	/// This also checks whether `y` is a leap year, if `m == 2` & `d == 29`.
	pub const fn is_valid(self) -> bool {
		let Self { y, m, d } = self;
		match (m, d) {
			(0 | 13.., _) | (_, 0) => false,
			(m, d) if d <= month::MONTHS[m as usize - 1].days => true,
			(2, 29) => Utc::is_leap(y),
			(_, _) => false
		}
	}

	/// Calculate the date within the cycle from the number of days since it began
	///
	/// The proleptic Gregorian calendar breaks down into repeating 400-year cycles.
	/// This function calculates the [`Date`] within such a cycle from the count of days since it began.
	pub(crate) const fn from_cycle_days(days: u32) -> Self {

		// get number of leap days before this day
		let leaps = Self::leap_days_before(days);

		// remove all leap days, from now on work with 365 day years
		let normalized = days - leaps as u32;

		let year = normalized / 365;
		let year_days = (normalized % 365) as u16;

		// Check if this day is a leap day and return
		if Self::leap_days_before(days + 1) != leaps {
			return Self {
				y: year as i64,
				m: 2,
				d: 29
			}
		}
		// This is a weird (and potentially inefficient) way of doing this, but
		// the idea was to make this calculation "branchless".
		// It seems to work and compile to `CMOVAE` instructions as intended.
		// BUT it has not actually been benchmarked, so…

		use month::offset::*;

		let mut month = 1;
		let mut offset = JAN;

		if year_days >= FEB {
			month = 2;
			offset = FEB;
		}
		if year_days >= MAR {
			month = 3;
			offset = MAR;
		}
		if year_days >= APR {
			month = 4;
			offset = APR;
		}
		if year_days >= MAY {
			month = 5;
			offset = MAY;
		}
		if year_days >= JUN {
			month = 6;
			offset = JUN;
		}
		if year_days >= JUL {
			month = 7;
			offset = JUL;
		}
		if year_days >= AUG {
			month = 8;
			offset = AUG;
		}
		if year_days >= SEP {
			month = 9;
			offset = SEP;
		}
		if year_days >= OCT {
			month = 10;
			offset = OCT;
		}
		if year_days >= NOV {
			month = 11;
			offset = NOV;
		}
		if year_days >= DEC {
			month = 12;
			offset = DEC;
		}

		Self {
			y: year as i64,
			m: month,
			// one-based day of month
			d: (year_days - offset + 1) as u8
		}
	}

	/// Number of leap days that occurred before this day of the cycle
	///
	/// There are 97 leap days in a 400 year (146_097 day) cycle.
	const fn leap_days_before(cycle_days: u32) -> u8 {
		// Length of centuries 1, 2, 3
		// Century 0 is one (leap) day longer
		const CENTURY: u32 = (365 * 4 + 1) * 25 - 1;

		// Days between leap days within a century
		const DAYS_BETWEEN_LEAPS: u32 = 365 * 4 + 1;

		// Since the first century is one day longer
		let century = cycle_days.saturating_sub(1) / CENTURY;

		// Century correction: 1, 0, 0, 0
		let is_cent_0 = if century == 0 {1} else {0};

		// Days from the beginning of the century
		// Because century 0 is 1 day longer, subtract that day first and then %.
		// This will give the correct remainder for all but the first century, so correct that by adding the day back.
		// Technically this folds day 0 and day 1 into the same value.
		let cent_days = cycle_days
			.saturating_sub(1)
			% CENTURY
			+ is_cent_0;

		// For century 0, shift the days "forward" 4 years so day 60 is the first leap
		let shift = is_cent_0 * (DAYS_BETWEEN_LEAPS - 1);

		// otherwise the first leap day is on day (DAYS_BETWEEN_LEAPS + 59)
		let shifted = (cent_days + shift).saturating_sub(59);
		// count leap days
		let leaps = shifted / DAYS_BETWEEN_LEAPS;

		// leap days from previous centuries
		// 0, 25, 25 + 24, 25 + 24 + 24
		let accrued = (century * 25) - century.saturating_sub(1);

		(accrued + leaps) as u8
	}
	/// Get the [`Date`] immediately after this one
	///
	/// This is a simple convenience method that handles leap days correctly.
	///```
	/// use greg::calendar::Date;
	/// let pre_leap = Date::ymd(2020, 2, 28);
	/// let leap = pre_leap.add_day();
	/// let post_leap = leap.add_day();
	///
	/// assert_eq!("2020-02-28", &pre_leap.to_string());
	/// assert_eq!("2020-02-29", &leap.to_string());
	/// assert_eq!("2020-03-01", &post_leap.to_string());
	///
	/// assert_eq!(Date::ymd(2020, 12, 31).add_day(), Date::ymd(2021, 1, 1));
	/// assert_eq!(Date::ymd(2021, 2, 28).add_day(), Date::ymd(2021, 3, 1));
	///```
	#[must_use]
	pub const fn add_day(self) -> Self {
		let Self { y, m, d } = self;
		let month_days = month::MONTHS[m as usize - 1].days;
		let d = d + 1;
		match d > month_days {
			true if m == 12 => Self {
				y: y + 1,
				m: 1,
				d: 1
			},
			true if m == 2 && d == 29 && Utc::is_leap(y) => Self {y, m, d},
			true => Self {y, m: m + 1, d: 1},
			false => Self {y, m, d}
		}
	}
	/// Get the [`Date`] immediately before this one
	///
	/// This is a simple convenience method that handles leap days correctly.
	///```
	/// use greg::calendar::Date;
	/// let post_leap = Date::ymd(2020, 3, 1);
	/// let leap = post_leap.sub_day();
	/// let pre_leap = leap.sub_day();
	///
	/// assert_eq!("2020-02-28", &pre_leap.to_string());
	/// assert_eq!("2020-02-29", &leap.to_string());
	/// assert_eq!("2020-03-01", &post_leap.to_string());
	///
	/// assert_eq!(Date::ymd(2021, 1, 1).sub_day(), Date::ymd(2020, 12, 31));
	/// assert_eq!(Date::ymd(2021, 3, 1).sub_day(), Date::ymd(2021, 2, 28));
	/// assert_eq!(Date::ymd(2021, 3, 2).sub_day(), Date::ymd(2021, 3, 1));
	///```
	#[must_use]
	pub const fn sub_day(self) -> Self {
		let Self { y, m, d } = self;
		match d >= 2 {
			true => Self {y, m, d: d - 1},
			false if m == 3 && Utc::is_leap(y) => Self {y, m: 2, d: 29},
			false if m == 1 => {Self {y: y - 1, m: 12, d: 31}},
			false => Self {
				y,
				m: m - 1,
				d: month::MONTHS[m as usize - 2].days
			}
		}
	}
}

impl fmt::Display for Date {
	/// Formats the [`Date`] as `YYYY-MM-DD` (i.e. `2022-12-31`)
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		let Self {y, m, d} = self;
		write!(f, "{y:04}-{m:02}-{d:02}")
	}
}

impl fmt::Debug for Date {
	/// Same as [`Display`](fmt::Display): `YYYY-MM-DD` (i.e. `2022-12-31`)
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
		fmt::Display::fmt(self, f)
	}
}

impl Date {
	/// Try to parse `YYYY-MM-DD` date
	///
	/// May also accept dates with too much or too little 0-padding for the year.
	/// Month and day segments must be exactly 2 digits.
	///
	///```
	/// use greg::calendar::Date;
	///
	/// // leap day in 2020
	/// assert_eq!(Date::try_parse("2020-02-29"), Ok(Date::ymd(2020, 2, 29)));
	/// // year zero, often written as 1 BC
	/// assert_eq!(Date::try_parse("0000-01-01"), Ok(Date::ymd(0, 1, 1)));
	/// // year before zero, often written as 2 BC
	/// assert_eq!(Date::try_parse("-001-01-01"), Ok(Date::ymd(-1, 1, 1)));
	/// assert_eq!(Date::try_parse("4321-01-23"), Ok(Date::ymd(4321, 1, 23)));
	///
	/// use greg::calendar::ParseError;
	///
	/// // no leap day in 2021
	/// assert_eq!(Date::try_parse("2021-02-29"), Err(ParseError::Invalid));
	/// assert_eq!(Date::try_parse("2021-01"), Err(ParseError::Format));
	/// assert_eq!(Date::try_parse("2021"), Err(ParseError::Format));
	/// assert_eq!(Date::try_parse("00:01:23"), Err(ParseError::Format));
	///```
	pub const fn try_parse(from: &str) -> Result<Self, ParseError> {
		if from.is_empty() {return Err(ParseError::Empty)}

		let bytes = from.as_bytes();
		// start from the back because the year can be arbitrarily long
		let [rest @ .., b'-', d1 @ b'0'..=b'9', d2 @ b'0'..=b'9'] = bytes else {
			return Err(ParseError::Format);
		};
		let [rest @ .., b'-', m1 @ b'0'..=b'9', m2 @ b'0'..=b'9'] = rest else {
			return Err(ParseError::Format);
		};

		let d = (*d1 - b'0') * 10 + (*d2 - b'0');
		let m = (*m1 - b'0') * 10 + (*m2 - b'0');

		let mut y: i64 = 0;
		let (mut year, is_bc) = match rest {
			[b'-', rest @ ..] => (rest, true),
			[] => return Err(ParseError::Format),
			rest => (rest, false)
		};
		loop {
			match year {
				[n @ b'0'..=b'9', rest @ ..] => match y.checked_mul(10) {
					Some(mul) => {
						year = rest;
						let digit = (*n - b'0') as i64;
						let Some(add_or_sub) = (match is_bc {
							true => mul.checked_sub(digit),
							false => mul.checked_add(digit)
						}) else {return Err(ParseError::Overflow)};
						y = add_or_sub;
					},
					None => return Err(ParseError::Overflow)
				},
				[_, ..] => return Err(ParseError::Format),
				[] => break
			}
		}
		let date = Self {y, m, d};
		if date.is_valid() {Ok(date)} else {Err(ParseError::Invalid)}
	}
	/// Parse `YYYY-MM-DD` date and panic if invalid
	///
	///```
	/// use greg::calendar::Date;
	/// const UNIX_DAY: Date = Date::parse("1970-01-01");
	///
	/// assert_eq!(Date::parse("2023-08-16"), Date::ymd(2023, 8, 16));
	/// assert_eq!(Date::parse("2023-12-24"), Date::ymd(2023, 12, 24));
	///```
	///
	/// This is mainly useful in `const` contexts, since the panic gets caught at compile-time.
	///
	///```compile_fail
	/// use greg::calendar::Date;
	/// const LEAP: Date = Date::parse("2023-02-29"); // not a leap year
	///```
	///
	/// See also the [`ymd_hms!`](crate::ymd_hms) macro for defining [`DateTime`](super::DateTime)s at compile-time.
	#[must_use]
	pub const fn parse(from: &str) -> Self {
		match Self::try_parse(from) {
			Ok(date) => date,
			Err(err) => panic!("{}", err.as_str())
		}
	}
}
impl FromStr for Date {
	type Err = ParseError;
	/// Parse `YYYY-MM-DD` date
	///
	/// May also accept dates with too much or too little 0-padding for the year.
	/// Month and day segments must be exactly 2 digits.
	///
	///```
	/// use greg::calendar::Date;
	/// assert_eq!("2020-01-01".parse(), Ok(Date::ymd(2020, 1, 1)));
	/// assert_eq!("1970-01-01".parse(), Ok(Date::ymd(1970, 1, 1)));
	/// assert_eq!("2022-12-31".parse(), Ok(Date::ymd(2022, 12, 31)));
	/// // leap day in 2020
	/// assert_eq!("2020-02-29".parse(), Ok(Date::ymd(2020, 2, 29)));
	/// // year zero, often written as 1 BC
	/// assert_eq!("0000-01-01".parse(), Ok(Date::ymd(0, 1, 1)));
	/// // year before zero, often written as 2 BC
	/// assert_eq!("-001-01-01".parse(), Ok(Date::ymd(-1, 1, 1)));
	///
	/// // no leap day in 2021
	/// assert!("2021-02-29".parse::<Date>().is_err());
	/// assert!("2021-01".parse::<Date>().is_err());
	/// assert!("2021".parse::<Date>().is_err());
	/// assert!("2000-00-00".parse::<Date>().is_err());
	/// assert!("2022-12-32".parse::<Date>().is_err());
	/// assert!("2023-13-31".parse::<Date>().is_err());
	/// assert!("2022-00-01".parse::<Date>().is_err());
	/// assert!("2022-01-00".parse::<Date>().is_err());
	/// assert!("0000-00-00".parse::<Date>().is_err());
	///```
	fn from_str(s: &str) -> Result<Self, Self::Err> {
		Self::try_parse(s)
	}
}

#[test]
fn date_parse() {
	use crate::ymd_hms;
	let valid = [
		(ymd_hms!(2023-01-31), "2023-01-31"),
		(ymd_hms!(2023-02-28), "2023-02-28"),
		(ymd_hms!(2023-03-31), "2023-03-31"),
		(ymd_hms!(2023-04-30), "2023-04-30"),
		(ymd_hms!(2023-05-31), "2023-05-31"),
		(ymd_hms!(2023-06-30), "2023-06-30"),
		(ymd_hms!(2023-07-31), "2023-07-31"),
		(ymd_hms!(2023-08-31), "2023-08-31"),
		(ymd_hms!(2023-09-30), "2023-09-30"),
		(ymd_hms!(2023-12-31), "2023-12-31"),
		(ymd_hms!(2023-11-30), "2023-11-30"),
		(ymd_hms!(2023-12-31), "2023-12-31"),
		(ymd_hms!(2020-02-29), "2020-02-29"),
		(ymd_hms!(2000-02-29), "2000-02-29"),
		(ymd_hms!(-10000-12-31), "-10000-12-31"),
		(ymd_hms!(10000-03-27), "10000-03-27"),
		(ymd_hms!(3030-03-03), "3030-03-03"),

		//TODO: consider enforcing proper year padding
		(ymd_hms!(1-12-31), "1-12-31"),
		(ymd_hms!(-1-12-31), "-1-12-31"),
		(ymd_hms!(11-11-11), "11-11-11"),
		(ymd_hms!(0000-01-01), "0-01-01"),
		(ymd_hms!(0000-11-22), "00000000000000000000000-11-22"),
		(ymd_hms!(0000-11-22), "-00000000000000000000000-11-22"),

		(ymd_hms!(6789-01-23), "6789-01-23"),
		(ymd_hms!(1111-11-11), "1111-11-11"),
		(ymd_hms!(0000-11-22), "0000-11-22"),
		(ymd_hms!(0000-01-01), "0000-01-01"),
		(ymd_hms!(9999-01-01), "9999-01-01"),
		(ymd_hms!(9223372036854775807-12-31), "9223372036854775807-12-31"),
		(ymd_hms!(-9223372036854775808-01-01), "-9223372036854775808-01-01")
	];
	for (expected, case) in valid {
		assert_eq!(Ok(expected.0), Date::try_parse(case));
	}
	let invalid = [
		(ParseError::Empty, ""),
		(ParseError::Format, "2023-1-1"),
		(ParseError::Format, "1111111111"),
		(ParseError::Format, "----------"),
		(ParseError::Format, "2023- 1-30"),
		(ParseError::Format, "12:34:56"),
		(ParseError::Format, "00:11:22"),
		(ParseError::Format, "                                      "),
		(ParseError::Format, " -100-01-02"),
		(ParseError::Format, "\n"),
		(ParseError::Format, "🤔"),
		(ParseError::Invalid, "2023-00-01"),
		(ParseError::Invalid, "2023-01-00"),
		(ParseError::Invalid, "0000-00-00"),
		(ParseError::Invalid, "2023-01-32"),
		(ParseError::Invalid, "2023-02-29"),
		(ParseError::Invalid, "2023-03-32"),
		(ParseError::Invalid, "2023-04-31"),
		(ParseError::Invalid, "2023-05-32"),
		(ParseError::Invalid, "2023-06-31"),
		(ParseError::Invalid, "2023-07-32"),
		(ParseError::Invalid, "2023-08-32"),
		(ParseError::Invalid, "2023-09-31"),
		(ParseError::Invalid, "2023-12-32"),
		(ParseError::Invalid, "2023-11-31"),
		(ParseError::Invalid, "2023-12-32"),
		(ParseError::Invalid, "2020-02-30"),
		(ParseError::Invalid, "2000-02-30"),
		(ParseError::Invalid, "2100-02-29"),
		(ParseError::Overflow, "9223372036854775808-12-31"),
		(
			ParseError::Overflow,
			"999999999999999999999999999999999999999999999999999999999999-12-31"
		),
		(ParseError::Overflow, "-9223372036854775809-01-01")
	];

	for (error, case) in invalid {
		assert_eq!(Err(error), Date::try_parse(case));
	}
}

#[test]
fn add_day_sub_day() {
	use std::iter::successors;
	//const CHECK_DAYS: usize = 50_000;
	const CHECK_DAYS: usize = 1000;

	let starting_days = [
		Date::ymd_checked(2023, 01, 01),
		Date::ymd_checked(2012, 02, 20),
		Date::ymd_checked(1900, 01, 01),
		Date::ymd_checked(1970, 01, 01),
		Date::ymd_checked(0000, 01, 01),
		Date::ymd_checked(-999, 12, 31),
		Date::ymd_checked(3030, 03, 03)
	];
	for start in starting_days {
		let forward: Vec<_> = successors(Some(start), |d| Some(d.add_day()))
			.take(CHECK_DAYS + 1)
			.collect();
		let last_day = Utc::lookup(
			Utc::resolve_midnight(start) + crate::Span::DAY * CHECK_DAYS as u64
		).0;
		let backward: Vec<_> = successors(Some(last_day), |d| Some(d.sub_day()))
			.take(CHECK_DAYS + 1)
			.collect();

		assert_eq!(forward.last().unwrap(), &last_day);
		assert_eq!(backward.last().unwrap(), &start);

		forward.iter()
			.rev()
			.zip(backward.iter())
			.for_each(|(a, b)| assert_eq!(a, b));

		forward.windows(2).for_each(|d| assert_eq!(d[0], d[1].sub_day()));
		backward.windows(2).for_each(|d| assert_eq!(d[0], d[1].add_day()));
		forward.windows(2).for_each(|d| assert!(d[0] < d[1]));
		backward.windows(2).for_each(|d| assert!(d[0] > d[1]));
	}
}