use time::{OffsetDateTime, UtcOffset, Weekday};
use super::common::{DaySelection, OpeningTimes};
use super::datetime::DateTime;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Opening {
Open,
Closed,
Unknown(UnknownReason),
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum UnknownReason {
NoOpeningTimes,
NoTimeZone,
MalformedTimeZone,
MalformedPeriod,
MalformedInstant,
}
impl Opening {
#[must_use]
pub const fn is_open(self) -> bool {
matches!(self, Self::Open)
}
#[must_use]
pub const fn is_closed(self) -> bool {
matches!(self, Self::Closed)
}
#[must_use]
pub const fn is_unknown(self) -> bool {
matches!(self, Self::Unknown(_))
}
}
fn parse_offset(time_zone: Option<&str>) -> Result<UtcOffset, UnknownReason> {
let tz = time_zone.ok_or(UnknownReason::NoTimeZone)?;
let bytes = tz.as_bytes();
if bytes.len() != 9 || &bytes[..3] != b"UTC" || bytes[6] != b':' {
return Err(UnknownReason::MalformedTimeZone);
}
let sign: i8 = match bytes[3] {
b'+' => 1,
b'-' => -1,
_ => return Err(UnknownReason::MalformedTimeZone),
};
let hours: i8 = tz[4..6].parse().map_err(|_| UnknownReason::MalformedTimeZone)?;
let minutes: i8 = tz[7..9].parse().map_err(|_| UnknownReason::MalformedTimeZone)?;
if hours > 14 || minutes > 59 {
return Err(UnknownReason::MalformedTimeZone);
}
UtcOffset::from_hms(sign * hours, sign * minutes, 0).map_err(|_| UnknownReason::MalformedTimeZone)
}
const fn covers(selection_matches: (bool, bool, bool), weekday: Weekday) -> bool {
let (everyday, workdays, weekend) = selection_matches;
if everyday {
return true;
}
let is_weekend = matches!(weekday, Weekday::Saturday | Weekday::Sunday);
(workdays && !is_weekend) || (weekend && is_weekend)
}
fn day_matches(selection: &DaySelection, weekday: Weekday) -> bool {
let named = match selection {
DaySelection::Monday => Some(Weekday::Monday),
DaySelection::Tuesday => Some(Weekday::Tuesday),
DaySelection::Wednesday => Some(Weekday::Wednesday),
DaySelection::Thursday => Some(Weekday::Thursday),
DaySelection::Friday => Some(Weekday::Friday),
DaySelection::Saturday => Some(Weekday::Saturday),
DaySelection::Sunday => Some(Weekday::Sunday),
_ => None,
};
if let Some(day) = named {
return day == weekday;
}
covers(
(
matches!(selection, DaySelection::Everyday),
matches!(selection, DaySelection::Workdays),
matches!(selection, DaySelection::Weekend),
),
weekday,
)
}
pub(crate) fn is_open_at(
is_open_24_hours: bool,
opening_times: Option<&Vec<OpeningTimes>>,
time_zone: Option<&str>,
at: &DateTime,
) -> Opening {
if is_open_24_hours {
return Opening::Open;
}
let Some(times) = opening_times.filter(|t| !t.is_empty()) else {
return Opening::Unknown(UnknownReason::NoOpeningTimes);
};
let offset = match parse_offset(time_zone) {
Ok(offset) => offset,
Err(reason) => return Opening::Unknown(reason),
};
let Some(instant) = at.as_offset() else {
return Opening::Unknown(UnknownReason::MalformedInstant);
};
let local: OffsetDateTime = instant.to_offset(offset);
let weekday = local.weekday();
let yesterday = weekday.previous();
let minutes = u16::from(local.hour()) * 60 + u16::from(local.minute());
let mut malformed = false;
for entry in times {
let opens_today = day_matches(&entry.on, weekday);
let opened_yesterday = day_matches(&entry.on, yesterday);
if !opens_today && !opened_yesterday {
continue;
}
for period in &entry.period {
let (Some(begin), Some(end)) = (period.begin.minutes_of_day(), period.end.minutes_of_day())
else {
malformed = true;
continue;
};
let open = if begin <= end {
opens_today && (begin..end).contains(&minutes)
} else {
(opens_today && minutes >= begin) || (opened_yesterday && minutes < end)
};
if open {
return Opening::Open;
}
}
}
if malformed { Opening::Unknown(UnknownReason::MalformedPeriod) } else { Opening::Closed }
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::{Extensions, HourMinute, Period};
fn window(on: DaySelection, begin: &str, end: &str) -> OpeningTimes {
OpeningTimes {
period: vec![Period {
begin: HourMinute::new(begin).expect("valid"),
end: HourMinute::new(end).expect("valid"),
}],
on,
extensions: Extensions::new(),
}
}
fn monday_at(utc: &str) -> DateTime {
format!("2026-08-31T{utc}:00.000Z").parse().expect("valid")
}
#[test]
fn around_the_clock_is_always_open() {
assert_eq!(is_open_at(true, None, None, &monday_at("03:00")), Opening::Open);
}
#[test]
fn a_local_window_is_evaluated_in_the_stations_own_time_zone() {
let times = vec![window(DaySelection::Workdays, "08:00", "18:00")];
assert_eq!(is_open_at(false, Some(×), Some("UTC+02:00"), &monday_at("07:00")), Opening::Open);
assert_eq!(is_open_at(false, Some(×), Some("UTC+02:00"), &monday_at("05:00")), Opening::Closed);
assert_eq!(is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at("07:00")), Opening::Closed);
}
#[test]
fn a_negative_offset_works_too() {
let times = vec![window(DaySelection::Everyday, "08:00", "18:00")];
assert_eq!(is_open_at(false, Some(×), Some("UTC-05:00"), &monday_at("15:00")), Opening::Open);
assert_eq!(is_open_at(false, Some(×), Some("UTC-05:00"), &monday_at("06:00")), Opening::Closed);
}
#[test]
fn an_overnight_window_stays_open_past_midnight() {
let times = vec![window(DaySelection::Everyday, "22:00", "02:00")];
let at = |utc: &str| is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at(utc));
assert_eq!(at("23:00"), Opening::Open, "before midnight");
assert_eq!(at("01:00"), Opening::Open, "after midnight");
assert_eq!(at("12:00"), Opening::Closed);
assert_eq!(at("02:00"), Opening::Closed, "the end is exclusive");
}
#[test]
fn an_overnight_window_belongs_to_the_day_it_opened_on() {
let times = vec![window(DaySelection::Monday, "22:00", "02:00")];
let at = |day: &str, utc: &str| {
let instant: DateTime = format!("2026-08-{day}T{utc}:00.000Z").parse().expect("valid");
is_open_at(false, Some(×), Some("UTC+00:00"), &instant)
};
assert_eq!(at("31", "23:00"), Opening::Open, "Monday evening");
assert_eq!(at("31", "01:00"), Opening::Closed, "Monday small hours belong to Sunday's window");
let tuesday: DateTime = "2026-09-01T01:00:00.000Z".parse().unwrap();
assert_eq!(
is_open_at(false, Some(×), Some("UTC+00:00"), &tuesday),
Opening::Open,
"Tuesday small hours are the tail of Monday's window"
);
let tuesday_evening: DateTime = "2026-09-01T23:00:00.000Z".parse().unwrap();
assert_eq!(
is_open_at(false, Some(×), Some("UTC+00:00"), &tuesday_evening),
Opening::Closed,
"Tuesday evening is not Monday's window"
);
}
#[test]
fn a_workday_window_does_not_leak_into_monday_morning_from_sunday() {
let times = vec![window(DaySelection::Workdays, "22:00", "02:00")];
assert_eq!(is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at("01:00")), Opening::Closed);
let saturday: DateTime = "2026-09-05T01:00:00.000Z".parse().unwrap();
assert_eq!(is_open_at(false, Some(×), Some("UTC+00:00"), &saturday), Opening::Open);
}
#[test]
fn an_unreadable_instant_is_unknown() {
let times = vec![window(DaySelection::Everyday, "08:00", "18:00")];
let broken = DateTime::new_unchecked("31.08.2026 12:00");
assert_eq!(
is_open_at(false, Some(×), Some("UTC+00:00"), &broken),
Opening::Unknown(UnknownReason::MalformedInstant)
);
}
#[test]
fn day_selections_are_honoured() {
let workdays = vec![window(DaySelection::Workdays, "08:00", "18:00")];
let weekend = vec![window(DaySelection::Weekend, "08:00", "18:00")];
let monday = vec![window(DaySelection::Monday, "08:00", "18:00")];
let noon = monday_at("12:00"); let saturday: DateTime = "2026-09-05T12:00:00.000Z".parse().unwrap();
assert_eq!(is_open_at(false, Some(&workdays), Some("UTC+00:00"), &noon), Opening::Open);
assert_eq!(is_open_at(false, Some(&workdays), Some("UTC+00:00"), &saturday), Opening::Closed);
assert_eq!(is_open_at(false, Some(&weekend), Some("UTC+00:00"), &saturday), Opening::Open);
assert_eq!(is_open_at(false, Some(&weekend), Some("UTC+00:00"), &noon), Opening::Closed);
assert_eq!(is_open_at(false, Some(&monday), Some("UTC+00:00"), &noon), Opening::Open);
assert_eq!(is_open_at(false, Some(&monday), Some("UTC+00:00"), &saturday), Opening::Closed);
}
#[test]
fn several_windows_in_a_day_are_all_considered() {
let times = vec![
window(DaySelection::Everyday, "08:00", "12:00"),
window(DaySelection::Everyday, "14:00", "18:00"),
];
let at = |utc: &str| is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at(utc));
assert_eq!(at("09:00"), Opening::Open);
assert_eq!(at("13:00"), Opening::Closed, "the lunch gap");
assert_eq!(at("15:00"), Opening::Open);
}
#[test]
fn what_cannot_be_answered_is_unknown_rather_than_closed() {
let times = vec![window(DaySelection::Everyday, "08:00", "18:00")];
let noon = monday_at("12:00");
assert_eq!(is_open_at(false, Some(×), None, &noon), Opening::Unknown(UnknownReason::NoTimeZone));
assert_eq!(
is_open_at(false, Some(×), Some("Europe/Berlin"), &noon),
Opening::Unknown(UnknownReason::MalformedTimeZone)
);
assert_eq!(
is_open_at(false, None, Some("UTC+00:00"), &noon),
Opening::Unknown(UnknownReason::NoOpeningTimes)
);
assert_eq!(
is_open_at(false, Some(&vec![]), Some("UTC+00:00"), &noon),
Opening::Unknown(UnknownReason::NoOpeningTimes)
);
}
#[test]
fn a_malformed_period_is_unknown_not_closed() {
let times = vec![OpeningTimes {
period: vec![Period {
begin: HourMinute::new_unchecked("not a time"),
end: HourMinute::new_unchecked("18:00"),
}],
on: DaySelection::Everyday,
extensions: Extensions::new(),
}];
assert_eq!(
is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at("12:00")),
Opening::Unknown(UnknownReason::MalformedPeriod)
);
}
#[test]
fn offsets_are_parsed_exactly() {
assert_eq!(parse_offset(Some("UTC+01:00")).unwrap(), UtcOffset::from_hms(1, 0, 0).unwrap());
assert_eq!(parse_offset(Some("UTC-05:30")).unwrap(), UtcOffset::from_hms(-5, -30, 0).unwrap());
assert_eq!(parse_offset(Some("UTC+00:00")).unwrap(), UtcOffset::UTC);
assert_eq!(parse_offset(Some("UTC+14:00")).unwrap(), UtcOffset::from_hms(14, 0, 0).unwrap());
assert_eq!(parse_offset(Some("UTC-14:00")).unwrap(), UtcOffset::from_hms(-14, 0, 0).unwrap());
assert_eq!(parse_offset(Some("UTC+05:59")).unwrap(), UtcOffset::from_hms(5, 59, 0).unwrap());
for bad in ["UTC+1:00", "GMT+01:00", "UTC+01-00", "UTC+99:00", "+01:00", "", "UTC+15:00", "UTC+05:60"]
{
assert!(parse_offset(Some(bad)).is_err(), "{bad} should not parse");
}
assert_eq!(parse_offset(None), Err(UnknownReason::NoTimeZone));
}
#[test]
fn every_named_day_selects_its_own_day() {
let days = [
(DaySelection::Monday, "2026-08-31"),
(DaySelection::Tuesday, "2026-09-01"),
(DaySelection::Wednesday, "2026-09-02"),
(DaySelection::Thursday, "2026-09-03"),
(DaySelection::Friday, "2026-09-04"),
(DaySelection::Saturday, "2026-09-05"),
(DaySelection::Sunday, "2026-09-06"),
];
for (selection, its_day) in &days {
let times = vec![window(selection.clone(), "08:00", "18:00")];
for (_, other_day) in &days {
let at: DateTime = format!("{other_day}T12:00:00.000Z").parse().expect("valid");
let answer = is_open_at(false, Some(×), Some("UTC+00:00"), &at);
let expected = if other_day == its_day { Opening::Open } else { Opening::Closed };
assert_eq!(answer, expected, "{selection:?} on {other_day}");
}
}
}
#[test]
fn the_three_answers_are_distinguishable() {
let times = vec![window(DaySelection::Everyday, "08:00", "18:00")];
let open = is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at("12:00"));
let closed = is_open_at(false, Some(×), Some("UTC+00:00"), &monday_at("03:00"));
let unknown = is_open_at(false, Some(×), None, &monday_at("12:00"));
assert!(open.is_open() && !open.is_closed() && !open.is_unknown());
assert!(closed.is_closed() && !closed.is_open() && !closed.is_unknown());
assert!(unknown.is_unknown() && !unknown.is_open() && !unknown.is_closed());
}
}