use chrono::{DateTime, Duration, NaiveDate, Utc};
use super::gate::SourceGate;
use super::schedule::{QueryContext, RuleSet};
use crate::calendar::exceptions::{DateException, ExceptionBlock, ExceptionBlockKind};
use crate::calendar::local_time::{bounded_utc, mk_local_close, mk_local_open};
use crate::calendar::rule::SessionKind;
const SECONDS_PER_DAY: u32 = 86_400;
pub(super) enum ExceptionDailyClose {
NotGoverned,
NoSession,
Close(DateTime<Utc>),
}
pub(super) fn is_tradeable(block: ExceptionBlock) -> bool {
matches!(
block.kind(),
ExceptionBlockKind::Regular | ExceptionBlockKind::Extended
)
}
fn selects(block: ExceptionBlock, set: RuleSet) -> bool {
match set {
RuleSet::OrderEntry => matches!(block.kind(), ExceptionBlockKind::OrderEntry),
RuleSet::Sessions(SessionKind::Regular) => {
matches!(block.kind(), ExceptionBlockKind::Regular)
}
RuleSet::Sessions(SessionKind::Extended) => {
matches!(block.kind(), ExceptionBlockKind::Extended)
}
RuleSet::Sessions(SessionKind::Both) => is_tradeable(block),
}
}
fn opening_day(trade_date: NaiveDate, block: ExceptionBlock) -> Option<NaiveDate> {
trade_date.checked_add_signed(Duration::days(i64::from(block.open_day_offset())))
}
fn late_open_day(trade_date: NaiveDate, blocks: &[ExceptionBlock], ssm: u32) -> NaiveDate {
let Some(first) = blocks.iter().copied().find(|block| is_tradeable(*block)) else {
return trade_date;
};
let Some(first_day) = opening_day(trade_date, first) else {
return trade_date;
};
if first_day < trade_date && ssm >= first.open_ssm() {
first_day
} else {
trade_date
}
}
pub(super) fn resolve_block_bounds<G: SourceGate>(
context: &QueryContext<'_, G>,
trade_date: NaiveDate,
blocks: &[ExceptionBlock],
block: ExceptionBlock,
) -> Option<(DateTime<Utc>, DateTime<Utc>)> {
let open_day = opening_day(trade_date, block)?;
let close_day = if block.wraps_to_next_day() {
open_day.succ_opt()?
} else {
open_day
};
let tz = context.tz();
let raw_open = mk_local_open(tz, open_day, block.open_ssm()).with_timezone(&Utc);
let raw_close = mk_local_close(tz, close_day, block.close_ssm()).with_timezone(&Utc);
if raw_open >= raw_close {
return None;
}
if !context.has_daily_close_at(raw_open) {
return None;
}
let Some(policy) = context.policy() else {
return Some((raw_open, raw_close));
};
if policy.is_closed(trade_date) {
return None;
}
let mut open = raw_open;
let mut close = raw_close;
if let Some(ssm) = policy.early_close_ssm(trade_date) {
if ssm > SECONDS_PER_DAY {
return None;
}
close = close.min(mk_local_close(tz, trade_date, ssm).with_timezone(&Utc));
}
if let Some(ssm) = policy.late_open_ssm(trade_date) {
if ssm >= SECONDS_PER_DAY {
return None;
}
let cutoff_day = late_open_day(trade_date, blocks, ssm);
open = open.max(mk_local_open(tz, cutoff_day, ssm).with_timezone(&Utc));
}
(open < close).then_some((open, close))
}
pub(super) fn find_occurrence<G: SourceGate, T>(
context: &QueryContext<'_, G>,
open_day: NaiveDate,
set: RuleSet,
wrapped_only: bool,
mut probe: impl FnMut(DateTime<Utc>, DateTime<Utc>) -> Option<T>,
) -> Option<T> {
if !context.has_replacement_layer() {
return None;
}
let reach_last =
open_day.checked_add_signed(Duration::days(i64::from(-ExceptionBlock::MIN_DAY_OFFSET)))?;
if !context.replacement_blocks_may_reach(open_day, reach_last) {
return None;
}
let mut offset = ExceptionBlock::MIN_DAY_OFFSET;
while offset <= ExceptionBlock::MAX_DAY_OFFSET {
if let Some(trade_date) = open_day.checked_sub_signed(Duration::days(i64::from(offset)))
&& let DateException::ReplaceSessions(blocks) = context.exception_on(trade_date)
{
for block in blocks.iter().copied().filter(|block| {
block.open_day_offset() == offset
&& selects(*block, set)
&& (!wrapped_only || block.wraps_to_next_day())
}) {
if let Some((open, close)) =
resolve_block_bounds(context, trade_date, blocks, block)
&& let Some(found) = probe(open, close)
{
return Some(found);
}
}
}
offset += 1;
}
None
}
pub(super) fn governs_instant<G: SourceGate>(
context: &QueryContext<'_, G>,
window: (DateTime<Utc>, DateTime<Utc>),
set: RuleSet,
open_day: chrono::NaiveDate,
wraps: bool,
) -> bool {
if !context.has_replacement_layer() {
return false;
}
let Some(reach_first) =
open_day.checked_sub_signed(Duration::days(i64::from(-ExceptionBlock::MIN_DAY_OFFSET)))
else {
return false;
};
let Some(reach_last) = open_day.checked_add_signed(Duration::days(7 + i64::from(wraps))) else {
return false;
};
if !context.replacement_blocks_may_reach(reach_first, reach_last) {
return false;
}
let (window_open, window_close) = window;
let tz = context.tz();
let first_day = bounded_utc(window_open, tz).with_timezone(&tz).date_naive();
let last_day = bounded_utc(window_close, tz)
.with_timezone(&tz)
.date_naive();
let Some(first_trade_date) =
first_day.checked_add_signed(Duration::days(i64::from(ExceptionBlock::MIN_DAY_OFFSET)))
else {
return false;
};
let Some(last_trade_date) =
last_day.checked_sub_signed(Duration::days(i64::from(ExceptionBlock::MIN_DAY_OFFSET)))
else {
return false;
};
let mut trade_date = first_trade_date;
loop {
if let DateException::ReplaceSessions(blocks) = context.exception_on(trade_date) {
let span = trade_date
.signed_duration_since(first_day)
.num_days()
.clamp(0, i64::from(-ExceptionBlock::MIN_DAY_OFFSET));
let mut offset = -i8::try_from(span).unwrap_or(ExceptionBlock::MIN_DAY_OFFSET);
while offset <= ExceptionBlock::MAX_DAY_OFFSET {
for block in blocks
.iter()
.copied()
.filter(|block| block.open_day_offset() == offset && selects(*block, set))
{
if let Some((block_open, block_close)) =
resolve_block_bounds(context, trade_date, blocks, block)
&& block_open < window_close
&& block_close > window_open
{
return true;
}
}
offset += 1;
}
}
if trade_date >= last_trade_date {
return false;
}
let Some(next) = trade_date.succ_opt() else {
return false;
};
trade_date = next;
}
}
pub(super) fn replacement_trade_date<G: SourceGate>(
context: &QueryContext<'_, G>,
open: DateTime<Utc>,
) -> Option<NaiveDate> {
if !context.has_replacement_layer() {
return None;
}
let tz = context.tz();
let local_day = bounded_utc(open, tz).with_timezone(&tz).date_naive();
let mut offset = ExceptionBlock::MIN_DAY_OFFSET;
while offset <= ExceptionBlock::MAX_DAY_OFFSET {
if let Some(trade_date) = local_day.checked_sub_signed(Duration::days(i64::from(offset)))
&& let DateException::ReplaceSessions(blocks) = context.exception_on(trade_date)
{
for block in blocks
.iter()
.copied()
.filter(|block| block.open_day_offset() == offset && is_tradeable(*block))
{
if resolve_block_bounds(context, trade_date, blocks, block)
.is_some_and(|(block_open, _close)| block_open == open)
{
return Some(trade_date);
}
}
}
offset += 1;
}
None
}
pub(super) fn daily_close<G: SourceGate>(
context: &QueryContext<'_, G>,
trade_date: NaiveDate,
kind: SessionKind,
) -> ExceptionDailyClose {
let opening_midnight = mk_local_open(context.tz(), trade_date, 0).with_timezone(&Utc);
if !context.has_daily_close_at(opening_midnight) {
return ExceptionDailyClose::NotGoverned;
}
match context.exception_on(trade_date) {
DateException::Closed => ExceptionDailyClose::NoSession,
DateException::ReplaceSessions(blocks) => {
let mut latest: Option<DateTime<Utc>> = None;
for block in blocks
.iter()
.copied()
.filter(|block| selects(*block, RuleSet::Sessions(kind)))
{
if let Some((_open, close)) =
resolve_block_bounds(context, trade_date, blocks, block)
&& latest.is_none_or(|current| close > current)
{
latest = Some(close);
}
}
latest.map_or(ExceptionDailyClose::NoSession, ExceptionDailyClose::Close)
}
DateException::KnownNormal | DateException::OutOfCoverage => {
ExceptionDailyClose::NotGoverned
}
}
}