//! Five-field cron lines for `on { schedule "…" }` (oxygenflow#24):

//! minute, hour, day of month, month, day of week (0 or 7 is Sunday), each

//! `*`, a number, a range `a-b`, a list `a,b`, or any of those `/step`.

//! The hub checks each minute which lines are due.

/// A parsed line: the values each field allows.

#[derive(Clone, Debug, PartialEq, Eq)]

pub struct Cron {

    minute: Vec<bool>,

    hour: Vec<bool>,

    day: Vec<bool>,

    month: Vec<bool>,

    weekday: Vec<bool>,

    /// Both day fields restricted: either may match, as cron has it.

    either_day: bool,

}

fn field(text: &str, lo: u32, hi: u32) -> Option<(Vec<bool>, bool)> {

    let mut allowed = vec![false; hi as usize + 1];

    let star = text == "*";

    for part in text.split(',') {

        let (range, step) = match part.split_once('/') {

            Some((r, s)) => (r, s.parse::<u32>().ok().filter(|s| *s > 0)?),

            None => (part, 1),

        };

        let (a, b) = if range == "*" {

            (lo, hi)

        } else if let Some((a, b)) = range.split_once('-') {

            (a.parse().ok()?, b.parse().ok()?)

        } else {

            let a: u32 = range.parse().ok()?;

            // `5/15` is from 5 to the end, every 15.

            (a, if part.contains('/') { hi } else { a })

        };

        if a < lo || b > hi || a > b {

            return None;

        }

        let mut v = a;

        while v <= b {

            allowed[v as usize] = true;

            v += step;

        }

    }

    Some((allowed, star))

}

impl Cron {

    pub fn parse(line: &str) -> Option<Cron> {

        let f: Vec<&str> = line.split_whitespace().collect();

        let [m, h, d, mo, w] = f.as_slice() else { return None };

        let (minute, _) = field(m, 0, 59)?;

        let (hour, _) = field(h, 0, 23)?;

        let (day, day_star) = field(d, 1, 31)?;

        let (month, _) = field(mo, 1, 12)?;

        let (mut weekday, week_star) = field(w, 0, 7)?;

        if weekday[7] {

            weekday[0] = true;

        }

        Some(Cron { minute, hour, day, month, weekday, either_day: !day_star && !week_star })

    }

    /// Whether the line is due at this minute (UTC): `weekday` 0 is Sunday.

    pub fn matches(&self, minute: u32, hour: u32, day: u32, month: u32, weekday: u32) -> bool {

        let get = |v: &Vec<bool>, i: u32| v.get(i as usize).copied().unwrap_or(false);

        let (d, w) = (get(&self.day, day), get(&self.weekday, weekday % 7));

        let days = if self.either_day { d || w } else { d && w };

        get(&self.minute, minute) && get(&self.hour, hour) && get(&self.month, month) && days

    }

}

#[cfg(test)]

mod tests {

    use super::Cron;

    #[test]

    fn lines_parse_and_match_as_cron_does() {

        let nightly = Cron::parse("0 3 * * *").unwrap();

        assert!(nightly.matches(0, 3, 15, 6, 2));

        assert!(!nightly.matches(1, 3, 15, 6, 2));

        let quarter = Cron::parse("*/15 9-17 * * 1-5").unwrap();

        assert!(quarter.matches(45, 17, 2, 10, 5));

        assert!(!quarter.matches(50, 17, 2, 10, 5));

        assert!(!quarter.matches(0, 12, 3, 10, 6), "Saturday");

        let sunday = Cron::parse("30 4 * * 7").unwrap();

        assert!(sunday.matches(30, 4, 4, 10, 0));

        let either = Cron::parse("0 0 1 * 1").unwrap();

        assert!(either.matches(0, 0, 1, 10, 3) && either.matches(0, 0, 5, 10, 1), "the 1st or a Monday");

        for bad in ["", "* * * *", "60 * * * *", "* 24 * * *", "* * 0 * *", "*/0 * * * *", "a * * * *", "5-1 * * * *"] {

            assert!(Cron::parse(bad).is_none(), "{bad:?}");

        }

    }

}