use std::str::FromStr;
use chrono::{LocalResult, TimeZone};
use chrono_tz::Tz;
use cron::Schedule;
use crate::error::{NasaRedisError, Result};
use crate::job::definition::JobDefinition;
use crate::job::model::JobScheduleType;
pub const CRON_SEMANTICS_ID: &str = "spring-numeric-intersection";
pub const CRON_TZDB_VERSION: &str = chrono_tz::IANA_TZDB_VERSION;
pub fn next_fire_at(definition: &JobDefinition, logical_fire_at: i64) -> Result<i64> {
match definition.schedule_type() {
JobScheduleType::Cron => next_cron(definition.cron(), definition.zone(), logical_fire_at),
JobScheduleType::FixedRate | JobScheduleType::FixedDelay => {
let interval =
i64::try_from(definition.interval_ms()).map_err(|_| err("固定调度间隔超出 i64"))?;
logical_fire_at
.checked_add(interval)
.ok_or_else(|| err("固定间隔下一触发时刻溢出"))
}
JobScheduleType::Manual | JobScheduleType::FanoutOnly => Ok(0),
}
}
pub fn first_fire_at_after(
definition: &JobDefinition,
logical_fire_at: i64,
redis_now: i64,
) -> Result<i64> {
match definition.schedule_type() {
JobScheduleType::FixedRate => {
let interval =
i64::try_from(definition.interval_ms()).map_err(|_| err("固定速率间隔超出 i64"))?;
let distance = redis_now
.checked_sub(logical_fire_at)
.ok_or_else(|| err("固定速率逻辑时刻差溢出"))?;
let steps = distance.div_euclid(interval).saturating_add(1).max(1);
logical_fire_at
.checked_add(
interval
.checked_mul(steps)
.ok_or_else(|| err("固定速率跨度溢出"))?,
)
.ok_or_else(|| err("固定速率下一触发时刻溢出"))
}
JobScheduleType::FixedDelay => {
let interval =
i64::try_from(definition.interval_ms()).map_err(|_| err("固定延迟间隔超出 i64"))?;
redis_now
.checked_add(interval)
.ok_or_else(|| err("固定延迟下一触发时刻溢出"))
}
JobScheduleType::Cron => next_cron(
definition.cron(),
definition.zone(),
logical_fire_at.max(redis_now),
),
JobScheduleType::Manual | JobScheduleType::FanoutOnly => Ok(0),
}
}
pub fn validate_cron_compatibility(expr: &str, zone: &str) -> Result<()> {
normalize_cron(expr)?;
Tz::from_str(zone.trim()).map_err(|_| err(&format!("非法时区: {zone}")))?;
Ok(())
}
fn next_cron(expr: &str, zone: &str, from_millis: i64) -> Result<i64> {
let normalized = normalize_cron(expr)?;
let tz = Tz::from_str(zone).map_err(|_| err(&format!("非法时区: {zone}")))?;
let base = tz
.timestamp_millis_opt(from_millis)
.single()
.ok_or_else(|| err("cron 基准时刻无法在该时区唯一表示"))?;
let schedule = Schedule::from_str(&normalized)
.map_err(|error| err(&format!("非法 cron 表达式: {error}")))?;
if let Some(next) = next_match_inside_overlap(&schedule, tz, &base) {
return Ok(next.timestamp_millis());
}
let next = schedule
.after(&base)
.next()
.ok_or_else(|| err("cron 表达式无下一触发时刻"))?;
let next = match tz.from_local_datetime(&next.naive_local()) {
LocalResult::Ambiguous(earlier, _) if earlier > base => earlier,
LocalResult::Ambiguous(_, later) if later > base => later,
_ => next,
};
Ok(next.timestamp_millis())
}
fn next_match_inside_overlap(
schedule: &Schedule,
tz: Tz,
base: &chrono::DateTime<Tz>,
) -> Option<chrono::DateTime<Tz>> {
let LocalResult::Ambiguous(earlier, later) = tz.from_local_datetime(&base.naive_local()) else {
return None;
};
let overlap_ms = later
.timestamp_millis()
.checked_sub(earlier.timestamp_millis())?;
if overlap_ms <= 0 {
return None;
}
let first_second = base.timestamp_millis().div_euclid(1_000).checked_add(1)?;
let last_second = base
.timestamp_millis()
.checked_add(overlap_ms)?
.div_euclid(1_000);
for second in first_second..=last_second {
let candidate = tz.timestamp_opt(second, 0).single()?;
if schedule.includes(candidate) {
return Some(candidate);
}
}
None
}
fn normalize_cron(expr: &str) -> Result<String> {
let fields: Vec<&str> = expr.split_whitespace().collect();
if fields.len() != 6 {
return Err(err("cron 必须恰好包含六个字段"));
}
let bounds = [(0, 59), (0, 59), (0, 23), (1, 31), (1, 12)];
let mut normalized = Vec::with_capacity(6);
for (index, (field, (min, max))) in fields.iter().take(5).zip(bounds).enumerate() {
normalized.push(normalize_numeric_field(field, min, max, index == 3)?);
}
let day_of_month_any = matches!(fields[3], "*" | "?");
let day_of_week_any = matches!(fields[5], "*" | "?");
if !day_of_month_any && !day_of_week_any {
return Err(err("cron 日与星期不能同时受限"));
}
if fields[3] == "?" {
normalized[3] = "*".to_owned();
}
normalized.push(normalize_day_of_week(fields[5])?);
let normalized = normalized.join(" ");
Schedule::from_str(&normalized)
.map_err(|error| err(&format!("cron 交集表达式无法解析: {error}")))?;
Ok(normalized)
}
fn normalize_numeric_field(
field: &str,
min: u32,
max: u32,
allow_question: bool,
) -> Result<String> {
if field == "?" {
return if allow_question {
Ok("*".to_owned())
} else {
Err(err("cron 字段不允许 '?'"))
};
}
if field.is_empty()
|| !field
.bytes()
.all(|byte| byte.is_ascii_digit() || matches!(byte, b'*' | b',' | b'-' | b'/'))
{
return Err(err("cron 只允许数字、通配、列表、范围和步进"));
}
for item in field.split(',') {
let mut step_parts = item.split('/');
let base = step_parts.next().unwrap_or_default();
let step = step_parts.next();
if step_parts.next().is_some() {
return Err(err("cron 步进字段包含多个 '/'"));
}
if let Some(step) = step {
let step = parse_ordinal(step, 1, max.saturating_sub(min).saturating_add(1))?;
if step == 0 {
return Err(err("cron 步进必须大于零"));
}
}
if base == "*" {
continue;
}
if let Some((start, end)) = base.split_once('-') {
let start = parse_ordinal(start, min, max)?;
let end = parse_ordinal(end, min, max)?;
if start > end {
return Err(err("cron 范围起点不能晚于终点"));
}
} else {
parse_ordinal(base, min, max)?;
}
}
Ok(field.to_owned())
}
fn normalize_day_of_week(field: &str) -> Result<String> {
if matches!(field, "*" | "?") {
return Ok("*".to_owned());
}
let mut days = Vec::new();
for item in field.split(',') {
let spring = parse_ordinal(item, 0, 7)?;
let local = if spring == 0 || spring == 7 {
1
} else {
spring + 1
};
days.push(local);
}
days.sort_unstable();
days.dedup();
Ok(days
.into_iter()
.map(|day| day.to_string())
.collect::<Vec<_>>()
.join(","))
}
fn parse_ordinal(value: &str, min: u32, max: u32) -> Result<u32> {
let parsed = value
.parse::<u32>()
.map_err(|_| err("cron 数字字段无法解析"))?;
if !(min..=max).contains(&parsed) {
return Err(err("cron 数字字段越界"));
}
Ok(parsed)
}
fn err(message: &str) -> NasaRedisError {
crate::job::JobError::Config(format!("trigger {message}")).into()
}