Parse iCalendar RRULE and Recurrence Data into Typed Rust Enums

use crate::types::{Frequency, RRule, Weekday};
use std::collections::HashMap;

#[derive(Debug, PartialEq, Eq)]
pub enum ParseError {
    MissingKey(&'static str),
    UnknownToken(String),
    InvalidInteger(String),
}

fn parse_byday(raw: &str) -> Result<Vec<Weekday>, ParseError> {
    raw.split(',')
        .map(|tok| tok.parse::<Weekday>().map_err(|_| ParseError::UnknownToken(tok.to_string())))
        .collect()
}

pub fn parse_rrule(value: &str) -> Result<RRule, ParseError> {
    let mut params: HashMap<&str, &str> = HashMap::new();
    for part in value.split(';') {
        if part.is_empty() {
            continue;
        }
        let (key, val) = part.split_once('=').ok_or(ParseError::MissingKey("="))?;
        params.insert(key, val);
    }

    let freq_raw = params.get("FREQ").ok_or(ParseError::MissingKey("FREQ"))?;
    let freq = freq_raw
        .parse::<Frequency>()
        .map_err(|_| ParseError::UnknownToken(freq_raw.to_string()))?;

    let interval = match params.get("INTERVAL") {
        Some(v) => v.parse::<u32>().map_err(|_| ParseError::InvalidInteger(v.to_string()))?,
        None => 1,
    };

    let count = match params.get("COUNT") {
        Some(v) => Some(v.parse::<u32>().map_err(|_| ParseError::InvalidInteger(v.to_string()))?),
        None => None,
    };

    let until = params.get("UNTIL").map(|v| v.to_string());
    let by_day = match params.get("BYDAY") {
        Some(v) => parse_byday(v)?,
        None => Vec::new(),
    };

    Ok(RRule { freq, interval, count, until, by_day })
}

mod parser;
mod types;

use parser::{parse_rrule, ParseError};
use types::RRule;

fn parse_ical(input: &str) -> Result<Vec<RRule>, ParseError> {
    let mut rules = Vec::new();
    for line in input.lines() {
        let line = line.trim();
        if let Some(rest) = line.strip_prefix("RRULE:") {
            rules.push(parse_rrule(rest)?);
        }
    }
    Ok(rules)
}

fn main() -> Result<(), ParseError> {
    let ics = "\
BEGIN:VEVENT
SUMMARY:Team standup
RRULE:FREQ=WEEKLY;INTERVAL=2;BYDAY=MO,WE;COUNT=10
END:VEVENT";

    for rule in parse_ical(ics)? {
        print!("{:?} every {} unit(s)", rule.freq, rule.interval);
        if !rule.by_day.is_empty() {
            print!(" on {:?}", rule.by_day);
        }
        match (rule.count, rule.until.as_deref()) {
            (Some(n), _) => println!(", {} times", n),
            (None, Some(d)) => println!(", until {}", d),
            (None, None) => println!(", forever"),
        }
    }
    Ok(())
}