akiflow_rust 0.4.11

use crate::helpers::fix_timezone;
use chrono::{DateTime, Datelike, TimeZone, Timelike, Utc};
use chrono_tz::Tz;
use rrule::RRuleSet;

/// Minimum number of occurrences to find before stopping range extension.
const MIN_OCCURRENCES: usize = 3;

/// Maximum duration to extend the end date by (10 years in days).
/// This needs to be long enough to handle infrequent recurrences like "every 49 months".
const MAX_RANGE_EXTENSION_DAYS: i64 = 10 * 365; // 10 years

/// Wrapper around `between_datetime_i64` that handles floating point conversions.
///
/// The internal function `between_datetime_i64`:
/// 1. Fixes the timezone string using `fix_timezone`.
/// 2. Constructs the DTSTART string from the given epoch and timezone.
/// 3. Parses the recurrence rule combined with DTSTART.
/// 4. If parsing fails, attempts to fix the recurrence string and parse again.
/// 5. Iterates through the recurrence occurrences.
/// 6. Filters and returns timestamps that fall within the [start_datetime, end_datetime] range.
/// 7. If `extend_end` is true and fewer than MIN_OCCURRENCES are found, extends the end date.
pub fn between_datetime_f64(
    dt_start_utc: f64,
    tzid: &str,
    recurrence: &str,
    start_datetime: f64,
    end_datetime: f64,
    extend_end: bool,
    include_dtstart: bool,
) -> Vec<f64> {
    between_datetime_i64(
        dt_start_utc as i64,
        tzid,
        recurrence,
        start_datetime as i64,
        end_datetime as i64,
        extend_end,
        include_dtstart,
    )
    .into_iter()
    .map(|x| x as f64)
    .collect()
}

pub fn between_datetime_i64(
    dt_start_utc: i64,
    tzid: &str,
    recurrence: &str,
    start_datetime: i64,
    end_datetime: i64,
    extend_end: bool,
    include_dtstart: bool,
) -> Vec<i64> {
    let fixed_tz: String = fix_timezone(tzid, Some("UTC"));
    let dtstart = get_dtstart_from_epoch(dt_start_utc, Some(&fixed_tz));

    let rruleset = match (dtstart.clone() + "\n" + recurrence).parse::<RRuleSet>() {
        Ok(rr) => rr,
        Err(err1) => {
            let fixed_recurrence = fix_datetime_recurrence(recurrence, dt_start_utc, &fixed_tz);
            eprintln!("Error parsing recurrence rule: {}", err1);
            match (dtstart + "\n" + &fixed_recurrence).parse::<RRuleSet>() {
                Ok(rr) => rr,
                Err(err2) => {
                    eprintln!(
                        "Error parsing recurrence rule even after attempting fixing: {}",
                        err2
                    );
                    return Vec::new();
                }
            }
        }
    };

    // Calculate the maximum end date we're willing to extend to (10 years from original end)
    let max_end = end_datetime + MAX_RANGE_EXTENSION_DAYS * 24 * 60 * 60 * 1000;

    let mut arr = vec![];
    let iterator = rruleset.into_iter();

    for date in iterator {
        let date_timestamp = date.timestamp_millis();

        if date_timestamp >= start_datetime && date_timestamp <= end_datetime {
            // Within original range - always collect
            arr.push(date_timestamp);
        } else if date_timestamp > end_datetime {
            // Past original end - only continue if extending and need more occurrences
            if extend_end && arr.len() < MIN_OCCURRENCES && date_timestamp <= max_end {
                arr.push(date_timestamp);
            } else {
                break;
            }
        }
        // Skip dates before start_datetime (date_timestamp < start_datetime)
    }

    // Google-like behavior:
    // If DTSTART is not part of the rule-generated set (e.g. BYDAY excludes its weekday),
    // still include DTSTART alongside the occurrences (but don't duplicate it).
    // Also, do not include if DTSTART is in EXDATE.
    if include_dtstart
        && dt_start_utc >= start_datetime
        && dt_start_utc <= end_datetime
        && !arr.contains(&dt_start_utc)
        && !is_datetime_excluded(recurrence, dt_start_utc, &fixed_tz)
    {
        arr.insert(0, dt_start_utc);
    }

    arr
}

/// Wrapper around `between_date_i64` that handles floating point conversions for the time range.
///
/// The internal function `between_date_i64`:
/// 1. Constructs the DTSTART string from the provided date string.
/// 2. Fixes the recurrence string using `fix_date_recurrence`.
/// 3. Parses the recurrence rule combined with DTSTART.
/// 4. Iterates through the recurrence occurrences.
/// 5. Filters occurrences based on the timestamp range [start_datetime, end_datetime].
/// 6. Returns the dates in "YYYY-MM-DD" format.
/// 7. If `extend_end` is true and fewer than MIN_OCCURRENCES are found, extends the end date.
pub fn between_date_f64(
    dt_start_date: &str,
    recurrence: &str,
    start_date: &str,
    end_date: &str,
    extend_end: bool,
    include_dtstart: bool,
) -> Vec<String> {
    between_date_i64(
        dt_start_date,
        recurrence,
        start_date,
        end_date,
        extend_end,
        include_dtstart,
    )
}
// date is in the format YYYY-MM-DD
pub fn between_date_i64(
    dt_start_date: &str,
    recurrence: &str,
    start_date: &str,
    end_date: &str,
    extend_end: bool,
    include_dtstart: bool,
) -> Vec<String> {
    // We will compare occurrences by calendar date (NaiveDate) to preserve
    // all-day semantics regardless of timezone/DST.
    let start_naive = match chrono::NaiveDate::parse_from_str(start_date, "%Y-%m-%d") {
        Ok(d) => d,
        Err(_) => return Vec::new(),
    };
    let end_naive = match chrono::NaiveDate::parse_from_str(end_date, "%Y-%m-%d") {
        Ok(d) => d,
        Err(_) => return Vec::new(),
    };

    let dtstart = get_dtstart_from_date(dt_start_date);
    let fixed_recurrence = fix_date_recurrence(recurrence);

    let rruleset = match (dtstart + "\n" + &fixed_recurrence).parse::<RRuleSet>() {
        Ok(rr) => rr,
        Err(err2) => {
            eprintln!(
                "Error parsing recurrence rule even after attempting fixing: {}",
                err2
            );
            return Vec::new();
        }
    };

    // Note: extension window is expressed as a calendar range (max_end_naive)
    let max_end_naive = end_naive + chrono::Duration::days(MAX_RANGE_EXTENSION_DAYS);

    let mut arr: Vec<String> = vec![];
    let iterator = rruleset.into_iter().peekable();

    for date in iterator {
        // Compare by calendar date to avoid timezone-induced day shifts.
        let date_naive = date.date_naive();

        if date_naive >= start_naive && date_naive <= end_naive {
            // Within original range - always collect
            arr.push(date.format("%F").to_string());
        } else if date_naive > end_naive {
            // Past original end - only continue if extending and need more occurrences
            if extend_end && arr.len() < MIN_OCCURRENCES && date_naive <= max_end_naive {
                arr.push(date.format("%F").to_string());
            } else {
                break;
            }
        }
        // Skip dates before start_datetime (date_timestamp < start_datetime)
    }

    // Google-like behavior for all-day DTSTART: include DTSTART date token if it falls in range
    // even if it doesn't match BYDAY (e.g. DTSTART Thu + BYDAY=WE).
    // Also, do not include if DTSTART is in EXDATE.
    if include_dtstart {
        if let Ok(d) = chrono::NaiveDate::parse_from_str(dt_start_date, "%Y-%m-%d") {
            if d >= start_naive
                && d <= end_naive
                && !arr.iter().any(|s| s == dt_start_date)
                && !is_date_excluded(recurrence, dt_start_date)
            {
                arr.insert(0, dt_start_date.to_string());
            }
        }
    }

    arr
}

/// Takes a UTC Unix epoch in milliseconds and optional tz string,
/// returns an iCalendar DTSTART line. The timestamp value is NOT
/// converted to the tz; it remains the UTC instant, just like your TS.
pub fn get_dtstart_from_epoch(epoch_ms: i64, tz: Option<&str>) -> String {
    let dt_utc = DateTime::<Utc>::from_timestamp_millis(epoch_ms).unwrap();

    if let Some(tzid) = tz.filter(|s| !s.is_empty()) {
        if let Ok(zone) = tzid.parse::<Tz>() {
            let local = dt_utc.with_timezone(&zone);
            // Local time with TZID — no trailing Z
            return format!("DTSTART;TZID={}:{}", tzid, local.format("%Y%m%dT%H%M%S"));
        }
    }

    // Fallback: UTC with trailing Z and no TZID
    format!("DTSTART:{}Z", dt_utc.format("%Y%m%dT%H%M%S"))
}
// date is in the format YYYY-MM-DD
pub fn get_dtstart_from_date(date: &str) -> String {
    // format date as YYYYMMDD
    let stamp = date.replace("-", "");
    format!("DTSTART;VALUE=DATE:{}", stamp)
}

/// Fixes non-compliant RRULE `UNTIL` values:
/// 1) If `UNTIL` is a DATE (YYYYMMDD), attach the wall-clock time from `start_epoch`
///    interpreted in `timezone`, convert to UTC, and format as YYYYMMDDTHHMMSSZ.
/// 2) If `UNTIL` is a local DATE-TIME without trailing Z (YYYYMMDDTHHMMSS),
///    interpret it in `timezone`, convert to UTC, and add Z.
/// Leaves the string unchanged if:
/// - No UNTIL present
/// - UNTIL already has a trailing Z
/// - Values can't be parsed, timezone invalid, or ambiguous/nonexistent local times that can't be disambiguated.
pub fn fix_datetime_recurrence_until(recurrence: &str, start_epoch: i64, timezone: &str) -> String {
    let tz: Tz = timezone.parse().unwrap_or(chrono_tz::UTC);

    // Locate UNTIL=
    let until_key = "UNTIL=";
    let Some(pos) = recurrence.find(until_key) else {
        return recurrence.to_string();
    };
    let val_start = pos + until_key.len();
    let rest = &recurrence[val_start..];
    let val_len = rest.find(';').unwrap_or(rest.len());
    let until_val = &rest[..val_len];

    // If it already ends with 'Z', assume compliant UTC and leave as-is.
    if until_val.ends_with('Z') {
        return recurrence.to_string();
    }

    // Case A: DATE only, e.g. 20250617
    let is_date_only = until_val.len() == 8 && until_val.chars().all(|c| c.is_ascii_digit());
    if is_date_only {
        // Build wall time from DTSTART (start_epoch) in local tz
        let start_utc = match Utc.timestamp_opt(start_epoch, 0).single() {
            Some(dt) => dt,
            None => return recurrence.to_string(),
        };
        let start_local = start_utc.with_timezone(&tz);
        let (hh, mm, ss) = (
            start_local.hour(),
            start_local.minute(),
            start_local.second(),
        );

        let (y, m, d) = match parse_yyyymmdd(until_val) {
            Some(v) => v,
            None => return recurrence.to_string(),
        };

        // Use earliest() to resolve DST ambiguity deterministically.
        let until_local = match tz.with_ymd_and_hms(y, m, d, hh, mm, ss).earliest() {
            Some(dt) => dt,
            None => return recurrence.to_string(),
        };
        let until_utc = until_local.with_timezone(&Utc);
        let until_fmt = until_utc.format("%Y%m%dT%H%M%SZ").to_string();

        return splice_value(recurrence, val_start, val_len, &until_fmt);
    }

    // Case B: DATE-TIME without Z, e.g. 20250617T235959  (treat as local in tz)
    let is_local_datetime = until_val.len() == 15
        && until_val.as_bytes()[8] == b'T'
        && until_val
            .chars()
            .enumerate()
            .all(|(i, c)| i == 8 || c.is_ascii_digit());

    if is_local_datetime {
        let (y, m, d) = match parse_yyyymmdd(&until_val[0..8]) {
            Some(v) => v,
            None => return recurrence.to_string(),
        };
        let (hh, mm, ss) = match parse_hhmmss(&until_val[9..15]) {
            Some(v) => v,
            None => return recurrence.to_string(),
        };

        let until_local = match tz.with_ymd_and_hms(y, m, d, hh, mm, ss).earliest() {
            Some(dt) => dt,
            None => return recurrence.to_string(),
        };
        let until_utc = until_local.with_timezone(&Utc);
        let until_fmt = until_utc.format("%Y%m%dT%H%M%SZ").to_string();

        return splice_value(recurrence, val_start, val_len, &until_fmt);
    }

    // Otherwise, leave unchanged.
    recurrence.to_string()
}

/// Splits malformed recurrence strings where clauses are separated by ';' instead of newlines.
/// Replaces occurrences of ";RRULE", ";EXDATE", ";RDATE", ";DTSTART" with "\nRRULE" etc.
pub fn fix_recurrence_split(recurrence: &str) -> String {
    let mut s = recurrence.to_string();
    for key in ["RRULE", "EXDATE", "RDATE", "DTSTART"] {
        let needle = format!(";{}", key);
        let replacement = format!("\n{}", key);
        s = s.replace(&needle, &replacement);
    }
    s
}

/// Wrapper that first fixes clause splitting, then normalizes UNTIL to UTC with Z.
pub fn fix_datetime_recurrence(recurrence: &str, start_epoch: i64, timezone: &str) -> String {
    let split = fix_recurrence_split(recurrence);
    fix_datetime_recurrence_until(&split, start_epoch, timezone)
}

/// Fixes a recurrence rule by removing the time part from UNTIL values.
/// If the UNTIL value is a datetime (with or without Z), it will be converted to a date-only value.
/// For example:
/// - "UNTIL=20250617T235959Z" becomes "UNTIL=20250617"
/// - "UNTIL=20250617T235959" becomes "UNTIL=20250617"
///
/// Leaves the string unchanged if:
/// - No UNTIL present
/// - UNTIL is already a date-only value
/// - UNTIL value can't be parsed
pub fn fix_date_recurrence_until(recurrence: &str) -> String {
    // Locate UNTIL=
    let until_key = "UNTIL=";
    let Some(pos) = recurrence.find(until_key) else {
        return recurrence.to_string();
    };
    let val_start = pos + until_key.len();
    let rest = &recurrence[val_start..];
    let val_len = rest.find(';').unwrap_or(rest.len());
    let until_val = &rest[..val_len];

    // If it's already a date-only value, leave as-is
    let is_date_only = until_val.len() == 8 && until_val.chars().all(|c| c.is_ascii_digit());
    if is_date_only {
        return recurrence.to_string();
    }

    // Check if it's a datetime value (with or without Z)
    let is_datetime = (until_val.len() == 15
        || (until_val.len() == 16 && until_val.ends_with('Z')))
        && until_val.as_bytes()[8] == b'T'
        && until_val
            .chars()
            .enumerate()
            .all(|(i, c)| i == 8 || i == 15 && c == 'Z' || c.is_ascii_digit());

    if is_datetime {
        // Extract just the date part (first 8 characters)
        let date_only = &until_val[0..8];

        // Verify it's a valid date
        if parse_yyyymmdd(date_only).is_none() {
            return recurrence.to_string();
        }

        return splice_value(recurrence, val_start, val_len, date_only);
    }

    // Otherwise, leave unchanged
    recurrence.to_string()
}

/// Wrapper that first fixes clause splitting, then strips time from UNTIL (date-only semantics).
pub fn fix_date_recurrence(recurrence: &str) -> String {
    let split = fix_recurrence_split(recurrence);
    fix_date_recurrence_until(&split)
}

fn parse_yyyymmdd(s: &str) -> Option<(i32, u32, u32)> {
    if s.len() != 8 {
        return None;
    }
    let y: i32 = s[0..4].parse().ok()?;
    let m: u32 = s[4..6].parse().ok()?;
    let d: u32 = s[6..8].parse().ok()?;
    Some((y, m, d))
}

fn parse_hhmmss(s: &str) -> Option<(u32, u32, u32)> {
    if s.len() != 6 {
        return None;
    }
    let hh: u32 = s[0..2].parse().ok()?;
    let mm: u32 = s[2..4].parse().ok()?;
    let ss: u32 = s[4..6].parse().ok()?;
    Some((hh, mm, ss))
}

fn splice_value(orig: &str, start: usize, len: usize, replacement: &str) -> String {
    let mut out = String::with_capacity(orig.len() + replacement.len().saturating_sub(len));
    out.push_str(&orig[..start]);
    out.push_str(replacement);
    out.push_str(&orig[start + len..]);
    out
}

/// Adds or updates the UNTIL clause in a recurrence rule for all-day events.
///
/// This function takes a full recurrence parameter (as a string with all recurrence pieces
/// separated by \n) and adds or updates the UNTIL clause in the RRULE part using the provided
/// date string in yyyy-mm-dd format.
///
/// If the recurrence already has an UNTIL clause, it will be replaced.
/// If the recurrence has a COUNT clause, it will be removed.
///
/// # Arguments
/// * `recurrence` - The full recurrence parameter as a string
/// * `until_date` - The date string in yyyy-mm-dd format (e.g., "2025-09-30")
/// * `use_exact_until` - If true, use the date as passed; if false, subtract 1 day before using it.
///
/// # Returns
/// A modified recurrence string with the UNTIL clause added or updated
pub fn add_until_date(recurrence: &str, until_date: &str, use_exact_until: bool) -> String {
    // Handle date adjustment based on use_exact_until
    let until_value = if use_exact_until {
        until_date.replace("-", "")
    } else {
        // subtract one day from yyyy-mm-dd
        if let Ok(d) = chrono::NaiveDate::parse_from_str(until_date, "%Y-%m-%d") {
            let prev = d.pred_opt().unwrap_or(d);
            prev.format("%Y%m%d").to_string()
        } else {
            // If parsing fails, fall back to original behavior
            until_date.replace("-", "")
        }
    };

    // Process each line in the recurrence
    let lines: Vec<&str> = recurrence.lines().collect();
    let mut result = Vec::with_capacity(lines.len());

    for line in lines {
        if line.starts_with("RRULE:") {
            // Process the RRULE line
            let mut rrule = line.to_string();

            // Remove COUNT if present
            if let Some(count_pos) = rrule.find("COUNT=") {
                let count_start = count_pos;
                let count_rest = &rrule[count_pos..];
                let count_end = count_pos + count_rest.find(';').unwrap_or(count_rest.len());

                // Remove COUNT=n; or COUNT=n at the end
                rrule = splice_value(
                    &rrule,
                    count_start,
                    count_end - count_start + if count_end < rrule.len() { 1 } else { 0 },
                    "",
                );
            }

            // Check if UNTIL is already present
            if let Some(until_pos) = rrule.find("UNTIL=") {
                let until_start = until_pos;
                let until_rest = &rrule[until_pos..];
                let until_end = until_pos + until_rest.find(';').unwrap_or(until_rest.len());

                // Replace existing UNTIL
                rrule = splice_value(
                    &rrule,
                    until_start,
                    until_end - until_start,
                    &format!("UNTIL={}", until_value),
                );
            } else {
                // Add new UNTIL
                if rrule.ends_with(';') {
                    rrule = format!("{}UNTIL={}", rrule, until_value);
                } else {
                    rrule = format!("{};UNTIL={}", rrule, until_value);
                }
            }

            result.push(rrule);
        } else {
            // Keep other lines unchanged
            result.push(line.to_string());
        }
    }

    result.join("\n")
}

/// Adds or updates the UNTIL clause in a recurrence rule using a unix epoch timestamp.
///
/// This function takes a full recurrence parameter (as a string with all recurrence pieces
/// separated by \n) and adds or updates the UNTIL clause in the RRULE part using the provided
/// unix epoch timestamp (in UTC).
///
/// If the recurrence already has an UNTIL clause, it will be replaced.
/// If the recurrence has a COUNT clause, it will be removed.
///
/// # Arguments
/// * `recurrence` - The full recurrence parameter as a string
/// * `until_timestamp` - The unix epoch timestamp in milliseconds (UTC)
/// * `use_exact_until` - If true, use the until timestamp exactly; if false (default), subtract 1 second to end before the passed until.
///
/// # Returns
/// A modified recurrence string with the UNTIL clause added or updated
///
/// # Notes
/// By default, RFC interpretation can differ across libraries; this function now defaults to ending the recurrence strictly before the provided until by subtracting 1 second unless `use_exact_until` is true.
pub fn add_until_datetime(
    recurrence: &str,
    until_timestamp: f64,
    use_exact_until: bool,
    timezone: &str,
) -> String {
    // Compute UTC DateTime for UNTIL according to rules
    let until_dt_utc = if use_exact_until {
        DateTime::<Utc>::from_timestamp_millis(until_timestamp as i64).unwrap()
    } else {
        // Convert the provided UTC timestamp into the provided timezone, shift to previous day's 23:59:59 in that TZ, then back to UTC
        let utc_dt = DateTime::<Utc>::from_timestamp_millis(until_timestamp as i64).unwrap();
        // Parse timezone (default to UTC if invalid)
        let tz: chrono_tz::Tz = timezone.parse().unwrap_or(chrono_tz::UTC);
        let local_dt = utc_dt.with_timezone(&tz);
        let prev_day = local_dt
            .date_naive()
            .pred_opt()
            .unwrap_or(local_dt.date_naive());
        // set to 23:59:59 local time previous day
        let local_235959 = tz
            .with_ymd_and_hms(
                prev_day.year(),
                prev_day.month(),
                prev_day.day(),
                23,
                59,
                59,
            )
            .single()
            .unwrap_or_else(|| {
                tz.with_ymd_and_hms(
                    prev_day.year(),
                    prev_day.month(),
                    prev_day.day(),
                    23,
                    59,
                    59,
                )
                .earliest()
                .unwrap()
            });
        local_235959.with_timezone(&Utc)
    };

    // Format the until value in UTC with Z suffix
    let until_value = until_dt_utc.format("%Y%m%dT%H%M%SZ").to_string();

    // Process each line in the recurrence
    let lines: Vec<&str> = recurrence.lines().collect();
    let mut result = Vec::with_capacity(lines.len());

    for line in lines {
        if line.starts_with("RRULE:") {
            // Process the RRULE line
            let mut rrule = line.to_string();

            // Remove COUNT if present
            if let Some(count_pos) = rrule.find("COUNT=") {
                let count_start = count_pos;
                let count_rest = &rrule[count_pos..];
                let count_end = count_pos + count_rest.find(';').unwrap_or(count_rest.len());

                // Remove COUNT=n; or COUNT=n at the end
                rrule = splice_value(
                    &rrule,
                    count_start,
                    count_end - count_start + if count_end < rrule.len() { 1 } else { 0 },
                    "",
                );
            }

            // Check if UNTIL is already present
            if let Some(until_pos) = rrule.find("UNTIL=") {
                let until_start = until_pos;
                let until_rest = &rrule[until_pos..];
                let until_end = until_pos + until_rest.find(';').unwrap_or(until_rest.len());

                // Replace existing UNTIL
                rrule = splice_value(
                    &rrule,
                    until_start,
                    until_end - until_start,
                    &format!("UNTIL={}", until_value),
                );
            } else {
                // Add new UNTIL
                if rrule.ends_with(';') {
                    rrule = format!("{}UNTIL={}", rrule, until_value);
                } else {
                    rrule = format!("{};UNTIL={}", rrule, until_value);
                }
            }

            result.push(rrule);
        } else {
            // Keep other lines unchanged
            result.push(line.to_string());
        }
    }

    result.join("\n")
}

/// Adds a datetime EXDATE (UTC with Z) to a recurrence set if missing.
///
/// - `recurrence` is the full recurrence parameter (potentially multi-line).
/// - `exdate_ts` is a UTC Unix epoch in milliseconds.
///
/// Behavior (RFC-compliant):
/// - EXDATE lines follow the form `EXDATE[:|;params]value[,value...]`.
/// - We emit `EXDATE:YYYYMMDDTHHMMSSZ` (UTC with Z, no params) using the
///   provided timestamp. Any existing EXDATE lines with timezone parameters
///   are preserved; we only add a new UTC value.
/// - If an EXDATE line already contains that exact value in any of its comma-separated
///   datetimes, we do nothing.
/// - Otherwise, we append the value to the last EXDATE line; if none exists we append
///   a new EXDATE line at the end of the string (separated by a newline when non-empty).
pub fn add_exdate_datetime(recurrence: &str, exdate_ts: f64) -> String {
    let dt_utc = match DateTime::<Utc>::from_timestamp_millis(exdate_ts as i64) {
        Some(dt) => dt,
        None => return recurrence.to_string(),
    };
    let value = dt_utc.format("%Y%m%dT%H%M%SZ").to_string();

    let mut lines: Vec<String> = recurrence.lines().map(|s| s.to_string()).collect();

    // Track index of last EXDATE line (if any)
    let mut last_exdate_idx: Option<usize> = None;
    for (idx, line) in lines.iter().enumerate() {
        if line.starts_with("EXDATE") {
            last_exdate_idx = Some(idx);
        }
    }

    if let Some(idx) = last_exdate_idx {
        let line = &mut lines[idx];

        // Find the colon that separates params from values.
        if let Some(colon_pos) = line.find(':') {
            let (head, tail) = line.split_at(colon_pos + 1); // keep ':' in head
            // tail is the comma-separated list of values
            let existing_values: Vec<&str> = tail.split(',').collect();
            if existing_values.iter().any(|v| *v == value) {
                // already present, return unchanged
                return recurrence.to_string();
            }
            let mut new_tail = tail.to_string();
            if !new_tail.is_empty() {
                new_tail.push(',');
            }
            new_tail.push_str(&value);
            *line = format!("{}{}", head, new_tail);
        } else {
            // Malformed EXDATE line without ':', append anew values section.
            *line = format!("{}:{}", line, value);
        }
        return lines.join("\n");
    }

    // No EXDATE line found: append a new one
    if recurrence.is_empty() {
        format!("EXDATE:{}", value)
    } else {
        format!("{}\nEXDATE:{}", recurrence, value)
    }
}

/// Adds a date-only EXDATE (VALUE=DATE, YYYYMMDD) to a recurrence set if missing.
///
/// - `recurrence` is the full recurrence parameter (potentially multi-line).
/// - `exdate_date` is a calendar date string in `YYYY-MM-DD`.
///
/// Behavior:
/// - We emit `EXDATE;VALUE=DATE:YYYYMMDD` with no time component.
/// - If any existing `EXDATE;VALUE=DATE:` line already contains that date token
///   in its comma-separated list, we do nothing.
/// - Otherwise we append the date token to the last `EXDATE;VALUE=DATE:` line;
///   if none exists, we append a new line at the end (or return just that line
///   if `recurrence` is empty).
pub fn add_exdate_date(recurrence: &str, exdate_date: &str) -> String {
    // Normalize YYYY-MM-DD -> YYYYMMDD; if parsing fails, return unchanged.
    let naive = match chrono::NaiveDate::parse_from_str(exdate_date, "%Y-%m-%d") {
        Ok(d) => d,
        Err(_) => return recurrence.to_string(),
    };
    let token = naive.format("%Y%m%d").to_string();

    let mut lines: Vec<String> = recurrence.lines().map(|s| s.to_string()).collect();

    // Track index of last EXDATE;VALUE=DATE line (if any)
    let mut last_idx: Option<usize> = None;
    for (idx, line) in lines.iter().enumerate() {
        if line.starts_with("EXDATE;VALUE=DATE:") {
            last_idx = Some(idx);
        }
    }

    if let Some(idx) = last_idx {
        let line = &mut lines[idx];
        // Split into head "EXDATE;VALUE=DATE:" and comma-separated values
        let prefix = "EXDATE;VALUE=DATE:";
        let existing = &line[prefix.len()..];
        let parts: Vec<&str> = existing.split(',').collect();
        if parts.iter().any(|v| *v == token) {
            return recurrence.to_string();
        }
        if existing.is_empty() {
            *line = format!("{}{}", prefix, token);
        } else {
            *line = format!("{}{},{}", prefix, existing, token);
        }
        return lines.join("\n");
    }

    // No EXDATE;VALUE=DATE line found: append a new one
    let new_line = format!("EXDATE;VALUE=DATE:{}", token);
    if recurrence.is_empty() {
        new_line
    } else {
        format!("{}\n{}", recurrence, new_line)
    }
}

/// Checks if a given UTC timestamp (ms) is present in any EXDATE datetime lines.
///
/// Supports:
/// - `EXDATE:YYYYMMDDTHHMMSSZ` (UTC)
/// - `EXDATE;TZID=Europe/Bucharest:YYYYMMDDTHHMMSS` (local in TZID)
/// - tokens without seconds: `YYYYMMDDTHHMM` / `YYYYMMDDTHHMMZ`
///
/// `tzid` is used as a fallback when an EXDATE line has no TZID and no `Z`.
pub fn is_datetime_excluded(recurrence: &str, ts_utc_ms: i64, tzid: &str) -> bool {
    let dt_utc = match DateTime::<Utc>::from_timestamp_millis(ts_utc_ms) {
        Some(dt) => dt,
        None => return false,
    };

    let tz: Tz = tzid.parse().unwrap_or(chrono_tz::UTC);

    // UTC tokens
    let utc_full = dt_utc.format("%Y%m%dT%H%M%SZ").to_string(); // ...SSZ
    let utc_no_sec = dt_utc.format("%Y%m%dT%H%MZ").to_string(); // ...MMZ

    for line in recurrence.lines() {
        // Skip EXDATE;VALUE=DATE
        if !line.starts_with("EXDATE") || line.contains(";VALUE=DATE") {
            continue;
        }

        let Some(colon_pos) = line.find(':') else {
            continue; // malformed EXDATE line
        };

        let head = &line[..colon_pos];
        let values = &line[colon_pos + 1..];

        // Determine TZID for this EXDATE line (fallback to event tz)
        let line_tz: Tz = head
            .split(';')
            .find_map(|p| p.strip_prefix("TZID="))
            .and_then(|tz| tz.parse::<Tz>().ok())
            .unwrap_or(tz);

        // Local tokens in line tz (no trailing Z)
        let dt_local = dt_utc.with_timezone(&line_tz);
        let local_full = dt_local.format("%Y%m%dT%H%M%S").to_string(); // ...SS
        let local_no_sec = dt_local.format("%Y%m%dT%H%M").to_string(); // ...MM

        for raw in values.split(',') {
            let v = raw.trim();
            if v.is_empty() {
                continue;
            }

            if v.ends_with('Z') {
                // UTC comparison
                if v == utc_full || v == utc_no_sec {
                    return true;
                }
            } else {
                // Local wall-time comparison (TZID or event tz)
                if v == local_full || v == local_no_sec {
                    return true;
                }
            }
        }
    }

    false
}

/// Checks if a given date string is present in any EXDATE;VALUE=DATE lines.
pub fn is_date_excluded(recurrence: &str, date_str: &str) -> bool {
    let naive = match chrono::NaiveDate::parse_from_str(date_str, "%Y-%m-%d") {
        Ok(d) => d,
        Err(_) => return false,
    };
    let token = naive.format("%Y%m%d").to_string();

    for line in recurrence.lines() {
        if line.starts_with("EXDATE;VALUE=DATE:") {
            let values = &line["EXDATE;VALUE=DATE:".len()..];
            if values.split(',').any(|v| v.trim() == token) {
                return true;
            }
        }
    }
    false
}

#[cfg(test)]
mod tests1 {
    // add_until tests and datetime UNTIL normalization tests
    use super::*;
    use chrono::TimeZone;

    #[test]
    fn test_add_until_to_rrule_all_day() {
        // Test adding UNTIL to a simple RRULE
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", true);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930");

        // Test replacing existing UNTIL
        let recurrence = "RRULE:FREQ=WEEKLY;UNTIL=20250101;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", true);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;UNTIL=20250930;BYDAY=MO,WE,FR");

        // Test removing COUNT and adding UNTIL
        let recurrence = "RRULE:FREQ=WEEKLY;COUNT=10;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", true);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930");

        // Test with multi-line recurrence
        let recurrence = "DTSTART;VALUE=DATE:20250101\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR\nEXDATE;VALUE=DATE:20250115";
        let result = add_until_date(recurrence, "2025-09-30", true);
        assert_eq!(
            result,
            "DTSTART;VALUE=DATE:20250101\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930\nEXDATE;VALUE=DATE:20250115"
        );
    }

    #[test]
    fn test_add_until_to_rrule_all_day_adjusted() {
        // When use_exact_until is false, we should subtract one day
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", false);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250929");

        // Replacing existing UNTIL should reflect adjusted date
        let recurrence = "RRULE:FREQ=WEEKLY;UNTIL=20250101;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", false);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;UNTIL=20250929;BYDAY=MO,WE,FR");

        // Removing COUNT and adding adjusted UNTIL
        let recurrence = "RRULE:FREQ=WEEKLY;COUNT=10;BYDAY=MO,WE,FR";
        let result = add_until_date(recurrence, "2025-09-30", false);
        assert_eq!(result, "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250929");

        // Multi-line recurrence adjusted
        let recurrence = "DTSTART;VALUE=DATE:20250101\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR\nEXDATE;VALUE=DATE:20250115";
        let result = add_until_date(recurrence, "2025-09-30", false);
        assert_eq!(
            result,
            "DTSTART;VALUE=DATE:20250101\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250929\nEXDATE;VALUE=DATE:20250115"
        );
    }

    #[test]
    fn test_add_until_to_rrule_datetime() {
        // Create a timestamp for 2025-09-30T15:30:00Z
        let timestamp = Utc
            .with_ymd_and_hms(2025, 9, 30, 15, 30, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;

        // Test adding UNTIL to a simple RRULE (exact time)
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR";
        let result = add_until_datetime(recurrence, timestamp, true, "UTC");
        assert_eq!(
            result,
            "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930T153000Z"
        );

        // Test replacing existing UNTIL (exact time)
        let recurrence = "RRULE:FREQ=WEEKLY;UNTIL=20250101T000000Z;BYDAY=MO,WE,FR";
        let result = add_until_datetime(recurrence, timestamp, true, "UTC");
        assert_eq!(
            result,
            "RRULE:FREQ=WEEKLY;UNTIL=20250930T153000Z;BYDAY=MO,WE,FR"
        );

        // Test removing COUNT and adding UNTIL (exact time)
        let recurrence = "RRULE:FREQ=WEEKLY;COUNT=10;BYDAY=MO,WE,FR";
        let result = add_until_datetime(recurrence, timestamp, true, "UTC");
        assert_eq!(
            result,
            "RRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930T153000Z"
        );

        // Test with multi-line recurrence (exact time)
        let recurrence =
            "DTSTART:20250101T120000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR\nEXDATE:20250115T120000Z";
        let result = add_until_datetime(recurrence, timestamp, true, "UTC");
        assert_eq!(
            result,
            "DTSTART:20250101T120000Z\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;UNTIL=20250930T153000Z\nEXDATE:20250115T120000Z"
        );
    }

    #[test]
    fn add_until_datetime_ends_before_when_not_exact() {
        // 2025-09-30T15:30:00Z; using UTC timezone should set to previous day 23:59:59 UTC
        let timestamp = Utc
            .with_ymd_and_hms(2025, 9, 30, 15, 30, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, false, "UTC");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250929T235959Z");
    }

    #[test]
    fn add_until_datetime_saturates_at_epoch_zero() {
        // If timestamp < 1s, previous day's 23:59:59 in UTC should floor to epoch start
        let timestamp = 500.0f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, false, "UTC");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=19691231T235959Z");
    }

    #[test]
    fn add_until_date_first_of_month_subtracts_to_prev_month_end() {
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_date(recurrence, "2025-10-01", false);
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250930");

        // Year boundary: Jan 1 -> Dec 31 of previous year
        let result2 = add_until_date(recurrence, "2025-01-01", false);
        assert_eq!(result2, "RRULE:FREQ=DAILY;UNTIL=20241231");
    }

    #[test]
    fn add_until_date_first_of_month_replaces_existing_until_correctly() {
        let recurrence = "RRULE:FREQ=DAILY;UNTIL=20250115";
        let result = add_until_date(recurrence, "2025-10-01", false);
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250930");
    }

    #[test]
    fn fixes_date_only_until_using_dtstart_wall_clock() {
        // DTSTART local: 2025-05-20 15:00 America/Los_Angeles (PDT, UTC-7) => 22:00Z
        let start_utc = Utc
            .with_ymd_and_hms(2025, 5, 20, 22, 0, 0)
            .single()
            .unwrap();
        let start_epoch = start_utc.timestamp();

        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU";
        let fixed = fix_datetime_recurrence(input, start_epoch, "America/Los_Angeles");

        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z;BYDAY=TU");
    }

    #[test]
    fn fixes_local_datetime_until_without_z() {
        // start time irrelevant for this case; keep same as above
        let start_utc = Utc
            .with_ymd_and_hms(2025, 5, 20, 22, 0, 0)
            .single()
            .unwrap();
        let start_epoch = start_utc.timestamp();

        // Local LA 2025-06-17 23:59:59 PDT => 2025-06-18 06:59:59Z
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T235959;BYDAY=TU";
        let fixed = fix_datetime_recurrence(input, start_epoch, "America/Los_Angeles");

        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250618T065959Z;BYDAY=TU");
    }

    #[test]
    fn leaves_utc_until_with_z_unchanged() {
        let start_utc = Utc
            .with_ymd_and_hms(2025, 5, 20, 22, 0, 0)
            .single()
            .unwrap();
        let start_epoch = start_utc.timestamp();

        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z;BYDAY=TU";
        let fixed = fix_datetime_recurrence(input, start_epoch, "America/Los_Angeles");

        assert_eq!(fixed, input);
    }
    #[test]
    fn add_until_datetime_timezone_conversion_example() {
        // Input UTC: 2025-09-10T14:00:00Z with Europe/Madrid -> local 16:00
        // Should set UNTIL to previous day 23:59:59 local -> 2025-09-09T23:59:59 Europe/Madrid
        // Then convert to UTC -> 2025-09-09T21:59:59Z
        let timestamp = Utc
            .with_ymd_and_hms(2025, 9, 10, 14, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, false, "Europe/Madrid");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250909T215959Z");
    }

    #[test]
    fn add_until_datetime_exact_ignores_timezone() {
        let timestamp = Utc
            .with_ymd_and_hms(2025, 9, 10, 14, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, true, "Europe/Madrid");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250910T140000Z");
    }

    #[test]
    fn add_until_datetime_east_of_utc_tokyo() {
        // UTC input: 2025-09-10T14:00:00Z -> Tokyo local 23:00 same day
        // Previous day 23:59:59 in Tokyo => 2025-09-09T23:59:59 JST -> 2025-09-09T14:59:59Z
        let timestamp = Utc
            .with_ymd_and_hms(2025, 9, 10, 14, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, false, "Asia/Tokyo");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250909T145959Z");
    }

    #[test]
    fn add_until_datetime_west_of_utc_los_angeles_winter() {
        // UTC input: 2025-01-10T12:00:00Z -> Los Angeles local 04:00 (PST, UTC-8)
        // Previous day 23:59:59 PST => 2025-01-09T23:59:59 PST -> 2025-01-10T07:59:59Z
        let timestamp = Utc
            .with_ymd_and_hms(2025, 1, 10, 12, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let result = add_until_datetime(recurrence, timestamp, false, "America/Los_Angeles");
        assert_eq!(result, "RRULE:FREQ=DAILY;UNTIL=20250110T075959Z");
    }
}

#[cfg(test)]
mod tests3 {
    // date UNTIL normalization tests
    use super::fix_date_recurrence;

    #[test]
    fn removes_time_from_datetime_with_z() {
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z;BYDAY=TU";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU");
    }

    #[test]
    fn removes_time_from_datetime_without_z() {
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T235959;BYDAY=TU";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU");
    }

    #[test]
    fn leaves_date_only_unchanged() {
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, input);
    }

    #[test]
    fn leaves_no_until_unchanged() {
        let input = "RRULE:FREQ=WEEKLY;BYDAY=TU";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, input);
    }

    #[test]
    fn handles_until_at_end_of_string() {
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250617");
    }

    #[test]
    fn handles_until_in_middle_of_string() {
        let input = "RRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z;BYDAY=TU;COUNT=10";
        let fixed = fix_date_recurrence(input);
        assert_eq!(fixed, "RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU;COUNT=10");
    }
}

#[cfg(test)]
mod tests4a {
    // split-fix tests for malformed recurrence
    use super::{fix_datetime_recurrence, fix_recurrence_split};
    use chrono::TimeZone;
    use chrono::Utc;

    #[test]
    fn splits_semicolon_separated_clauses_datetime() {
        let input = "EXDATE;TZID=Europe/Rome:20250402T163000,20250416T163000,20250430T163000,20250507T163000,20250604T163000,20250625T163000,20250709T163000,20250716T163000,20250820T163000;RRULE:FREQ=WEEKLY;BYDAY=WE";
        let expected = "EXDATE;TZID=Europe/Rome:20250402T163000,20250416T163000,20250430T163000,20250507T163000,20250604T163000,20250625T163000,20250709T163000,20250716T163000,20250820T163000\nRRULE:FREQ=WEEKLY;BYDAY=WE";
        assert_eq!(fix_recurrence_split(input), expected);
    }

    #[test]
    fn wrapper_calls_split_then_until() {
        // ensure wrapper can parse after split and perform until normalization
        let start_epoch = Utc
            .with_ymd_and_hms(2025, 5, 20, 22, 0, 0)
            .single()
            .unwrap()
            .timestamp();
        let input =
            "EXDATE;TZID=Europe/Rome:20250402T163000;RRULE:FREQ=WEEKLY;UNTIL=20250617;BYDAY=TU";
        let out = fix_datetime_recurrence(input, start_epoch, "America/Los_Angeles");
        assert_eq!(
            out,
            "EXDATE;TZID=Europe/Rome:20250402T163000\nRRULE:FREQ=WEEKLY;UNTIL=20250617T220000Z;BYDAY=TU"
        );
    }

    #[test]
    fn splits_semicolon_separated_clauses_date() {
        let input = "EXDATE;VALUE=DATE:20250402,20250416;RRULE:FREQ=WEEKLY;BYDAY=WE";
        let expected = "EXDATE;VALUE=DATE:20250402,20250416\nRRULE:FREQ=WEEKLY;BYDAY=WE";
        assert_eq!(fix_recurrence_split(input), expected);
    }
}

#[cfg(test)]
mod tests_exdate {
    use super::*;
    use chrono::TimeZone;

    #[test]
    fn add_exdate_adds_new_line_when_missing() {
        let recurrence = "RRULE:FREQ=DAILY";
        let ts = Utc
            .with_ymd_and_hms(2025, 1, 10, 12, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(out, "RRULE:FREQ=DAILY\nEXDATE:20250110T120000Z");
    }

    #[test]
    fn add_exdate_appends_to_existing_line() {
        let recurrence = "RRULE:FREQ=DAILY\nEXDATE:20250110T120000Z";
        let ts2 = Utc
            .with_ymd_and_hms(2025, 1, 11, 9, 30, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts2);
        assert_eq!(
            out,
            "RRULE:FREQ=DAILY\nEXDATE:20250110T120000Z,20250111T093000Z"
        );
    }

    #[test]
    fn add_exdate_does_not_duplicate_if_already_present() {
        let recurrence = "RRULE:FREQ=DAILY\nEXDATE:20250110T120000Z";
        let ts = Utc
            .with_ymd_and_hms(2025, 1, 10, 12, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(out, recurrence);
    }

    #[test]
    fn add_exdate_respects_existing_params() {
        let recurrence = "EXDATE;TZID=Europe/Rome:20250110T120000";
        let ts2 = Utc
            .with_ymd_and_hms(2025, 1, 11, 9, 30, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts2);
        assert_eq!(
            out,
            "EXDATE;TZID=Europe/Rome:20250110T120000,20250111T093000Z"
        );
    }

    #[test]
    fn add_exdate_handles_empty_recurrence() {
        let ts = Utc
            .with_ymd_and_hms(2025, 2, 1, 8, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime("", ts);
        assert_eq!(out, "EXDATE:20250201T080000Z");
    }

    #[test]
    fn add_exdate_uses_last_exdate_line() {
        let recurrence = "EXDATE:20250110T120000Z\nRRULE:FREQ=DAILY\nEXDATE:20250111T090000Z";
        let ts = Utc
            .with_ymd_and_hms(2025, 1, 12, 7, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(
            out,
            "EXDATE:20250110T120000Z\nRRULE:FREQ=DAILY\nEXDATE:20250111T090000Z,20250112T070000Z"
        );
    }

    #[test]
    fn add_exdate_skips_when_timestamp_invalid() {
        // from_timestamp_millis returns None for clearly out-of-range values
        let bad_ts = i64::MAX as f64;
        let recurrence = "RRULE:FREQ=DAILY";
        let out = add_exdate_datetime(recurrence, bad_ts);
        assert_eq!(out, recurrence);
    }

    #[test]
    fn add_exdate_handles_malformed_exdate_without_colon() {
        let recurrence = "RRULE:FREQ=DAILY\nEXDATE";
        let ts = Utc
            .with_ymd_and_hms(2025, 3, 5, 10, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(out, "RRULE:FREQ=DAILY\nEXDATE:20250305T100000Z");
    }

    #[test]
    fn add_exdate_does_not_confuse_suffix_match() {
        // Ensure we match full value tokens, not substrings
        let recurrence = "EXDATE:20250110T120000Z,20250110T120000";
        let ts = Utc
            .with_ymd_and_hms(2025, 1, 10, 12, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(out, recurrence);
    }

    #[test]
    fn add_exdate_datetime_ignores_recurrence_line_order() {
        // Same logical recurrence, different line orders should yield the
        // same EXDATE addition behavior.
        let ts = Utc
            .with_ymd_and_hms(2025, 4, 1, 9, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;

        let rec_a = "RRULE:FREQ=DAILY\nEXDATE:20250331T090000Z";
        let rec_b = "EXDATE:20250331T090000Z\nRRULE:FREQ=DAILY";

        let out_a = add_exdate_datetime(rec_a, ts);
        let out_b = add_exdate_datetime(rec_b, ts);

        assert_eq!(
            out_a,
            "RRULE:FREQ=DAILY\nEXDATE:20250331T090000Z,20250401T090000Z"
        );
        assert_eq!(
            out_b,
            "EXDATE:20250331T090000Z,20250401T090000Z\nRRULE:FREQ=DAILY"
        );
    }

    #[test]
    fn add_exdate_datetime_uses_last_exdate_regardless_of_other_order() {
        // Multiple EXDATE lines mixed with other properties: only the last
        // EXDATE line is extended.
        let ts = Utc
            .with_ymd_and_hms(2025, 4, 2, 9, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis() as f64;

        let recurrence = "DTSTART:20250301T090000Z\nEXDATE:20250310T090000Z\nRRULE:FREQ=DAILY\nEXDATE:20250320T090000Z";
        let out = add_exdate_datetime(recurrence, ts);
        assert_eq!(
            out,
            "DTSTART:20250301T090000Z\nEXDATE:20250310T090000Z\nRRULE:FREQ=DAILY\nEXDATE:20250320T090000Z,20250402T090000Z"
        );
    }

    #[test]
    fn add_exdate_date_adds_new_line_when_missing() {
        let recurrence = "RRULE:FREQ=DAILY";
        let out = add_exdate_date(recurrence, "2025-01-10");
        assert_eq!(out, "RRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250110");
    }

    #[test]
    fn add_exdate_date_appends_to_existing_value_date_line() {
        let recurrence = "RRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250110";
        let out = add_exdate_date(recurrence, "2025-01-11");
        assert_eq!(out, "RRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250110,20250111");
    }

    #[test]
    fn add_exdate_date_does_not_duplicate_existing_date_token() {
        let recurrence = "EXDATE;VALUE=DATE:20250110,20250111";
        let out = add_exdate_date(recurrence, "2025-01-10");
        assert_eq!(out, recurrence);
    }

    #[test]
    fn add_exdate_date_uses_last_value_date_line() {
        let recurrence = "EXDATE;VALUE=DATE:20250101\nRRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250110";
        let out = add_exdate_date(recurrence, "2025-01-15");
        assert_eq!(
            out,
            "EXDATE;VALUE=DATE:20250101\nRRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250110,20250115"
        );
    }

    #[test]
    fn add_exdate_date_handles_empty_recurrence() {
        let out = add_exdate_date("", "2025-03-05");
        assert_eq!(out, "EXDATE;VALUE=DATE:20250305");
    }

    #[test]
    fn add_exdate_date_invalid_date_returns_unchanged() {
        let recurrence = "RRULE:FREQ=DAILY";
        let out = add_exdate_date(recurrence, "not-a-date");
        assert_eq!(out, recurrence);
    }

    #[test]
    fn add_exdate_date_ignores_recurrence_line_order() {
        let rec_a = "RRULE:FREQ=WEEKLY\nEXDATE;VALUE=DATE:20250331";
        let rec_b = "EXDATE;VALUE=DATE:20250331\nRRULE:FREQ=WEEKLY";

        let out_a = add_exdate_date(rec_a, "2025-04-01");
        let out_b = add_exdate_date(rec_b, "2025-04-01");

        assert_eq!(
            out_a,
            "RRULE:FREQ=WEEKLY\nEXDATE;VALUE=DATE:20250331,20250401"
        );
        assert_eq!(
            out_b,
            "EXDATE;VALUE=DATE:20250331,20250401\nRRULE:FREQ=WEEKLY"
        );
    }

    #[test]
    fn add_exdate_date_uses_last_value_date_line_among_others() {
        let recurrence = "DTSTART;VALUE=DATE:20250301\nEXDATE;VALUE=DATE:20250305\nRRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250310";
        let out = add_exdate_date(recurrence, "2025-03-15");
        assert_eq!(
            out,
            "DTSTART;VALUE=DATE:20250301\nEXDATE;VALUE=DATE:20250305\nRRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250310,20250315"
        );
    }
}

#[cfg(test)]
mod tests_range_extension {
    use super::*;
    use chrono::TimeZone;

    // Helper to create a timestamp in milliseconds
    fn ts_ms(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) -> i64 {
        Utc.with_ymd_and_hms(year, month, day, hour, min, sec)
            .single()
            .unwrap()
            .timestamp_millis()
    }

    #[test]
    fn extends_range_for_yearly_recurrence_datetime() {
        // DTSTART: 2020-06-15, query range: 2025-01-01 to 2025-01-31 (no occurrences in Jan)
        // Should extend and find occurrence on 2025-06-15
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY",
            start,
            end,
            true,
            false,
        );

        // Should find at least 3 occurrences (2025, 2026, 2027) due to MIN_OCCURRENCES
        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences, got {}",
            result.len()
        );
        // First occurrence should be 2025-06-15
        assert_eq!(result[0], ts_ms(2025, 6, 15, 10, 0, 0));
    }

    #[test]
    fn extends_range_for_yearly_recurrence_date() {
        // DTSTART: 2020-06-15 (all-day), query range: 2025-01-01 to 2025-01-31

        let result = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY",
            "2025-01-01",
            "2025-01-31",
            true,
            false,
        );

        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences, got {}",
            result.len()
        );
        assert_eq!(result[0], "2025-06-15");
    }

    #[test]
    fn extends_range_for_every_49_months_datetime() {
        // Every 49 months (~4 years) - a very infrequent recurrence
        // DTSTART: 2020-01-15, query range: 2024-01-01 to 2024-01-31
        // First occurrence after DTSTART: 2024-02-15 (49 months from 2020-01)
        // Next: 2028-03-15 (49 months later)
        let dt_start = ts_ms(2020, 1, 15, 9, 0, 0);
        let start = ts_ms(2024, 1, 1, 0, 0, 0);
        let end = ts_ms(2024, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY;INTERVAL=49",
            start,
            end,
            true,
            false,
        );

        // Should extend and find occurrences
        assert!(
            !result.is_empty(),
            "Expected to find occurrences for every-49-months rule"
        );
    }

    #[test]
    fn extends_range_for_every_49_months_date() {
        // Every 49 months (~4 years) - all-day event
        let result = between_date_i64(
            "2020-01-15",
            "RRULE:FREQ=MONTHLY;INTERVAL=49",
            "2024-01-01",
            "2024-01-31",
            true,
            false,
        );

        assert!(
            !result.is_empty(),
            "Expected to find occurrences for every-49-months rule"
        );
    }

    #[test]
    fn does_not_extend_range_when_until_present_datetime() {
        // With UNTIL, should NOT extend the range even if no occurrences found
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        // UNTIL is before the query range, so no occurrences should be found
        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;UNTIL=20240101T000000Z",
            start,
            end,
            true,
            false,
        );

        assert!(
            result.is_empty(),
            "Should not extend range when UNTIL is present"
        );
    }

    #[test]
    fn does_not_extend_range_when_until_present_date() {
        let result = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY;UNTIL=20240101",
            "2025-01-01",
            "2025-01-31",
            true,
            false,
        );

        assert!(
            result.is_empty(),
            "Should not extend range when UNTIL is present"
        );
    }

    #[test]
    fn count_with_past_occurrences_returns_empty_datetime() {
        // COUNT=2 means only 2020-06-15 and 2021-06-15 exist (both in the past)
        // Even with extend_end=true, there are no future occurrences to find
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=2",
            start,
            end,
            true,
            false,
        );

        // Empty because all COUNT occurrences are in the past (2020, 2021)
        assert!(
            result.is_empty(),
            "Expected empty since COUNT=2 occurrences are in the past"
        );
    }

    #[test]
    fn count_with_past_occurrences_returns_empty_date() {
        // COUNT=2 means only 2020-06-15 and 2021-06-15 exist (both in the past)
        let result = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY;COUNT=2",
            "2025-01-01",
            "2025-01-31",
            true,
            false,
        );

        // Empty because all COUNT occurrences are in the past
        assert!(
            result.is_empty(),
            "Expected empty since COUNT=2 occurrences are in the past"
        );
    }

    #[test]
    fn extends_range_for_count_with_future_occurrences_datetime() {
        // COUNT=10 means occurrences from 2020 to 2029 (10 years)
        // Query range is Jan 2025, but 2025-06-15 through 2029-06-15 are valid future occurrences
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=10",
            start,
            end,
            true,
            false,
        );

        // Should extend and find remaining occurrences (2025-2029 = 5 occurrences)
        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences for COUNT=10 rule with future occurrences, got {}",
            result.len()
        );
        // First should be 2025-06-15
        assert_eq!(result[0], ts_ms(2025, 6, 15, 10, 0, 0));
    }

    #[test]
    fn extends_range_for_count_with_future_occurrences_date() {
        // COUNT=10 for all-day event
        let result = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY;COUNT=10",
            "2025-01-01",
            "2025-01-31",
            true,
            false,
        );

        // Should extend and find remaining occurrences
        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences for COUNT=10 rule with future occurrences, got {}",
            result.len()
        );
        assert_eq!(result[0], "2025-06-15");
    }

    #[test]
    fn returns_occurrences_in_original_range_without_extension_if_enough() {
        // Daily recurrence - should find plenty in original range, no extension needed
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 10, 23, 59, 59);

        let result =
            between_datetime_i64(dt_start, "UTC", "RRULE:FREQ=DAILY", start, end, true, false);

        // Should have 10 occurrences (Jan 1-10), all within original range
        assert_eq!(result.len(), 10);
        assert_eq!(result[0], ts_ms(2025, 1, 1, 10, 0, 0));
        assert_eq!(result[9], ts_ms(2025, 1, 10, 10, 0, 0));
    }

    #[test]
    fn extends_range_for_biennial_recurrence() {
        // Every 2 years - query range has no occurrences initially
        let dt_start = ts_ms(2020, 3, 20, 14, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;INTERVAL=2",
            start,
            end,
            true,
            false,
        );

        // Should extend and find 2026, 2028, 2030 (every 2 years from 2020)
        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences, got {}",
            result.len()
        );
        // First occurrence should be 2026-03-20 (2020 + 6 years = 3 intervals of 2 years)
        assert_eq!(result[0], ts_ms(2026, 3, 20, 14, 0, 0));
    }

    #[test]
    fn extends_range_when_fewer_than_min_occurrences_found() {
        // Monthly recurrence, but query range only covers 2 months
        let dt_start = ts_ms(2025, 1, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 2, 28, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY",
            start,
            end,
            true,
            false,
        );

        // Original range only has 2 occurrences (Jan 15, Feb 15)
        // Should extend to find at least 3
        assert!(
            result.len() >= 3,
            "Expected at least 3 occurrences, got {}",
            result.len()
        );
    }

    #[test]
    fn does_not_extend_when_extend_end_is_false() {
        // With extend_end=false, should NOT extend even for yearly recurrence
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY",
            start,
            end,
            false,
            false,
        );

        // Should be empty since no occurrences in Jan and extend_end=false
        assert!(
            result.is_empty(),
            "Should not extend range when extend_end is false"
        );
    }

    #[test]
    fn does_not_extend_when_extend_end_is_false_date() {
        let result = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY",
            "2025-01-01",
            "2025-01-31",
            false,
            false,
        );

        assert!(
            result.is_empty(),
            "Should not extend range when extend_end is false"
        );
    }

    #[test]
    fn compare_extend_true_vs_false_yearly_datetime() {
        // Compare behavior with extend_end=true vs false for yearly recurrence
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY",
            start,
            end,
            true,
            false,
        );

        // Without extend: no occurrences in January
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find at least 3 occurrences (2025-06-15, 2026-06-15, 2027-06-15)
        assert!(
            result_with_extend.len() >= 3,
            "With extend: expected at least 3 occurrences, got {}",
            result_with_extend.len()
        );

        // Verify the found occurrences are correct
        assert_eq!(result_with_extend[0], ts_ms(2025, 6, 15, 10, 0, 0));
    }

    #[test]
    fn compare_extend_true_vs_false_yearly_date() {
        // Compare behavior with extend_end=true vs false for yearly all-day recurrence
        let result_no_extend = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY",
            "2025-01-01",
            "2025-01-31",
            false,
            false,
        );
        let result_with_extend = between_date_i64(
            "2020-06-15",
            "RRULE:FREQ=YEARLY",
            "2025-01-01",
            "2025-01-31",
            true,
            false,
        );

        // Without extend: no occurrences in January
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find at least 3 occurrences
        assert!(
            result_with_extend.len() >= 3,
            "With extend: expected at least 3 occurrences, got {}",
            result_with_extend.len()
        );

        assert_eq!(result_with_extend[0], "2025-06-15");
    }

    #[test]
    fn compare_extend_true_vs_false_monthly_datetime() {
        // Compare behavior for monthly recurrence with only 2 occurrences in original range
        let dt_start = ts_ms(2025, 1, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 2, 28, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY",
            start,
            end,
            true,
            false,
        );

        // Without extend: only 2 occurrences (Jan 15, Feb 15)
        assert_eq!(
            result_no_extend.len(),
            2,
            "Without extend: expected 2 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find at least 3 occurrences
        assert!(
            result_with_extend.len() >= 3,
            "With extend: expected at least 3 occurrences, got {}",
            result_with_extend.len()
        );

        // Both should have the same first 2 occurrences
        assert_eq!(result_no_extend[0], result_with_extend[0]);
        assert_eq!(result_no_extend[1], result_with_extend[1]);
    }

    #[test]
    fn compare_extend_true_vs_false_biennial_datetime() {
        // Compare behavior for every 2 years recurrence
        let dt_start = ts_ms(2020, 3, 20, 14, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;INTERVAL=2",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;INTERVAL=2",
            start,
            end,
            true,
            false,
        );

        // Without extend: no occurrences in Jan 2025 (next is 2026-03-20)
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find 2026, 2028, 2030
        assert!(
            result_with_extend.len() >= 3,
            "With extend: expected at least 3 occurrences, got {}",
            result_with_extend.len()
        );

        assert_eq!(result_with_extend[0], ts_ms(2026, 3, 20, 14, 0, 0));
    }

    #[test]
    fn compare_extend_true_vs_false_every_49_months() {
        // Compare behavior for very infrequent recurrence (every 49 months)
        let dt_start = ts_ms(2020, 1, 15, 9, 0, 0);
        let start = ts_ms(2024, 1, 1, 0, 0, 0);
        let end = ts_ms(2024, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY;INTERVAL=49",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY;INTERVAL=49",
            start,
            end,
            true,
            false,
        );

        // Without extend: no occurrences in Jan 2024
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find some occurrences
        assert!(
            !result_with_extend.is_empty(),
            "With extend: expected some occurrences for every-49-months rule"
        );
    }

    #[test]
    fn extend_has_no_effect_when_enough_occurrences_in_range() {
        // When there are already enough occurrences, extend_end should have no effect
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 10, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        let result_with_extend =
            between_datetime_i64(dt_start, "UTC", "RRULE:FREQ=DAILY", start, end, true, false);

        // Both should have exactly 10 occurrences (Jan 1-10) - no difference
        assert_eq!(result_no_extend.len(), 10);
        assert_eq!(result_with_extend.len(), 10);
        assert_eq!(result_no_extend, result_with_extend);
    }

    #[test]
    fn until_in_past_returns_empty_regardless_of_extend() {
        // When UNTIL is in the past, no occurrences exist - both should be empty
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;UNTIL=20240101T000000Z",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;UNTIL=20240101T000000Z",
            start,
            end,
            true,
            false,
        );

        // Both should be empty - UNTIL ended before our query range
        assert!(result_no_extend.is_empty());
        assert!(result_with_extend.is_empty());
        assert_eq!(result_no_extend, result_with_extend);
    }

    #[test]
    fn until_in_future_extends_to_find_occurrences() {
        // When UNTIL is in the future, extension should find occurrences up to UNTIL
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0); // June 15, 2020
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        // UNTIL is 2028 - so occurrences exist in 2025, 2026, 2027
        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;UNTIL=20280101T000000Z",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;UNTIL=20280101T000000Z",
            start,
            end,
            true,
            false,
        );

        // Without extend: no occurrences in Jan 2025 (next is June 2025)
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find 2025-06-15, 2026-06-15, 2027-06-15
        assert_eq!(
            result_with_extend.len(),
            3,
            "With extend: expected 3 occurrences, got {}",
            result_with_extend.len()
        );
        assert_eq!(result_with_extend[0], ts_ms(2025, 6, 15, 10, 0, 0));
        assert_eq!(result_with_extend[1], ts_ms(2026, 6, 15, 10, 0, 0));
        assert_eq!(result_with_extend[2], ts_ms(2027, 6, 15, 10, 0, 0));
    }

    #[test]
    fn compare_extend_true_vs_false_count_with_future_occurrences() {
        // COUNT=10 has future occurrences - extension should find them
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=10",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=10",
            start,
            end,
            true,
            false,
        );

        // Without extend: no occurrences in Jan 2025
        assert!(
            result_no_extend.is_empty(),
            "Without extend: expected 0 occurrences, got {}",
            result_no_extend.len()
        );

        // With extend: should find future occurrences (2025-2029)
        assert!(
            result_with_extend.len() >= 3,
            "With extend: expected at least 3 occurrences, got {}",
            result_with_extend.len()
        );
    }

    #[test]
    fn count_past_occurrences_same_result_with_or_without_extend() {
        // When COUNT occurrences are all in the past, extend has no effect
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result_no_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=2",
            start,
            end,
            false,
            false,
        );
        let result_with_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY;COUNT=2",
            start,
            end,
            true,
            false,
        );

        // Both should be empty - no future occurrences exist
        assert!(result_no_extend.is_empty());
        assert!(result_with_extend.is_empty());
        assert_eq!(result_no_extend, result_with_extend);
    }
}

#[cfg(test)]
mod tests_between_edge_cases {
    use super::*;

    fn ts_ms(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) -> i64 {
        chrono::Utc
            .with_ymd_and_hms(year, month, day, hour, min, sec)
            .unwrap()
            .timestamp_millis()
    }

    // ==================== between_datetime_i64 edge cases ====================

    #[test]
    fn datetime_empty_recurrence_returns_empty() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 12, 31, 23, 59, 59);

        let result = between_datetime_i64(dt_start, "UTC", "", start, end, false, false);
        assert!(result.is_empty());
    }

    #[test]
    fn datetime_invalid_recurrence_returns_empty() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 12, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "INVALID_RRULE_STRING",
            start,
            end,
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn datetime_start_equals_end_single_occurrence() {
        // Query for exact moment of an occurrence
        let dt_start = ts_ms(2025, 6, 15, 10, 0, 0);
        let exact_moment = ts_ms(2025, 6, 15, 10, 0, 0);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            exact_moment,
            exact_moment,
            false,
            false,
        );
        assert_eq!(result.len(), 1);
        assert_eq!(result[0], exact_moment);
    }

    #[test]
    fn datetime_start_after_end_returns_empty() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 12, 31, 0, 0, 0);
        let end = ts_ms(2025, 1, 1, 0, 0, 0); // end before start

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn datetime_dtstart_after_range_returns_empty() {
        let dt_start = ts_ms(2030, 1, 1, 10, 0, 0); // starts in 2030
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 12, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn datetime_dtstart_before_range_finds_occurrences() {
        let dt_start = ts_ms(2020, 1, 1, 10, 0, 0); // starts in 2020
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 5, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert_eq!(result.len(), 5);
        assert_eq!(result[0], ts_ms(2025, 1, 1, 10, 0, 0));
    }

    #[test]
    fn datetime_weekly_correct_occurrences() {
        let dt_start = ts_ms(2025, 1, 6, 9, 0, 0); // Monday Jan 6
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=WEEKLY;BYDAY=MO",
            start,
            end,
            false,
            false,
        );
        // Jan 2025 Mondays: 6, 13, 20, 27
        assert_eq!(result.len(), 4);
        assert_eq!(result[0], ts_ms(2025, 1, 6, 9, 0, 0));
        assert_eq!(result[1], ts_ms(2025, 1, 13, 9, 0, 0));
        assert_eq!(result[2], ts_ms(2025, 1, 20, 9, 0, 0));
        assert_eq!(result[3], ts_ms(2025, 1, 27, 9, 0, 0));
    }

    #[test]
    fn datetime_monthly_bymonthday() {
        let dt_start = ts_ms(2025, 1, 15, 14, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 6, 30, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY;BYMONTHDAY=15",
            start,
            end,
            false,
            false,
        );
        assert_eq!(result.len(), 6);
        assert_eq!(result[0], ts_ms(2025, 1, 15, 14, 0, 0));
        assert_eq!(result[5], ts_ms(2025, 6, 15, 14, 0, 0));
    }

    #[test]
    fn datetime_with_exdate_excludes_date() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 5, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY\nEXDATE:20250103T100000Z",
            start,
            end,
            false,
            false,
        );
        // Should have 4 occurrences (1, 2, 4, 5) - Jan 3 is excluded
        assert_eq!(result.len(), 4);
        assert!(!result.contains(&ts_ms(2025, 1, 3, 10, 0, 0)));
    }

    #[test]
    fn datetime_timezone_europe_london() {
        let dt_start = ts_ms(2025, 6, 15, 9, 0, 0); // 9:00 UTC = 10:00 London (BST)
        let start = ts_ms(2025, 6, 1, 0, 0, 0);
        let end = ts_ms(2025, 6, 30, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "Europe/London",
            "RRULE:FREQ=WEEKLY;BYDAY=SU",
            start,
            end,
            false,
            false,
        );
        // Should find Sunday occurrences in June 2025
        assert!(!result.is_empty(), "Should find some Sunday occurrences");
    }

    #[test]
    fn datetime_count_limits_occurrences() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 12, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY;COUNT=5",
            start,
            end,
            false,
            false,
        );
        assert_eq!(result.len(), 5);
    }

    #[test]
    fn datetime_interval_every_3_days() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 15, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY;INTERVAL=3",
            start,
            end,
            false,
            false,
        );
        // Jan 1, 4, 7, 10, 13 = 5 occurrences
        assert_eq!(result.len(), 5);
        assert_eq!(result[0], ts_ms(2025, 1, 1, 10, 0, 0));
        assert_eq!(result[1], ts_ms(2025, 1, 4, 10, 0, 0));
        assert_eq!(result[4], ts_ms(2025, 1, 13, 10, 0, 0));
    }

    #[test]
    fn datetime_boundary_occurrence_at_start() {
        let dt_start = ts_ms(2025, 1, 1, 0, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0); // exact match
        let end = ts_ms(2025, 1, 2, 0, 0, 0);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert!(result.contains(&ts_ms(2025, 1, 1, 0, 0, 0)));
    }

    #[test]
    fn datetime_boundary_occurrence_at_end() {
        let dt_start = ts_ms(2025, 1, 1, 0, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 2, 0, 0, 0); // exact match with second occurrence

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert!(result.contains(&ts_ms(2025, 1, 2, 0, 0, 0)));
    }

    #[test]
    fn datetime_with_exdate_and_timezone() {
        // Test case from user: betweenDatetime with EXDATE in different timezone
        let dt_start = ts_ms(2025, 12, 12, 6, 30, 0);
        let start = ts_ms(2025, 12, 12, 0, 0, 0);
        let end = ts_ms(2025, 12, 22, 0, 0, 0);

        let result = between_datetime_i64(
            dt_start,
            "Europe/Bucharest",
            "RRULE:FREQ=WEEKLY;BYDAY=SA\nEXDATE;TZID=Europe/Bucharest:20251212T083000",
            start,
            end,
            false,
            true,
        );

        // Expected: 2025-12-13T06:30:00.000Z, 2025-12-20T06:30:00.000Z
        // (2025-12-12T06:30:00.000Z is excluded by EXDATE)
        let expected = vec![ts_ms(2025, 12, 13, 6, 30, 0), ts_ms(2025, 12, 20, 6, 30, 0)];
        assert_eq!(result, expected);
    }

    // ==================== between_date_i64 edge cases ====================

    #[test]
    fn date_empty_recurrence_returns_empty() {
        let result = between_date_i64("2025-01-01", "", "2025-01-01", "2025-12-31", false, false);
        assert!(result.is_empty());
    }

    #[test]
    fn date_invalid_recurrence_returns_empty() {
        let result = between_date_i64(
            "2025-01-01",
            "INVALID_RRULE",
            "2025-01-01",
            "2025-12-31",
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn date_invalid_dtstart_format_returns_empty() {
        let result = between_date_i64(
            "not-a-date",
            "RRULE:FREQ=DAILY",
            "2025-01-01",
            "2025-12-31",
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn date_daily_correct_format() {
        // Use a range that starts well before dtstart to avoid timezone edge cases
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=DAILY",
            "2025-01-01",
            "2025-01-10",
            false,
            false,
        );
        // Should return dates in YYYY-MM-DD format
        assert!(!result.is_empty(), "Should find daily occurrences");
        // All results should be valid date strings
        for date in &result {
            assert!(date.len() == 10, "Date should be in YYYY-MM-DD format");
            assert!(
                date.starts_with("2025-01-"),
                "Date should be in January 2025"
            );
        }
    }

    #[test]
    fn date_weekly_multiple_days() {
        // Starts on Wednesday Jan 1, recurs on Mon and Wed
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=WEEKLY;BYDAY=MO,WE",
            "2025-01-01",
            "2025-01-31",
            false,
            false,
        );
        // Should find multiple occurrences of Mon and Wed in January
        assert!(!result.is_empty(), "Should find Mon/Wed occurrences");
        // Check that we have a mix of days
        let has_monday = result.iter().any(|d| {
            d == "2025-01-06" || d == "2025-01-13" || d == "2025-01-20" || d == "2025-01-27"
        });
        let has_wednesday = result.iter().any(|d| {
            d == "2025-01-01"
                || d == "2025-01-08"
                || d == "2025-01-15"
                || d == "2025-01-22"
                || d == "2025-01-29"
        });
        assert!(
            has_monday || has_wednesday,
            "Should find at least some Mon or Wed"
        );
    }

    #[test]
    fn date_monthly_last_day() {
        let result = between_date_i64(
            "2025-01-31",
            "RRULE:FREQ=MONTHLY;BYMONTHDAY=-1",
            "2025-01-01",
            "2025-06-30",
            false,
            false,
        );
        // Last days: Jan 31, Feb 28, Mar 31, Apr 30, May 31, Jun 30
        assert_eq!(result.len(), 6);
        assert!(result.contains(&"2025-01-31".to_string()));
        assert!(result.contains(&"2025-02-28".to_string()));
        assert!(result.contains(&"2025-04-30".to_string()));
    }

    #[test]
    fn date_yearly_leap_year() {
        let result = between_date_i64(
            "2024-02-29",
            "RRULE:FREQ=YEARLY;BYMONTH=2;BYMONTHDAY=29",
            "2024-01-01",
            "2028-12-31",
            false,
            false,
        );
        // Only leap years: 2024, 2028
        assert_eq!(result.len(), 2);
        assert!(result.contains(&"2024-02-29".to_string()));
        assert!(result.contains(&"2028-02-29".to_string()));
    }

    #[test]
    fn date_with_exdate_excludes() {
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=DAILY\nEXDATE;VALUE=DATE:20250105",
            "2025-01-01",
            "2025-01-10",
            false,
            false,
        );
        // 10 days minus 1 excluded = 9
        assert_eq!(result.len(), 9);
        assert!(!result.contains(&"2025-01-05".to_string()));
    }

    #[test]
    fn date_count_limits_occurrences() {
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=WEEKLY;COUNT=4",
            "2025-01-01",
            "2025-12-31",
            false,
            false,
        );
        // COUNT=4 limits to 4 occurrences (or fewer if they fall outside range)
        assert!(
            result.len() <= 4,
            "COUNT=4 should limit to at most 4 occurrences"
        );
        assert!(!result.is_empty(), "Should find some occurrences");
    }

    #[test]
    fn date_until_limits_occurrences() {
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=WEEKLY;UNTIL=20250201",
            "2025-01-01",
            "2025-12-31",
            false,
            false,
        );
        // UNTIL limits occurrences to before Feb 1
        assert!(
            !result.is_empty(),
            "Should find some occurrences before UNTIL"
        );
        // All dates should be in January
        for date in &result {
            assert!(
                date.starts_with("2025-01"),
                "All dates should be in January 2025"
            );
        }
    }

    #[test]
    fn date_dtstart_in_future_returns_empty_for_past_range() {
        let result = between_date_i64(
            "2025-01-01",
            "RRULE:FREQ=DAILY",
            "2020-01-01",
            "2020-12-31",
            false,
            false,
        );
        assert!(result.is_empty());
    }

    #[test]
    fn date_f64_wrapper_works_correctly() {
        let result = between_date_f64(
            "2025-01-01",
            "RRULE:FREQ=DAILY",
            "2025-01-01",
            "2025-01-10",
            false,
            false,
        );
        assert!(!result.is_empty(), "Should find daily occurrences");
        // All results should be valid date strings in January 2025
        for date in &result {
            assert!(
                date.starts_with("2025-01-"),
                "Date should be in January 2025"
            );
        }
    }

    #[test]
    fn datetime_f64_wrapper_works_correctly() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0) as f64;
        let start = ts_ms(2025, 1, 1, 0, 0, 0) as f64;
        let end = ts_ms(2025, 1, 5, 23, 59, 59) as f64;

        let result = between_datetime_f64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        assert_eq!(result.len(), 5);
        // Verify first result is the expected timestamp
        assert_eq!(result[0], ts_ms(2025, 1, 1, 10, 0, 0) as f64);
    }

    // ==================== Extension behavior edge cases ====================

    #[test]
    fn extend_stops_at_max_range() {
        // Very infrequent recurrence that would need many extensions
        let dt_start = ts_ms(2020, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        // Every 100 months (~8.3 years) - very infrequent
        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=MONTHLY;INTERVAL=100",
            start,
            end,
            true,
            false,
        );
        // Should not hang or crash - may return empty or limited results
        // The important thing is it terminates
        assert!(result.len() <= MIN_OCCURRENCES + 1);
    }

    #[test]
    fn extend_finds_exactly_min_occurrences_when_possible() {
        // Yearly recurrence starting June 2020
        let dt_start = ts_ms(2020, 6, 15, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 31, 23, 59, 59);

        let result = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=YEARLY",
            start,
            end,
            true,
            false,
        );
        // Should find at least MIN_OCCURRENCES (3): 2025, 2026, 2027, etc.
        assert!(
            result.len() >= MIN_OCCURRENCES,
            "Expected at least {} occurrences, got {}",
            MIN_OCCURRENCES,
            result.len()
        );
    }

    #[test]
    fn no_extension_when_enough_in_range() {
        let dt_start = ts_ms(2025, 1, 1, 10, 0, 0);
        let start = ts_ms(2025, 1, 1, 0, 0, 0);
        let end = ts_ms(2025, 1, 10, 23, 59, 59);

        let without_extend = between_datetime_i64(
            dt_start,
            "UTC",
            "RRULE:FREQ=DAILY",
            start,
            end,
            false,
            false,
        );
        let with_extend =
            between_datetime_i64(dt_start, "UTC", "RRULE:FREQ=DAILY", start, end, true, false);

        // Both should be identical - 10 occurrences, no need to extend
        assert_eq!(without_extend, with_extend);
        assert_eq!(without_extend.len(), 10);
    }
}

#[cfg(test)]
mod tests_include_dtstart {
    use super::*;
    use chrono::{TimeZone, Utc};
    use chrono_tz::Tz;

    fn ts_ms_utc(year: i32, month: u32, day: u32, hour: u32, min: u32, sec: u32) -> i64 {
        Utc.with_ymd_and_hms(year, month, day, hour, min, sec)
            .single()
            .unwrap()
            .timestamp_millis()
    }

    #[test]
    fn datetime_include_dtstart_matches_google_for_mismatched_byday_count() {
        // DTSTART;TZID=Europe/Berlin:20240530T200000 (Thu)
        // RRULE:FREQ=WEEKLY;COUNT=3;BYDAY=WE
        // Google shows 4 instances: DTSTART + 3 Wednesdays.
        let tz: Tz = "Europe/Berlin".parse().unwrap();
        let dtstart_local = tz.with_ymd_and_hms(2024, 5, 30, 20, 0, 0).single().unwrap();
        let dt_start_utc_ms = dtstart_local.with_timezone(&Utc).timestamp_millis();

        let start = ts_ms_utc(2024, 5, 1, 0, 0, 0);
        let end = ts_ms_utc(2024, 6, 30, 23, 59, 59);

        let rrule = "RRULE:FREQ=WEEKLY;COUNT=3;INTERVAL=1;BYDAY=WE";

        let without = between_datetime_i64(
            dt_start_utc_ms,
            "Europe/Berlin",
            rrule,
            start,
            end,
            false, // extend_end
            false, // include_dtstart
        );

        let with = between_datetime_i64(
            dt_start_utc_ms,
            "Europe/Berlin",
            rrule,
            start,
            end,
            false, // extend_end
            true,  // include_dtstart
        );

        // Expected timestamps (Berlin 20:00 == 18:00Z in May/June 2024)
        let exp_dtstart = ts_ms_utc(2024, 5, 30, 18, 0, 0);
        let exp_we1 = ts_ms_utc(2024, 6, 5, 18, 0, 0);
        let exp_we2 = ts_ms_utc(2024, 6, 12, 18, 0, 0);
        let exp_we3 = ts_ms_utc(2024, 6, 19, 18, 0, 0);

        // With include_dtstart we want exactly the Google-like set.
        assert_eq!(with, vec![exp_dtstart, exp_we1, exp_we2, exp_we3]);

        // Without include_dtstart: should NOT contain DTSTART (this is the mismatch case).
        assert!(!without.contains(&exp_dtstart));
        assert_eq!(without, vec![exp_we1, exp_we2, exp_we3]);
    }

    #[test]
    fn date_include_dtstart_matches_google_for_mismatched_byday_count() {
        // DTSTART;VALUE=DATE:20240530 (Thu)
        // RRULE:FREQ=WEEKLY;COUNT=3;BYDAY=WE
        let rrule = "RRULE:FREQ=WEEKLY;COUNT=3;INTERVAL=1;BYDAY=WE";

        let without = between_date_i64(
            "2024-05-30",
            rrule,
            "2024-05-01",
            "2024-06-30",
            false, // extend_end
            false, // include_dtstart
        );

        let with = between_date_i64(
            "2024-05-30",
            rrule,
            "2024-05-01",
            "2024-06-30",
            false, // extend_end
            true,  // include_dtstart
        );

        assert_eq!(
            with,
            vec![
                "2024-05-30".to_string(),
                "2024-06-05".to_string(),
                "2024-06-12".to_string(),
                "2024-06-19".to_string(),
            ]
        );

        assert_eq!(
            without,
            vec![
                "2024-06-05".to_string(),
                "2024-06-12".to_string(),
                "2024-06-19".to_string(),
            ]
        );
    }

    #[test]
    fn test_is_datetime_excluded() {
        // Test with EXDATE containing the timestamp
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE:20231212T120000Z";
        let ts = Utc
            .with_ymd_and_hms(2023, 12, 12, 12, 0, 0)
            .single()
            .unwrap()
            .timestamp_millis();
        assert!(is_datetime_excluded(recurrence, ts, "UTC"));

        // Test with EXDATE not containing the timestamp
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE:20231213T120000Z";
        assert!(!is_datetime_excluded(recurrence, ts, "UTC"));
        // Test with multiple EXDATE values
        let recurrence =
            "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE:20231211T120000Z,20231212T120000Z,20231213T120000Z";
        assert!(is_datetime_excluded(recurrence, ts, "UTC"));

        // Test with no EXDATE
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO";
        assert!(!is_datetime_excluded(recurrence, ts, "UTC"));
        // Test with EXDATE;VALUE=DATE (should not match datetime)
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE;VALUE=DATE:20231212";
        assert!(!is_datetime_excluded(recurrence, ts, "UTC"));
    }

    #[test]
    fn test_is_date_excluded() {
        // Test with EXDATE;VALUE=DATE containing the date
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE;VALUE=DATE:20231212";
        assert!(is_date_excluded(recurrence, "2023-12-12"));

        // Test with EXDATE;VALUE=DATE not containing the date
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE;VALUE=DATE:20231213";
        assert!(!is_date_excluded(recurrence, "2023-12-12"));

        // Test with multiple EXDATE;VALUE=DATE values
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE;VALUE=DATE:20231211,20231212,20231213";
        assert!(is_date_excluded(recurrence, "2023-12-12"));

        // Test with no EXDATE
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO";
        assert!(!is_date_excluded(recurrence, "2023-12-12"));

        // Test with EXDATE datetime (should not match date)
        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=MO\nEXDATE:20231212T120000Z";
        assert!(!is_date_excluded(recurrence, "2023-12-12"));
    }

    #[test]
    fn test_is_datetime_excluded_tzid_without_seconds() {
        let tz: chrono_tz::Tz = "Europe/Bucharest".parse().unwrap();

        // 2025-12-12 08:30:00 +02:00
        let dt_local = tz
            .with_ymd_and_hms(2025, 12, 12, 8, 30, 0)
            .single()
            .unwrap();
        let ts = dt_local.with_timezone(&Utc).timestamp_millis();

        let recurrence = "RRULE:FREQ=WEEKLY;BYDAY=SA\nEXDATE;TZID=Europe/Bucharest:20251212T083000";
        assert!(is_datetime_excluded(recurrence, ts, "Europe/Bucharest"));
    }
}