use chrono::{DateTime, Datelike, Duration, NaiveDate, Utc};
use chrono_tz::Tz;
use super::gate::SourceGate;
use super::periods::next_daily_close_after_with;
use super::schedule::QueryContext;
use super::sessions::{
containing_session_with, contains_in_session_on, next_session_after_with,
previous_session_before_with,
};
use crate::calendar::SessionState;
use crate::calendar::local_time::{bounded_utc, mk_local_open};
use crate::calendar::rule::SessionKind;
const MAX_MAINTENANCE_GAP: Duration = Duration::hours(4);
pub(in crate::calendar) fn is_open_with<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
kind: SessionKind,
) -> Result<bool, G::Error> {
let day = bounded_utc(instant, context.tz())
.with_timezone(&context.tz())
.date_naive();
let open = contains_in_session_on(context, instant, day, kind)?;
context.require_floor(day)?;
Ok(open)
}
pub(in crate::calendar) fn is_order_entry_only<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<bool, G::Error> {
Ok(!is_open_with(context, instant, SessionKind::Both)?
&& context.contains_order_entry(instant)?)
}
pub(in crate::calendar) fn is_accepting_orders<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<bool, G::Error> {
Ok(is_open_with(context, instant, SessionKind::Both)?
|| context.contains_order_entry(instant)?)
}
pub(in crate::calendar) fn is_maintenance<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<bool, G::Error> {
Ok(session_state(context, instant)? == SessionState::Maintenance)
}
pub(in crate::calendar) fn trade_date<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<Option<NaiveDate>, G::Error> {
let Some(day) = resolve_trade_date(context, instant)? else {
context.require_floor_at(instant)?;
return Ok(None);
};
context.require_floor(day)?;
Ok(Some(day))
}
fn resolve_trade_date<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<Option<NaiveDate>, G::Error> {
if let Some((open, _session_close)) =
containing_session_with(context, instant, SessionKind::Both)?
{
let Some(close) = next_daily_close_after_with(context, instant, SessionKind::Both)? else {
return Ok(None);
};
return Ok(Some(context.trade_date_for_bounds(open, close)));
}
if context.contains_order_entry(instant)? {
let Some((open, _next_close)) =
next_session_after_with(context, instant, SessionKind::Both)?
else {
return Ok(None);
};
let Some(close) = next_daily_close_after_with(context, open, SessionKind::Both)? else {
return Ok(None);
};
return Ok(Some(context.trade_date_for_bounds(open, close)));
}
Ok(None)
}
pub(in crate::calendar) fn session_state<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
) -> Result<SessionState, G::Error> {
context.require_floor_at(instant)?;
if is_open_with(context, instant, SessionKind::Regular)? {
return Ok(SessionState::OpenRegular);
}
if is_open_with(context, instant, SessionKind::Extended)? {
return Ok(SessionState::OpenExtended);
}
if context.contains_order_entry(instant)? {
return Ok(SessionState::OrderEntry);
}
let Some((_previous_open, previous_close)) =
previous_session_before_with(context, instant, SessionKind::Both)?
else {
return Ok(SessionState::Closed);
};
let Some((next_open, _next_close)) =
next_session_after_with(context, instant, SessionKind::Both)?
else {
return Ok(SessionState::Closed);
};
let gap = next_open - previous_close;
if gap <= MAX_MAINTENANCE_GAP && !context.has_weekend_close_at(instant) {
return Ok(SessionState::Maintenance);
}
let Some(previous_probe) = previous_close.checked_sub_signed(Duration::nanoseconds(1)) else {
return Ok(SessionState::Closed);
};
let (Some(previous_trade_date), Some(next_trade_date)) = (
trade_date(context, previous_probe)?,
trade_date(context, next_open)?,
) else {
return Ok(SessionState::Closed);
};
if previous_trade_date == next_trade_date {
return Ok(SessionState::Closed);
}
let same_week = previous_trade_date.iso_week() == next_trade_date.iso_week();
if same_week && gap <= MAX_MAINTENANCE_GAP {
Ok(SessionState::Maintenance)
} else {
Ok(SessionState::Closed)
}
}
pub(in crate::calendar) fn is_closed_trade_date<G: SourceGate>(
context: &QueryContext<'_, G>,
day: NaiveDate,
kind: SessionKind,
) -> Result<bool, G::Error> {
context.require_floor(day)?;
super::periods::trade_date_classification(context, day, kind)
}
pub(in crate::calendar) fn is_closed_all_day_in_calendar<G: SourceGate>(
context: &QueryContext<'_, G>,
day: NaiveDate,
calendar_tz: Tz,
kind: SessionKind,
) -> Result<bool, G::Error> {
context.require_floor(day)?;
let start = mk_local_open(calendar_tz, day, 0).with_timezone(&Utc);
let end = day.succ_opt().map_or(DateTime::<Utc>::MAX_UTC, |next| {
mk_local_open(calendar_tz, next, 0).with_timezone(&Utc)
});
if start >= end {
return Ok(true);
}
if is_open_with(context, start, kind)? {
return Ok(false);
}
Ok(next_session_after_with(context, start, kind)?
.is_none_or(|(next_open, _close)| next_open >= end))
}
pub(in crate::calendar) fn is_closed_all_day_at<G: SourceGate>(
context: &QueryContext<'_, G>,
instant: DateTime<Utc>,
calendar_tz: Tz,
kind: SessionKind,
) -> Result<bool, G::Error> {
let day = bounded_utc(instant, calendar_tz)
.with_timezone(&calendar_tz)
.date_naive();
is_closed_all_day_in_calendar(context, day, calendar_tz, kind)
}