use chrono::{Datelike, Duration as ChronoDur, NaiveDate, NaiveDateTime, NaiveTime};
use crate::{Error, Result};
use super::exact::DurationTiers;
use super::zone::{add_offset, sub_offset};
use super::{nanos_to_time, range_err, time_to_nanos, Temporal, NANOS_PER_DAY};
pub fn civil_epoch_days(year: i64, month: u32, day: u32) -> i128 {
let mut y = i128::from(year);
let mut m = i128::from(month);
if m <= 2 {
y -= 1;
m += 9;
} else {
m -= 3;
}
let era = y.div_euclid(400);
let yoe = y - era * 400;
let doy = (153 * m + 2) / 5 + i128::from(day) - 1;
let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
era * 146097 + doe - 719468
}
pub fn civil_from_days(days: i128) -> (i64, u32, u32) {
let z = days + 719_468;
let era = z.div_euclid(146_097);
let doe = z - era * 146_097;
let yoe = (doe - doe / 1_460 + doe / 36_524 - doe / 146_096) / 365;
let y = era * 400 + yoe;
let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
let mp = (5 * doy + 2) / 153;
let d = (doy - (153 * mp + 2) / 5 + 1) as u32;
let m = if mp < 10 { mp + 3 } else { mp - 9 } as u32;
(if m <= 2 { y + 1 } else { y } as i64, m, d)
}
pub(super) fn checked_add_dur(dt: NaiveDateTime, d: Option<ChronoDur>) -> Result<NaiveDateTime> {
let d = d.ok_or_else(range_err)?;
dt.checked_add_signed(d).ok_or_else(range_err)
}
pub(super) fn add_months(dt: NaiveDateTime, months: i64) -> Result<NaiveDateTime> {
let total = (i64::from(dt.year()) * 12 + (i64::from(dt.month()) - 1))
.checked_add(months)
.ok_or_else(range_err)?;
let year = i32::try_from(total.div_euclid(12)).map_err(|_| range_err())?;
let month = u32::try_from(total.rem_euclid(12) + 1).map_err(|_| range_err())?;
let last = last_day(year, month);
let day = dt.day().min(last);
let date = NaiveDate::from_ymd_opt(year, month, day).ok_or_else(range_err)?;
Ok(date.and_time(dt.time()))
}
fn last_day(year: i32, month: u32) -> u32 {
NaiveDate::from_ymd_opt(year, month, 1)
.and_then(|d| {
let next = if month == 12 {
year.checked_add(1)
.and_then(|y| NaiveDate::from_ymd_opt(y, 1, 1))
} else {
NaiveDate::from_ymd_opt(year, month + 1, 1)
};
next.map(|n| (n - d).num_days() as u32)
})
.unwrap_or(28)
}
fn shift_time_of_day(tm: NaiveTime, nanos: i128) -> NaiveTime {
let within_day = (i128::from(time_to_nanos(tm)) + nanos).rem_euclid(NANOS_PER_DAY);
nanos_to_time(i64::try_from(within_day).expect("rem_euclid bounds a within-day nanos count"))
}
fn negate_fields(months: i64, days: i64, nanos: i128) -> Result<(i64, i64, i128)> {
Ok((
months.checked_neg().ok_or_else(range_err)?,
days.checked_neg().ok_or_else(range_err)?,
nanos.checked_neg().ok_or_else(range_err)?,
))
}
fn duration_fields(t: &Temporal) -> Result<(i64, i64, i128)> {
let Temporal::Duration {
months,
days,
nanos,
} = t
else {
return Err(Error::ty("expected duration"));
};
Ok((*months, *days, *nanos))
}
pub fn negate_duration(t: &Temporal) -> Result<Temporal> {
let (months, days, nanos) = duration_fields(t)?;
let (months, days, nanos) = negate_fields(months, days, nanos)?;
Temporal::duration_checked_exact(months, days, nanos)
}
fn add_months_days_nanos(
dt: NaiveDateTime,
months: i64,
days: i64,
nanos: i128,
) -> Result<NaiveDateTime> {
let dt = add_months(dt, months)?;
let dt = checked_add_dur(dt, ChronoDur::try_days(days))?;
let nanos64 = i64::try_from(nanos).map_err(|_| range_err())?;
checked_add_dur(dt, Some(ChronoDur::nanoseconds(nanos64)))
}
pub fn add_duration(t: &Temporal, d: &Temporal) -> Result<Temporal> {
let (months, days, nanos) = duration_fields(d)?;
match t {
Temporal::Duration {
months: m,
days: da,
nanos: n,
} => {
let months = m.checked_add(months).ok_or_else(range_err)?;
let days = da.checked_add(days).ok_or_else(range_err)?;
let nanos = n.checked_add(nanos).ok_or_else(range_err)?;
Temporal::duration_checked_exact(months, days, nanos)
}
Temporal::Date(date) => {
let extra_days = i64::try_from(nanos / NANOS_PER_DAY).map_err(|_| range_err())?;
let days_total = days.checked_add(extra_days).ok_or_else(range_err)?;
let dt = add_months_days_nanos(date.and_time(NaiveTime::MIN), months, days_total, 0)?;
Ok(Temporal::Date(dt.date()))
}
Temporal::LocalDateTime(dt) => Ok(Temporal::LocalDateTime(add_months_days_nanos(
*dt, months, days, nanos,
)?)),
Temporal::DateTime { utc, offset, zone } => {
let local = add_offset(*utc, *offset)?;
let local = add_months_days_nanos(local, months, days, nanos)?;
let utc = sub_offset(local, *offset)?;
Ok(Temporal::DateTime {
utc,
offset: *offset,
zone: zone.clone(),
})
}
Temporal::LocalTime(tm) => Ok(Temporal::LocalTime(shift_time_of_day(*tm, nanos))),
Temporal::Time { time, offset } => Ok(Temporal::Time {
time: shift_time_of_day(*time, nanos),
offset: *offset,
}),
Temporal::CivilDate { .. } | Temporal::CivilDateTime { .. } => {
Err(Error::ty("civil date arithmetic out of range"))
}
}
}
pub fn sub_duration(t: &Temporal, d: &Temporal) -> Result<Temporal> {
let (months, days, nanos) = {
let (m, d, n) = duration_fields(d)?;
negate_fields(m, d, n)?
};
add_duration(
t,
&Temporal::Duration {
months,
days,
nanos,
},
)
}
pub fn scale_duration(t: &Temporal, factor: f64) -> Result<Temporal> {
let (months, days, nanos) = duration_fields(t)?;
if !factor.is_finite() {
return Err(Error::ty("duration scale factor"));
}
let mut tiers = DurationTiers::default();
tiers.months.add_float(months as f64 * factor)?;
tiers.days.add_float(days as f64 * factor)?;
tiers.nanos.add_float(nanos as f64 * factor)?;
let (months, days, nanos) = tiers.finish()?;
Temporal::duration_checked(months, days, nanos)
}