use std::convert::Infallible;
use chrono::{DateTime, NaiveDate, Utc};
use chrono_tz::Tz;
use crate::calendar::coverage::{CalendarCoverage, CoverageGapReason, DateCoverage};
use crate::calendar::exchange_calendar::ExchangeCalendar;
use crate::calendar::hours::MarketHours;
use crate::calendar::local_time::{bounded_utc, mk_local_open};
use crate::calendar::{CalendarQueryError, CalendarSource, SUPPORT_FLOOR};
use super::schedule::ResolvedHours;
const OPEN_DAY_ANCHOR_SSM: u32 = 86_399;
pub(in crate::calendar) trait SourceGate: Copy {
type Source<'a>: Copy;
type Coverage: Copy;
type Error;
fn identity(source: Self::Source<'_>) -> Option<CalendarSource>;
fn profile_for_open_day(source: Self::Source<'_>, tz: Tz, day: NaiveDate) -> ResolvedHours<'_>;
fn has_daily_close_at(source: Self::Source<'_>, instant: DateTime<Utc>) -> bool;
fn has_weekend_close_at(source: Self::Source<'_>, instant: DateTime<Utc>) -> bool;
fn require_answerable(coverage: Self::Coverage, date: NaiveDate) -> Result<(), Self::Error>;
fn require_floor(coverage: Self::Coverage, date: NaiveDate) -> Result<(), Self::Error>;
fn require_floor_at(
coverage: Self::Coverage,
tz: Tz,
instant: DateTime<Utc>,
) -> Result<(), Self::Error>;
fn require_phase_coverage(coverage: Self::Coverage, date: NaiveDate)
-> Result<(), Self::Error>;
fn require_holiday_classification(
coverage: Self::Coverage,
date: NaiveDate,
) -> Result<(), Self::Error>;
fn has_unscoped_refusing_phase_gap_on(coverage: Self::Coverage, day: NaiveDate) -> bool;
fn search_exhausted(coverage: Self::Coverage, day: NaiveDate) -> Result<(), Self::Error>;
}
#[derive(Clone, Copy)]
pub(in crate::calendar) struct FixedSnapshot;
impl SourceGate for FixedSnapshot {
type Source<'a> = &'a MarketHours;
type Coverage = ();
type Error = Infallible;
fn identity(_source: &MarketHours) -> Option<CalendarSource> {
None
}
fn profile_for_open_day(
source: Self::Source<'_>,
_tz: Tz,
_day: NaiveDate,
) -> ResolvedHours<'_> {
ResolvedHours::Borrowed(source)
}
fn has_daily_close_at(source: &MarketHours, _instant: DateTime<Utc>) -> bool {
source.has_daily_close
}
fn has_weekend_close_at(source: &MarketHours, _instant: DateTime<Utc>) -> bool {
source.has_weekend_close
}
fn require_answerable(_coverage: (), _date: NaiveDate) -> Result<(), Infallible> {
Ok(())
}
fn require_floor(_coverage: (), _date: NaiveDate) -> Result<(), Infallible> {
Ok(())
}
fn require_floor_at(_coverage: (), _tz: Tz, _instant: DateTime<Utc>) -> Result<(), Infallible> {
Ok(())
}
fn require_phase_coverage(_coverage: (), _date: NaiveDate) -> Result<(), Infallible> {
Ok(())
}
fn require_holiday_classification(_coverage: (), _date: NaiveDate) -> Result<(), Infallible> {
Ok(())
}
fn has_unscoped_refusing_phase_gap_on(_coverage: (), _day: NaiveDate) -> bool {
false
}
fn search_exhausted(_coverage: (), _day: NaiveDate) -> Result<(), Infallible> {
Ok(())
}
}
#[derive(Clone, Copy)]
pub(in crate::calendar) struct Identified;
impl SourceGate for Identified {
type Source<'a> = ExchangeCalendar;
type Coverage = CalendarCoverage;
type Error = CalendarQueryError;
fn identity(source: ExchangeCalendar) -> Option<CalendarSource> {
Some(source.source())
}
fn profile_for_open_day(
calendar: Self::Source<'_>,
tz: Tz,
day: NaiveDate,
) -> ResolvedHours<'_> {
let anchor = mk_local_open(tz, day, OPEN_DAY_ANCHOR_SSM).with_timezone(&Utc);
ResolvedHours::Selected(calendar.hours_at(anchor))
}
fn has_daily_close_at(calendar: ExchangeCalendar, instant: DateTime<Utc>) -> bool {
calendar.hours_at(instant).has_daily_close
}
fn has_weekend_close_at(calendar: ExchangeCalendar, instant: DateTime<Utc>) -> bool {
calendar.hours_at(instant).has_weekend_close
}
fn require_answerable(
coverage: CalendarCoverage,
date: NaiveDate,
) -> Result<(), CalendarQueryError> {
if date < SUPPORT_FLOOR {
return Ok(());
}
let verdict = match coverage.date_level_gap_on(date) {
None => DateCoverage::Covered,
Some(CoverageGapReason::WithheldDate) => DateCoverage::UnresolvedGap,
Some(CoverageGapReason::NormalWeekOnly) => DateCoverage::NormalWeekOnly,
Some(_) => DateCoverage::OutsideCoveredRange,
};
match verdict {
DateCoverage::Covered => Ok(()),
DateCoverage::NormalWeekOnly => {
let sourced = coverage.sourced_normal_week();
if date >= sourced.first() {
Ok(())
} else {
Err(CalendarQueryError::OutsideCoveredRange {
source: coverage.identity(),
date,
})
}
}
DateCoverage::BeforeSupportFloor => Err(CalendarQueryError::BeforeSupportFloor {
source: coverage.identity(),
date,
}),
DateCoverage::UnresolvedGap => Err(CalendarQueryError::UnresolvedGap {
source: coverage.identity(),
date,
}),
DateCoverage::OutsideCoveredRange => Err(CalendarQueryError::OutsideCoveredRange {
source: coverage.identity(),
date,
}),
}
}
fn require_floor(
coverage: CalendarCoverage,
date: NaiveDate,
) -> Result<(), CalendarQueryError> {
if date < SUPPORT_FLOOR {
return Err(CalendarQueryError::BeforeSupportFloor {
source: coverage.identity(),
date,
});
}
Ok(())
}
fn require_floor_at(
coverage: CalendarCoverage,
tz: Tz,
instant: DateTime<Utc>,
) -> Result<(), CalendarQueryError> {
let local_day = bounded_utc(instant, tz).with_timezone(&tz).date_naive();
Self::require_floor(coverage, local_day)
}
fn require_phase_coverage(
coverage: CalendarCoverage,
date: NaiveDate,
) -> Result<(), CalendarQueryError> {
if date < SUPPORT_FLOOR {
return Err(CalendarQueryError::BeforeSupportFloor {
source: coverage.identity(),
date,
});
}
Self::require_answerable(coverage, date)?;
match coverage.phase_gap_on(date) {
None => Ok(()),
Some(gap)
if matches!(
gap.reason(),
CoverageGapReason::PostCloseQueueTradeDateLabel
| CoverageGapReason::UnpublishedClosureDates
) =>
{
Ok(())
}
Some(_) => Err(CalendarQueryError::OutsideCoveredRange {
source: coverage.identity(),
date,
}),
}
}
fn require_holiday_classification(
coverage: CalendarCoverage,
date: NaiveDate,
) -> Result<(), CalendarQueryError> {
if coverage.holiday_classification_refused_on(date) {
return Err(CalendarQueryError::UnresolvedGap {
source: coverage.identity(),
date,
});
}
Ok(())
}
fn has_unscoped_refusing_phase_gap_on(coverage: CalendarCoverage, day: NaiveDate) -> bool {
coverage.has_unscoped_refusing_phase_gap_on(day)
}
fn search_exhausted(
coverage: CalendarCoverage,
day: NaiveDate,
) -> Result<(), CalendarQueryError> {
Err(CalendarQueryError::SearchExhausted {
source: coverage.identity(),
date: day,
bound: day,
})
}
}
pub(in crate::calendar) fn answered<T>(result: Result<T, Infallible>) -> T {
match result {
Ok(answer) => answer,
}
}