formatjs_temporal 1.0.0

Temporal calendar, date, time and timezone primitives
use crate::{
    CalendarProvider, Duration, Error, MAX_EPOCH_NANOSECONDS, NANOSECONDS_PER_DAY, RoundingMode,
    TimeUnit, round_duration_nanoseconds,
};

#[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
#[repr(usize)]
pub enum DateTimeUnit {
    Year,
    Month,
    Week,
    Day,
    Hour,
    Minute,
    Second,
    Millisecond,
    Microsecond,
    Nanosecond,
}
impl DateTimeUnit {
    pub(crate) fn time(self) -> Option<TimeUnit> {
        match self {
            Self::Hour => Some(TimeUnit::Hour),
            Self::Minute => Some(TimeUnit::Minute),
            Self::Second => Some(TimeUnit::Second),
            Self::Millisecond => Some(TimeUnit::Millisecond),
            Self::Microsecond => Some(TimeUnit::Microsecond),
            Self::Nanosecond => Some(TimeUnit::Nanosecond),
            _ => None,
        }
    }
}
impl core::str::FromStr for DateTimeUnit {
    type Err = Error;
    fn from_str(value: &str) -> Result<Self, Error> {
        match value.strip_suffix('s').unwrap_or(value) {
            "year" => Ok(Self::Year),
            "month" => Ok(Self::Month),
            "week" => Ok(Self::Week),
            "day" => Ok(Self::Day),
            "hour" => Ok(Self::Hour),
            "minute" => Ok(Self::Minute),
            "second" => Ok(Self::Second),
            "millisecond" => Ok(Self::Millisecond),
            "microsecond" => Ok(Self::Microsecond),
            "nanosecond" => Ok(Self::Nanosecond),
            _ => Err(Error::InvalidRoundingOptions),
        }
    }
}
impl From<TimeUnit> for DateTimeUnit {
    fn from(value: TimeUnit) -> Self {
        match value {
            TimeUnit::Hour => Self::Hour,
            TimeUnit::Minute => Self::Minute,
            TimeUnit::Second => Self::Second,
            TimeUnit::Millisecond => Self::Millisecond,
            TimeUnit::Microsecond => Self::Microsecond,
            TimeUnit::Nanosecond => Self::Nanosecond,
        }
    }
}
pub(crate) trait RelativeAnchor {
    type Calendar: CalendarProvider;
    fn calendar(&self) -> Self::Calendar;
    const ZONED: bool;
    fn origin(&self) -> i128;
    fn date_at(&self, value: i128) -> Result<i64, Error>;
    fn clock_at(&self, value: i128) -> Result<i128, Error> {
        Ok(value.rem_euclid(NANOSECONDS_PER_DAY))
    }
    fn endpoint(&self, fields: [i128; 10]) -> Result<i128, Error>;
}
fn endpoint<A: RelativeAnchor>(start: &A, fields: [i128; 10]) -> Result<i128, Error> {
    start.endpoint(fields)
}
fn date_until<A: RelativeAnchor>(
    anchor: &A,
    start: i64,
    end: i64,
    largest: DateTimeUnit,
) -> Result<[i128; 10], Error> {
    use crate::calendar::DateUnit;
    let unit = match largest {
        DateTimeUnit::Year => DateUnit::Year,
        DateTimeUnit::Month => DateUnit::Month,
        DateTimeUnit::Week => DateUnit::Week,
        _ => DateUnit::Day,
    };
    let value = anchor
        .calendar()
        .until_raw(start, end, unit)
        .map_err(|_| Error::OutOfRange)?;
    Ok([
        i128::from(value.years),
        i128::from(value.months),
        i128::from(value.weeks),
        i128::from(value.days),
        0,
        0,
        0,
        0,
        0,
        0,
    ])
}
pub(crate) fn unrounded<A: RelativeAnchor>(
    start: &A,
    end: i128,
    largest: DateTimeUnit,
) -> Result<[i128; 10], Error> {
    let origin = start.origin();
    if let Some(time) = largest.time() {
        return Ok(Duration::from_time_nanoseconds(end - origin, time)?.fields());
    }
    let sign = (end - origin).signum();
    if sign == 0 {
        return Ok([0; 10]);
    }
    let begin = start.date_at(origin)?;
    let finish = start.date_at(end)?;
    if !A::ZONED {
        let mut day = finish;
        let mut remainder =
            end.rem_euclid(NANOSECONDS_PER_DAY) - origin.rem_euclid(NANOSECONDS_PER_DAY);
        if remainder * sign < 0 {
            day -= sign as i64;
            remainder += sign * NANOSECONDS_PER_DAY;
        }
        let mut fields = date_until(start, begin, day, largest)?;
        fields[4..].copy_from_slice(
            &Duration::from_time_nanoseconds(remainder, TimeUnit::Hour)?.fields()[4..],
        );
        return Ok(fields);
    }
    let mut day = finish;
    if (start.clock_at(end)? - start.clock_at(origin)?) * sign < 0 {
        day -= sign as i64;
    }
    if i128::from(day - begin) * sign < 0 {
        day = begin;
    }
    let mut fields = date_until(start, begin, day, largest)?;
    let mut anchor;
    loop {
        anchor = match endpoint(start, fields) {
            Ok(value) => value,
            Err(Error::OutOfRange | Error::InvalidDateTime) => {
                sign * (MAX_EPOCH_NANOSECONDS + NANOSECONDS_PER_DAY)
            }
            Err(error) => return Err(error),
        };
        if (anchor - end) * sign <= 0 {
            break;
        }
        day -= sign as i64;
        if i128::from(day - begin) * sign < 0 {
            fields = [0; 10];
            anchor = origin;
            break;
        }
        fields = date_until(start, begin, day, largest)?;
    }
    let time = Duration::from_time_nanoseconds(end - anchor, TimeUnit::Hour)?.fields();
    fields[4..].copy_from_slice(&time[4..]);
    Ok(fields)
}
pub(crate) fn difference<A: RelativeAnchor>(
    start: &A,
    end: i128,
    largest: DateTimeUnit,
    smallest: DateTimeUnit,
    increment: u32,
    mode: RoundingMode,
    since: bool,
) -> Result<Duration, Error> {
    validate_options(largest, smallest, increment)?;
    let origin = start.origin();
    if origin == end {
        return Duration::new([0; 10]);
    }
    let sign = (end - origin).signum();
    let since_sign = if since { -1 } else { 1 };
    let mut fields = unrounded(start, end, largest)?;
    let mut expanded = false;
    let rounded;
    if smallest < DateTimeUnit::Day || A::ZONED && smallest == DateTimeUnit::Day {
        let mut prefix = [0; 10];
        prefix[largest as usize..smallest as usize]
            .copy_from_slice(&fields[largest as usize..smallest as usize]);
        let index = smallest as usize;
        let count = if smallest == DateTimeUnit::Week {
            fields[2] + fields[3] / 7
        } else {
            fields[index]
        };
        let mut truncated = count / i128::from(increment) * i128::from(increment);
        prefix[index] = truncated;
        let mut a = endpoint(start, prefix)?;
        prefix[index] = truncated + sign * i128::from(increment);
        let mut b = endpoint(start, prefix)?;
        if (end - a) * sign < 0 || (b - end) * sign < 0 {
            truncated += sign * i128::from(increment);
            a = b;
            prefix[index] = truncated + sign * i128::from(increment);
            b = endpoint(start, prefix)?;
            expanded = true;
        }
        let expand = if a == end {
            false
        } else if b == end {
            true
        } else {
            let positive = sign * since_sign > 0;
            let distance = (end - a) * sign;
            let span = (b - a) * sign;
            match mode {
                RoundingMode::Expand => true,
                RoundingMode::Trunc => false,
                RoundingMode::Ceil => positive,
                RoundingMode::Floor => !positive,
                _ if distance * 2 != span => distance * 2 > span,
                RoundingMode::HalfExpand => true,
                RoundingMode::HalfTrunc => false,
                RoundingMode::HalfCeil => positive,
                RoundingMode::HalfFloor => !positive,
                RoundingMode::HalfEven => (truncated / i128::from(increment)).abs() % 2 == 1,
            }
        };
        prefix[index] = if expand {
            truncated + sign * i128::from(increment)
        } else {
            truncated
        };
        fields = prefix;
        rounded = if expand { b } else { a };
        expanded |= expand;
    } else if A::ZONED && largest <= DateTimeUnit::Day {
        let time = Duration::new(fields)?.time_nanoseconds(false)?;
        let quantum = i128::from(increment) * smallest.time().unwrap().nanoseconds();
        let mut value = since_sign * round_duration_nanoseconds(time * since_sign, quantum, mode)?;
        if value == time {
            rounded = end;
        } else {
            fields[4..].fill(0);
            let base = endpoint(start, fields)?;
            let mut next = fields;
            next[3] += sign;
            let span = endpoint(start, next)? - base;
            expanded = (value - span) * sign >= 0;
            if expanded {
                fields[3] += sign;
                value = since_sign
                    * round_duration_nanoseconds((value - span) * since_sign, quantum, mode)?;
                rounded = base + span + value;
            } else {
                rounded = base + value;
            }
            fields[4..].copy_from_slice(
                &Duration::from_time_nanoseconds(value, TimeUnit::Hour)?.fields()[4..],
            );
        }
    } else {
        let time = Duration::new(fields)?.time_nanoseconds(true)?;
        let quantum = i128::from(increment)
            * smallest
                .time()
                .map_or(NANOSECONDS_PER_DAY, |unit| unit.nanoseconds());
        let value = since_sign * crate::rounding::round_duration(time * since_sign, quantum, mode);
        let days = if largest <= DateTimeUnit::Day {
            value / NANOSECONDS_PER_DAY
        } else {
            0
        };
        expanded = (days - fields[3]).signum() == sign;
        rounded = end + value - time;
        let remainder = if largest <= DateTimeUnit::Day {
            value % NANOSECONDS_PER_DAY
        } else {
            value
        };
        fields[3] = days;
        fields[4..].copy_from_slice(
            &Duration::from_time_nanoseconds(remainder, largest.time().unwrap_or(TimeUnit::Hour))?
                .fields()[4..],
        );
    }
    if expanded && smallest != DateTimeUnit::Week {
        let mut index = (smallest as usize).min(DateTimeUnit::Day as usize);
        while index > largest as usize {
            index -= 1;
            if index == DateTimeUnit::Week as usize && largest != DateTimeUnit::Week {
                continue;
            }
            let mut candidate = [0; 10];
            candidate[..index].copy_from_slice(&fields[..index]);
            candidate[index] = fields[index] + sign;
            let boundary = endpoint(start, candidate)?;
            if (rounded - boundary) * sign < 0 {
                break;
            }
            fields = candidate;
        }
    }
    if since {
        for field in &mut fields {
            *field = -*field;
        }
    }
    Duration::new(fields)
}

pub(crate) fn validate_options(
    largest: DateTimeUnit,
    smallest: DateTimeUnit,
    increment: u32,
) -> Result<(), Error> {
    if largest > smallest || increment == 0 || increment > 1_000_000_000 {
        return Err(Error::InvalidRoundingOptions);
    }
    if let Some(time) = smallest.time() {
        let maximum = match time {
            TimeUnit::Hour => 24,
            TimeUnit::Minute | TimeUnit::Second => 60,
            _ => 1000,
        };
        if increment >= maximum || maximum % increment != 0 {
            return Err(Error::InvalidRoundingOptions);
        }
    }
    Ok(())
}