Oxicloud/examples/bench_caldav_parse.rs

//! CalDAV parse-path benchmark — the write-side 8×-reparse and the
//! read-side per-event copies (ROUND4).
//!
//! What changed:
//!
//!   • `CalendarEvent::from_ical` funnelled each of its 8 property
//!     lookups through an extractor that re-ran the full `IcalParser`
//!     (line unfolding + component tree) over the whole body — 8
//!     complete parses per VEVENT on every CalDAV PUT, `8·(M+1)` on a
//!     master+M-exceptions PUT, `8·N` on an N-event import. Now: one
//!     parse, all lookups on the parsed component (value-only lookups
//!     also skip the parameter-map build).
//!   • `split_vevents` uppercased EVERY line into a fresh String.
//!     Now: allocation-free case-insensitive prefix tests.
//!   • `extract_vevent_chunk` (read side: every REPORT/GET, per event)
//!     allocated a full uppercase copy of the stored body just to find
//!     two tags. Now: memchr fast path + alloc-free CI scan fallback.
//!   • `group_events_by_uid` (read side, per REPORT) cloned every
//!     event's UID String. Now: borrowed keys.
//!
//! The OLD logic is copied verbatim into `mod before`; equivalence
//! gates assert byte-identical parsed fields / chunk slices / grouping
//! across a corpus incl. folded lines, params, VALARM, all-day,
//! exceptions and mixed-case tags (exit 1 on any diff).
//!
//! Run (no Postgres needed):
//!   cargo run --release --features bench --example bench_caldav_parse
//! Tunables (env):
//!   BENCH_EVENTS (200)  BENCH_PASSES (30)  BENCH_GROUP_N (5000)

use std::env;
use std::hint::black_box;
use std::time::Instant;

use chrono::{DateTime, TimeZone, Utc};
use oxicloud::application::adapters::caldav_adapter::bench as caldav_bench;
use oxicloud::application::dtos::calendar_dto::CalendarEventDto;
use oxicloud::domain::entities::calendar_event::CalendarEvent;
use uuid::Uuid;

// ─── BEFORE: verbatim copies of the pre-optimization logic ──────────────────

#[allow(clippy::all)]
mod before {
    use std::collections::HashMap;

    /// Old `parse_first_vevent` — fresh parser per call.
    pub fn parse_first_vevent(ical_data: &str) -> Option<ical::parser::ical::component::IcalEvent> {
        use std::io::BufReader;
        let reader = BufReader::new(ical_data.as_bytes());
        let parser = ical::IcalParser::new(reader);
        for cal in parser {
            let Ok(cal) = cal else { continue };
            if let Some(event) = cal.events.into_iter().next() {
                return Some(event);
            }
        }
        None
    }

    /// Old params-aware extractor — one FULL parse per property lookup.
    pub fn extract_ical_property_with_params(
        ical_data: &str,
        property_name: &str,
    ) -> Option<(String, HashMap<String, Vec<String>>)> {
        let event = parse_first_vevent(ical_data)?;
        let prop = event
            .properties
            .into_iter()
            .find(|p| p.name.eq_ignore_ascii_case(property_name))?;
        let value = prop.value?;
        if value.trim().is_empty() {
            return None;
        }
        let mut params: HashMap<String, Vec<String>> = HashMap::new();
        if let Some(param_list) = prop.params {
            for (name, values) in param_list {
                params.insert(name.to_ascii_uppercase(), values);
            }
        }
        Some((value.trim().to_string(), params))
    }

    pub fn extract_ical_property(ical_data: &str, property_name: &str) -> Option<String> {
        extract_ical_property_with_params(ical_data, property_name).map(|(v, _p)| v)
    }

    /// Comparable subset of the entity fields `from_ical` derives.
    #[derive(Debug, PartialEq)]
    pub struct BeforeEvent {
        pub summary: String,
        pub description: Option<String>,
        pub location: Option<String>,
        pub start_time: chrono::DateTime<chrono::Utc>,
        pub end_time: chrono::DateTime<chrono::Utc>,
        pub all_day: bool,
        pub rrule: Option<String>,
        pub ical_uid: Option<String>,
        pub recurrence_id: Option<chrono::DateTime<chrono::Utc>>,
    }

    /// Old `from_ical` body (8 extractor calls = 8 full parses), minus
    /// the entity envelope (ids/timestamps — identical on both sides).
    pub fn from_ical(ical_data: &str) -> Result<BeforeEvent, String> {
        let summary = extract_ical_property(ical_data, "SUMMARY").ok_or("Missing SUMMARY")?;
        let (dtstart_value, dtstart_params) =
            extract_ical_property_with_params(ical_data, "DTSTART").ok_or("Missing DTSTART")?;
        let (dtend_value, _dtend_params) =
            extract_ical_property_with_params(ical_data, "DTEND").ok_or("Missing DTEND")?;
        let all_day = dtstart_params
            .get("VALUE")
            .map(|vs| vs.iter().any(|v| v.eq_ignore_ascii_case("DATE")))
            .unwrap_or(false);
        let start_time = parse_ical_datetime(&dtstart_value, all_day)?;
        let end_time = parse_ical_datetime(&dtend_value, all_day)?;
        let description = extract_ical_property(ical_data, "DESCRIPTION");
        let location = extract_ical_property(ical_data, "LOCATION");
        let rrule = extract_ical_property(ical_data, "RRULE");
        let ical_uid = extract_ical_property(ical_data, "UID");
        let recurrence_id = match extract_ical_property_with_params(ical_data, "RECURRENCE-ID") {
            Some((value, params)) => {
                let is_date = params
                    .get("VALUE")
                    .map(|vs| vs.iter().any(|v| v.eq_ignore_ascii_case("DATE")))
                    .unwrap_or(false);
                parse_ical_datetime(&value, is_date).ok()
            }
            None => None,
        };
        Ok(BeforeEvent {
            summary,
            description,
            location,
            start_time,
            end_time,
            all_day,
            rrule,
            ical_uid,
            recurrence_id,
        })
    }

    /// Old datetime parser (verbatim semantics for the two supported forms).
    pub fn parse_ical_datetime(
        value: &str,
        is_date_only: bool,
    ) -> Result<chrono::DateTime<chrono::Utc>, String> {
        use chrono::TimeZone;
        if is_date_only {
            if value.len() != 8 {
                return Err("bad all-day".into());
            }
            let year: i32 = value[0..4].parse().map_err(|_| "year")?;
            let month: u32 = value[4..6].parse().map_err(|_| "month")?;
            let day: u32 = value[6..8].parse().map_err(|_| "day")?;
            return chrono::NaiveDate::from_ymd_opt(year, month, day)
                .map(|d| chrono::Utc.from_utc_datetime(&d.and_hms_opt(0, 0, 0).unwrap()))
                .ok_or_else(|| "date".into());
        }
        if value.len() < 15 || !value.ends_with('Z') {
            return Err(format!("bad datetime {value:?}"));
        }
        let year: i32 = value[0..4].parse().map_err(|_| "year")?;
        let month: u32 = value[4..6].parse().map_err(|_| "month")?;
        let day: u32 = value[6..8].parse().map_err(|_| "day")?;
        let hour: u32 = value[9..11].parse().map_err(|_| "hour")?;
        let minute: u32 = value[11..13].parse().map_err(|_| "minute")?;
        let second: u32 = value[13..15].parse().map_err(|_| "second")?;
        match chrono::NaiveDate::from_ymd_opt(year, month, day) {
            Some(date) => match date.and_hms_opt(hour, minute, second) {
                Some(datetime) => Ok(chrono::Utc.from_utc_datetime(&datetime)),
                None => Err("time".into()),
            },
            None => Err("date".into()),
        }
    }

    /// Old `split_vevents` — per-line uppercase String.
    pub fn split_vevents(ical_data: &str) -> Vec<String> {
        let mut blocks = Vec::new();
        let mut in_event = false;
        let mut current = String::new();
        for raw_line in ical_data.split('\n') {
            let line = raw_line.trim_end_matches('\r');
            let upper = line.trim_start().to_ascii_uppercase();
            if upper.starts_with("BEGIN:VEVENT") {
                in_event = true;
                current.clear();
            }
            if in_event {
                current.push_str(line);
                current.push_str("\r\n");
            }
            if in_event && upper.starts_with("END:VEVENT") {
                blocks.push(std::mem::take(&mut current));
                in_event = false;
            }
        }
        blocks
    }

    /// Old `extract_vevent_chunk` — full uppercase copy of the body.
    pub fn extract_vevent_chunk(ical_data: &str) -> Option<&str> {
        let upper = ical_data.to_ascii_uppercase();
        let begin = upper.find("BEGIN:VEVENT")?;
        let after_begin = &upper[begin..];
        let rel_end = after_begin.find("END:VEVENT")?;
        let end_tag_end = begin + rel_end + "END:VEVENT".len();
        let mut end = end_tag_end;
        if ical_data[end..].starts_with('\r') {
            end += 1;
        }
        if ical_data[end..].starts_with('\n') {
            end += 1;
        }
        Some(&ical_data[begin..end])
    }

    /// Old `group_events_by_uid` — String-keyed map, UID cloned per event.
    pub fn group_events_by_uid<'a>(
        events: &'a [oxicloud::application::dtos::calendar_dto::CalendarEventDto],
    ) -> Vec<Vec<&'a oxicloud::application::dtos::calendar_dto::CalendarEventDto>> {
        let mut order: Vec<String> = Vec::new();
        let mut buckets: HashMap<
            String,
            Vec<&'a oxicloud::application::dtos::calendar_dto::CalendarEventDto>,
        > = HashMap::new();
        for event in events {
            let key = event.ical_uid.clone();
            if !buckets.contains_key(&key) {
                order.push(key.clone());
            }
            buckets.entry(key).or_default().push(event);
        }
        let mut out = Vec::with_capacity(order.len());
        for uid in order {
            let mut bucket = buckets.remove(&uid).unwrap_or_default();
            bucket.sort_by_key(|e| e.recurrence_id.is_some());
            out.push(bucket);
        }
        out
    }
}

// ─── Corpus ─────────────────────────────────────────────────────────────────

/// A realistic ~1.3 KiB VEVENT: params on DTSTART, folded DESCRIPTION,
/// three ATTENDEEs with CN/PARTSTAT, ORGANIZER, VALARM, CATEGORIES,
/// STATUS and X-props. `variant` 0 = timed master with RRULE, 1 = all-day,
/// 2 = exception override (RECURRENCE-ID).
fn build_vevent_body(i: usize, variant: usize) -> String {
    let uid = format!("evt-{i:05}@oxicloud.bench");
    let mut v = String::with_capacity(1400);
    v.push_str("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//OxiCloud//NONSGML Calendar//EN\r\n");
    v.push_str("BEGIN:VEVENT\r\n");
    v.push_str(&format!("UID:{uid}\r\n"));
    v.push_str("DTSTAMP:20260701T120000Z\r\n");
    match variant {
        1 => {
            v.push_str("DTSTART;VALUE=DATE:20260810\r\n");
            v.push_str("DTEND;VALUE=DATE:20260811\r\n");
        }
        2 => {
            v.push_str("DTSTART:20260812T090000Z\r\n");
            v.push_str("DTEND:20260812T100000Z\r\n");
            v.push_str("RECURRENCE-ID:20260812T090000Z\r\n");
        }
        _ => {
            v.push_str("DTSTART:20260805T090000Z\r\n");
            v.push_str("DTEND:20260805T103000Z\r\n");
            v.push_str("RRULE:FREQ=WEEKLY;BYDAY=TU,TH;UNTIL=20261231T000000Z\r\n");
        }
    }
    v.push_str(&format!(
        "SUMMARY:Sprint review #{i} — métricas y datos\r\n"
    ));
    v.push_str(
        "DESCRIPTION:Repaso de los objetivos del sprint con el equipo completo\\, in\r\n cluyendo demo de la nueva vista de fotos y el plan de la ronda de rendimien\r\n to número cuatro.\r\n",
    );
    v.push_str("LOCATION:Sala Turing — 3ª planta\r\n");
    v.push_str("ORGANIZER;CN=Ana García:mailto:ana@example.com\r\n");
    v.push_str(
        "ATTENDEE;CN=Luis Pérez;PARTSTAT=ACCEPTED;ROLE=REQ-PARTICIPANT:mailto:luis@example.com\r\n",
    );
    v.push_str("ATTENDEE;CN=Sam Chen;PARTSTAT=NEEDS-ACTION;RSVP=TRUE:mailto:sam@example.com\r\n");
    v.push_str("ATTENDEE;CN=Río Núñez;PARTSTAT=TENTATIVE:mailto:rio@example.com\r\n");
    v.push_str("CATEGORIES:TRABAJO,EQUIPO\r\n");
    v.push_str("STATUS:CONFIRMED\r\n");
    v.push_str("SEQUENCE:2\r\n");
    v.push_str("TRANSP:OPAQUE\r\n");
    v.push_str("X-OXICLOUD-ROUND:4\r\n");
    v.push_str("BEGIN:VALARM\r\nACTION:DISPLAY\r\nDESCRIPTION:Reminder\r\nTRIGGER:-PT15M\r\nEND:VALARM\r\n");
    v.push_str("END:VEVENT\r\n");
    v.push_str("END:VCALENDAR\r\n");
    v
}

/// N-event import body (master + exception pairs inside one VCALENDAR).
fn build_import_body(n_events: usize) -> String {
    let mut v = String::with_capacity(n_events * 1400);
    v.push_str("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//Foreign//Client//EN\r\n");
    for i in 0..n_events {
        let single = build_vevent_body(i, i % 3);
        // Extract just the VEVENT block from the standalone body.
        let begin = single.find("BEGIN:VEVENT").unwrap();
        let end = single.find("END:VEVENT").unwrap() + "END:VEVENT\r\n".len();
        v.push_str(&single[begin..end]);
    }
    v.push_str("END:VCALENDAR\r\n");
    v
}

fn make_dto(i: usize, uid: &str, recurrence: Option<DateTime<Utc>>) -> CalendarEventDto {
    CalendarEventDto {
        id: Uuid::from_u128(i as u128).to_string(),
        calendar_id: Uuid::nil().to_string(),
        summary: format!("Evento {i}"),
        description: None,
        location: None,
        start_time: Utc.with_ymd_and_hms(2026, 8, 5, 9, 0, 0).unwrap(),
        end_time: Utc.with_ymd_and_hms(2026, 8, 5, 10, 0, 0).unwrap(),
        all_day: false,
        rrule: None,
        ical_uid: uid.to_string(),
        recurrence_id: recurrence,
        ical_data: build_vevent_body(i, if recurrence.is_some() { 2 } else { 0 }),
        created_at: Utc.with_ymd_and_hms(2026, 7, 1, 0, 0, 0).unwrap(),
        updated_at: Utc.with_ymd_and_hms(2026, 7, 1, 0, 0, 0).unwrap(),
    }
}

fn p50(mut xs: Vec<f64>) -> f64 {
    xs.sort_by(|a, b| a.partial_cmp(b).unwrap());
    xs[xs.len() / 2]
}

fn time_passes<T>(passes: usize, mut f: impl FnMut() -> T) -> f64 {
    let mut per_pass = Vec::with_capacity(passes);
    for _ in 0..passes {
        let t0 = Instant::now();
        black_box(f());
        per_pass.push(t0.elapsed().as_secs_f64() * 1e6);
    }
    p50(per_pass)
}

fn main() {
    let n_events: usize = env::var("BENCH_EVENTS")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(200);
    let passes: usize = env::var("BENCH_PASSES")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(30);
    let group_n: usize = env::var("BENCH_GROUP_N")
        .ok()
        .and_then(|v| v.parse().ok())
        .unwrap_or(5000);

    let calendar_id = Uuid::nil();
    let bodies: Vec<String> = (0..n_events).map(|i| build_vevent_body(i, i % 3)).collect();
    let import_body = build_import_body(50);

    println!("bench_caldav_parse — {n_events} bodies, {passes} passes\n");

    // ── [1] from_ical: single-event PUT path ────────────────────────────────
    let t_before = time_passes(passes, || {
        for b in &bodies {
            black_box(before::from_ical(b).expect("before parse"));
        }
    }) / n_events as f64;
    let t_after = time_passes(passes, || {
        for b in &bodies {
            black_box(CalendarEvent::from_ical(calendar_id, b.clone()).expect("after parse"));
        }
    }) / n_events as f64;
    // The AFTER side clones the body (the real API takes it by value) —
    // measure that clone alone so the comparison can subtract it.
    let t_clone = time_passes(passes, || {
        for b in &bodies {
            black_box(b.clone());
        }
    }) / n_events as f64;
    println!("[1] from_ical µs/event (8-parse chain vs single parse)");
    println!("    BEFORE            {t_before:8.2}");
    println!(
        "    AFTER             {t_after:8.2}  (incl. {t_clone:.2} body clone)   {:.1}x",
        t_before / (t_after - t_clone)
    );

    // ── [2] parse_all_events: 50-event import PUT ───────────────────────────
    let t_before_imp = time_passes(passes, || {
        let blocks = before::split_vevents(&import_body);
        let mut out = Vec::with_capacity(blocks.len());
        for block in blocks {
            let wrapped = format!(
                "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//OxiCloud//NONSGML Calendar//EN\r\n{}END:VCALENDAR\r\n",
                block,
            );
            out.push(before::from_ical(&wrapped).expect("before import"));
        }
        out
    });
    let t_after_imp = time_passes(passes, || {
        CalendarEvent::parse_all_events(calendar_id, &import_body).expect("after import")
    });
    println!("[2] parse_all_events µs/50-event import body");
    println!("    BEFORE            {t_before_imp:8.1}");
    println!(
        "    AFTER             {t_after_imp:8.1}                              {:.1}x",
        t_before_imp / t_after_imp
    );

    // ── [3] extract_vevent_chunk: REPORT/GET read path ──────────────────────
    let t_chunk_before = time_passes(passes, || {
        for b in &bodies {
            black_box(before::extract_vevent_chunk(b));
        }
    }) / n_events as f64
        * 1000.0;
    let t_chunk_after = time_passes(passes, || {
        for b in &bodies {
            black_box(caldav_bench::extract_vevent_chunk(b));
        }
    }) / n_events as f64
        * 1000.0;
    println!("[3] extract_vevent_chunk ns/event (uppercase copy vs direct scan)");
    println!("    BEFORE            {t_chunk_before:8.0}");
    println!(
        "    AFTER             {t_chunk_after:8.0}                              {:.1}x",
        t_chunk_before / t_chunk_after
    );

    // ── [4] group_events_by_uid: REPORT fold ────────────────────────────────
    // 80% masters, 20% exception overrides sharing a master's UID.
    let dtos: Vec<CalendarEventDto> = (0..group_n)
        .map(|i| {
            if i % 5 == 4 {
                let master = i - 1;
                make_dto(
                    i,
                    &format!("evt-{master:05}@oxicloud.bench"),
                    Some(Utc.with_ymd_and_hms(2026, 8, 12, 9, 0, 0).unwrap()),
                )
            } else {
                make_dto(i, &format!("evt-{i:05}@oxicloud.bench"), None)
            }
        })
        .collect();
    let t_grp_before = time_passes(passes, || black_box(before::group_events_by_uid(&dtos)));
    let t_grp_after = time_passes(passes, || {
        black_box(caldav_bench::group_events_by_uid(&dtos))
    });
    println!("[4] group_events_by_uid µs/{group_n} events (String keys vs borrowed)");
    println!("    BEFORE            {t_grp_before:8.1}");
    println!(
        "    AFTER             {t_grp_after:8.1}                              {:.1}x",
        t_grp_before / t_grp_after
    );

    // ── [5] Equivalence gates ───────────────────────────────────────────────
    let mut ok = true;

    // Gate A: from_ical field identity across the corpus + edge bodies.
    let mut gate_bodies: Vec<String> = bodies.clone();
    gate_bodies.push(build_vevent_body(9990, 1));
    gate_bodies.push(build_vevent_body(9991, 2));
    // Mixed-case tags + LF-only line endings (foreign client shapes).
    gate_bodies.push(
        "begin:vcalendar\nversion:2.0\nbegin:vevent\nuid:mixed-case@x\nsummary:Mixed Case\ndtstart:20260801T080000Z\ndtend:20260801T090000Z\nend:vevent\nend:vcalendar\n"
            .to_string(),
    );
    for b in &gate_bodies {
        let bf = before::from_ical(b);
        let af = CalendarEvent::from_ical(calendar_id, b.clone());
        match (bf, af) {
            (Ok(bf), Ok(af)) => {
                let same = bf.summary == af.summary()
                    && bf.description.as_deref() == af.description()
                    && bf.location.as_deref() == af.location()
                    && bf.start_time == *af.start_time()
                    && bf.end_time == *af.end_time()
                    && bf.all_day == af.all_day()
                    && bf.rrule.as_deref() == af.rrule()
                    && bf.ical_uid.as_deref() == Some(af.ical_uid())
                    && bf.recurrence_id.as_ref() == af.recurrence_id();
                if !same {
                    eprintln!("GATE A FAIL: field mismatch for body:\n{b}\n before={bf:?}");
                    ok = false;
                }
            }
            (Err(_), Err(_)) => {}
            (bf, af) => {
                eprintln!(
                    "GATE A FAIL: error parity broke (before_ok={} after_ok={}) for body:\n{b}",
                    bf.is_ok(),
                    af.is_ok()
                );
                ok = false;
            }
        }
    }

    // Gate B: parse_all_events equivalence on the import body — same
    // events, same wrapped per-row ical_data.
    let after_events =
        CalendarEvent::parse_all_events(calendar_id, &import_body).expect("import parses");
    let before_blocks = before::split_vevents(&import_body);
    if after_events.len() != before_blocks.len() {
        eprintln!(
            "GATE B FAIL: event count {} != block count {}",
            after_events.len(),
            before_blocks.len()
        );
        ok = false;
    }
    for (evt, block) in after_events.iter().zip(&before_blocks) {
        let wrapped = format!(
            "BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//OxiCloud//NONSGML Calendar//EN\r\n{}END:VCALENDAR\r\n",
            block,
        );
        if evt.ical_data() != wrapped {
            eprintln!("GATE B FAIL: wrapped ical_data mismatch");
            ok = false;
            break;
        }
        let bf = before::from_ical(&wrapped).expect("before parses wrapped");
        if bf.summary != evt.summary() || bf.recurrence_id.as_ref() != evt.recurrence_id() {
            eprintln!("GATE B FAIL: field mismatch on wrapped block");
            ok = false;
            break;
        }
    }

    // Gate C: chunk slices byte-identical (incl. mixed-case + no-terminator).
    let mut chunk_bodies = bodies.clone();
    chunk_bodies.push("BEGIN:VCALENDAR\r\nbegin:vevent\r\nUID:x@y\r\nend:vevent".to_string());
    chunk_bodies.push("no vevent here at all".to_string());
    for b in &chunk_bodies {
        if before::extract_vevent_chunk(b) != caldav_bench::extract_vevent_chunk(b) {
            eprintln!("GATE C FAIL: chunk mismatch for body:\n{b}");
            ok = false;
        }
    }

    // Gate D: grouping identity — same UID order, same per-bucket rows.
    let g_before = before::group_events_by_uid(&dtos);
    let g_after = caldav_bench::group_events_by_uid(&dtos);
    let shape = |g: &Vec<Vec<&CalendarEventDto>>| -> Vec<Vec<(String, bool)>> {
        g.iter()
            .map(|bucket| {
                bucket
                    .iter()
                    .map(|e| (e.id.clone(), e.recurrence_id.is_some()))
                    .collect()
            })
            .collect()
    };
    if shape(&g_before) != shape(&g_after) {
        eprintln!("GATE D FAIL: grouping mismatch");
        ok = false;
    }

    println!(
        "[5] Equivalence gates: {}",
        if ok { "OK (byte-identical)" } else { "FAILED" }
    );
    if !ok {
        std::process::exit(1);
    }
}