office2pdf 0.6.5

use std::collections::HashMap;

use crate::ir::{Color, DataBarInfo};
use crate::parser::xlsx::cond_fmt_raw::{RawCondFmtHint, RawCondFmtHints};
use crate::parser::xlsx::{CellPos, CellRange, parse_cell_ref};
use crate::parser::xml_util;

/// A conditional formatting override for a specific cell.
#[derive(Default)]
pub(crate) struct CondFmtOverride {
    pub background: Option<Color>,
    pub font_color: Option<Color>,
    pub bold: Option<bool>,
    pub data_bar: Option<DataBarInfo>,
    pub icon_text: Option<String>,
    pub icon_color: Option<Color>,
}

/// Parse an sqref string (e.g., "A1:C10" or "A1") into a list of CellRanges.
fn parse_sqref(sqref: &str) -> Vec<CellRange> {
    sqref
        .split_whitespace()
        .filter_map(|part| {
            if let Some((start_str, end_str)) = part.split_once(':') {
                let (sc, sr) = parse_cell_ref(start_str)?;
                let (ec, er) = parse_cell_ref(end_str)?;
                Some(CellRange {
                    start_col: sc,
                    start_row: sr,
                    end_col: ec,
                    end_row: er,
                })
            } else {
                let (c, r) = parse_cell_ref(part)?;
                Some(CellRange {
                    start_col: c,
                    start_row: r,
                    end_col: c,
                    end_row: r,
                })
            }
        })
        .collect()
}

use xml_util::parse_argb_color;

/// Try to get a numeric value from a cell.
fn cell_numeric_value(cell: &umya_spreadsheet::Cell) -> Option<f64> {
    let raw = cell.get_raw_value().to_string();
    if let Ok(v) = raw.parse::<f64>() {
        return Some(v);
    }
    cell.get_value().to_string().parse::<f64>().ok()
}

/// Text value of a cell, or `None` when the cell is not a string cell.
///
/// Excel keeps numbers and text as distinct comparison domains: a `cellIs` rule
/// whose operand is a quoted literal only ever matches string cells, so a
/// numeric cell holding `5` must not match the operand `"5"`.
fn cell_text_value(cell: &umya_spreadsheet::Cell) -> Option<String> {
    if cell.get_data_type() != "s" {
        return None;
    }
    let text = cell.get_value().to_string();
    if text.is_empty() {
        return None;
    }
    Some(text)
}

/// The right-hand operand of a `cellIs` rule.
///
/// Excel stores it as a formula string. A quoted literal (`"REORDER"`) selects
/// text comparison; anything else that parses as a number selects numeric
/// comparison.
enum CellIsOperand {
    Number(f64),
    Text(String),
}

/// Unquote an Excel string literal, collapsing the doubled `""` escape.
fn parse_quoted_literal(raw: &str) -> Option<String> {
    let inner: &str = raw.strip_prefix('"')?.strip_suffix('"')?;
    // A lone `"` inside would have terminated the literal early, so anything
    // that still contains an unescaped quote is not a single string literal.
    if inner.replace("\"\"", "").contains('"') {
        return None;
    }
    Some(inner.replace("\"\"", "\""))
}

/// Parse the operand of a `cellIs` rule from its formula.
fn parse_cell_is_operand(
    rule: &umya_spreadsheet::ConditionalFormattingRule,
) -> Option<CellIsOperand> {
    let raw: String = rule.get_formula()?.get_address_str();
    let trimmed: &str = raw.trim();
    if let Some(text) = parse_quoted_literal(trimmed) {
        return Some(CellIsOperand::Text(text));
    }
    trimmed.parse::<f64>().ok().map(CellIsOperand::Number)
}

/// Evaluate a CellIs conditional formatting rule against a numeric cell value.
fn evaluate_cell_is_rule(
    cell_val: f64,
    operator: &umya_spreadsheet::ConditionalFormattingOperatorValues,
    threshold: f64,
) -> bool {
    use umya_spreadsheet::ConditionalFormattingOperatorValues::*;

    match operator {
        GreaterThan => cell_val > threshold,
        GreaterThanOrEqual => cell_val >= threshold,
        LessThan => cell_val < threshold,
        LessThanOrEqual => cell_val <= threshold,
        Equal => (cell_val - threshold).abs() < f64::EPSILON,
        NotEqual => (cell_val - threshold).abs() >= f64::EPSILON,
        Between => cell_val >= threshold,
        NotBetween => cell_val < threshold,
        _ => false,
    }
}

/// Evaluate a CellIs rule against a text cell value.
///
/// Excel compares strings case-insensitively and orders them lexicographically.
fn evaluate_cell_is_text_rule(
    cell_text: &str,
    operator: &umya_spreadsheet::ConditionalFormattingOperatorValues,
    operand: &str,
) -> bool {
    use umya_spreadsheet::ConditionalFormattingOperatorValues::*;

    let lhs: String = cell_text.to_lowercase();
    let rhs: String = operand.to_lowercase();

    match operator {
        Equal => lhs == rhs,
        NotEqual => lhs != rhs,
        GreaterThan => lhs > rhs,
        GreaterThanOrEqual => lhs >= rhs,
        LessThan => lhs < rhs,
        LessThanOrEqual => lhs <= rhs,
        // Between/NotBetween need both operands; umya keeps only the last
        // formula, so the lower bound is unavailable for text ranges.
        _ => false,
    }
}

/// Extract formatting overrides from a conditional formatting rule's style.
fn extract_cond_fmt_style(rule: &umya_spreadsheet::ConditionalFormattingRule) -> CondFmtOverride {
    let mut result = CondFmtOverride::default();

    if let Some(style) = rule.get_style() {
        if let Some(bg) = style.get_background_color() {
            result.background = parse_argb_color(bg.get_argb());
        }
        // Differential formats (dxf) store solid CF fills in the pattern's
        // bgColor with no fgColor, which get_background_color misses.
        if result.background.is_none()
            && let Some(bg) = style
                .get_fill()
                .and_then(|fill| fill.get_pattern_fill()?.get_background_color())
        {
            result.background = parse_argb_color(bg.get_argb());
        }
        if let Some(font) = style.get_font() {
            if *font.get_bold() {
                result.bold = Some(true);
            }
            let color_argb = font.get_color().get_argb();
            if !color_argb.is_empty() && color_argb != "FF000000" {
                result.font_color = parse_argb_color(color_argb);
            }
        }
    }

    result
}

/// Parse an ARGB hex string from umya Color into an IR Color.
fn parse_umya_color_argb(color: &umya_spreadsheet::Color) -> Option<Color> {
    let argb = color.get_argb();
    if argb.is_empty() {
        return None;
    }
    parse_argb_color(argb)
}

/// Interpolate between two colors based on a ratio (0.0 = color_a, 1.0 = color_b).
fn interpolate_color(color_a: Color, color_b: Color, ratio: f64) -> Color {
    let ratio = ratio.clamp(0.0, 1.0);
    let r = (color_a.r as f64 + (color_b.r as f64 - color_a.r as f64) * ratio).round() as u8;
    let g = (color_a.g as f64 + (color_b.g as f64 - color_a.g as f64) * ratio).round() as u8;
    let b = (color_a.b as f64 + (color_b.b as f64 - color_a.b as f64) * ratio).round() as u8;
    Color::new(r, g, b)
}

/// Collect all numeric values in ranges from the sheet (for color scale min/max).
fn collect_numeric_values_in_ranges(
    sheet: &umya_spreadsheet::Worksheet,
    ranges: &[CellRange],
) -> Vec<f64> {
    let mut values = Vec::new();
    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                if let Some(cell) = sheet.get_cell((col, row))
                    && let Some(val) = cell_numeric_value(cell)
                {
                    values.push(val);
                }
            }
        }
    }
    values
}

/// Compute the min, max, and range span of a set of values.
/// Returns `None` if the slice is empty.
fn compute_min_max(values: &[f64]) -> Option<(f64, f64, f64)> {
    if values.is_empty() {
        return None;
    }
    let min_val: f64 = values.iter().cloned().fold(f64::INFINITY, f64::min);
    let max_val: f64 = values.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
    let val_range: f64 = max_val - min_val;
    Some((min_val, max_val, val_range))
}

/// Apply a CellIs conditional formatting rule to matching cells in the given ranges.
/// Apply text-match conditional rules (containsText / notContainsText /
/// beginsWith / endsWith) using the rule's `text` attribute.
fn apply_text_rule(
    sheet: &umya_spreadsheet::Worksheet,
    rule: &umya_spreadsheet::ConditionalFormattingRule,
    ranges: &[CellRange],
    overrides: &mut HashMap<CellPos, CondFmtOverride>,
) {
    use umya_spreadsheet::ConditionalFormatValues;
    let needle: &str = rule.get_text();
    if needle.is_empty() {
        return;
    }
    let fmt = extract_cond_fmt_style(rule);

    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                let Some(cell) = sheet.get_cell((col, row)) else {
                    continue;
                };
                let value = cell.get_formatted_value();
                let matched = match rule.get_type() {
                    ConditionalFormatValues::ContainsText => value.contains(needle),
                    ConditionalFormatValues::NotContainsText => !value.contains(needle),
                    ConditionalFormatValues::BeginsWith => value.starts_with(needle),
                    ConditionalFormatValues::EndsWith => value.ends_with(needle),
                    _ => false,
                };
                if matched {
                    let entry = overrides.entry((col, row)).or_default();
                    if fmt.background.is_some() {
                        entry.background = fmt.background;
                    }
                    if fmt.font_color.is_some() {
                        entry.font_color = fmt.font_color;
                    }
                    if fmt.bold.is_some() {
                        entry.bold = fmt.bold;
                    }
                }
            }
        }
    }
}

fn apply_cell_is_rule(
    sheet: &umya_spreadsheet::Worksheet,
    rule: &umya_spreadsheet::ConditionalFormattingRule,
    ranges: &[CellRange],
    overrides: &mut HashMap<CellPos, CondFmtOverride>,
) {
    let operator = rule.get_operator();
    let Some(operand) = parse_cell_is_operand(rule) else {
        return;
    };
    let fmt = extract_cond_fmt_style(rule);

    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                let Some(cell) = sheet.get_cell((col, row)) else {
                    continue;
                };
                let matched: bool = match &operand {
                    CellIsOperand::Number(threshold) => cell_numeric_value(cell)
                        .is_some_and(|val| evaluate_cell_is_rule(val, operator, *threshold)),
                    CellIsOperand::Text(text) => cell_text_value(cell)
                        .is_some_and(|val| evaluate_cell_is_text_rule(&val, operator, text)),
                };
                if matched {
                    let entry = overrides.entry((col, row)).or_default();
                    if fmt.background.is_some() {
                        entry.background = fmt.background;
                    }
                    if fmt.font_color.is_some() {
                        entry.font_color = fmt.font_color;
                    }
                    if fmt.bold.is_some() {
                        entry.bold = fmt.bold;
                    }
                }
            }
        }
    }
}

/// Apply a ColorScale conditional formatting rule to cells in the given ranges.
fn apply_color_scale_rule(
    sheet: &umya_spreadsheet::Worksheet,
    rule: &umya_spreadsheet::ConditionalFormattingRule,
    ranges: &[CellRange],
    overrides: &mut HashMap<CellPos, CondFmtOverride>,
) {
    let Some(cs) = rule.get_color_scale() else {
        return;
    };

    let colors: Vec<Option<Color>> = cs
        .get_color_collection()
        .iter()
        .map(parse_umya_color_argb)
        .collect();

    if colors.len() < 2 {
        return;
    }

    let numeric_vals: Vec<f64> = collect_numeric_values_in_ranges(sheet, ranges);
    let Some((min_val, _max_val, val_range)) = compute_min_max(&numeric_vals) else {
        return;
    };

    let color_min: Color = colors[0].unwrap_or(Color::white());
    let color_max: Color = colors[colors.len() - 1].unwrap_or(Color::black());

    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                if let Some(cell) = sheet.get_cell((col, row))
                    && let Some(val) = cell_numeric_value(cell)
                {
                    let ratio: f64 = if val_range.abs() < f64::EPSILON {
                        0.5
                    } else {
                        (val - min_val) / val_range
                    };

                    let color: Color = if colors.len() == 3 {
                        let color_mid: Color = colors[1].unwrap_or(Color::new(255, 255, 0));
                        if ratio <= 0.5 {
                            interpolate_color(color_min, color_mid, ratio * 2.0)
                        } else {
                            interpolate_color(color_mid, color_max, (ratio - 0.5) * 2.0)
                        }
                    } else {
                        interpolate_color(color_min, color_max, ratio)
                    };

                    let entry = overrides.entry((col, row)).or_default();
                    entry.background = Some(color);
                }
            }
        }
    }
}

/// Apply a DataBar conditional formatting rule to cells in the given ranges.
fn apply_data_bar_rule(
    sheet: &umya_spreadsheet::Worksheet,
    rule: &umya_spreadsheet::ConditionalFormattingRule,
    ranges: &[CellRange],
    overrides: &mut HashMap<CellPos, CondFmtOverride>,
    raw_hint: Option<&RawCondFmtHint>,
) {
    let Some(db) = rule.get_data_bar() else {
        return;
    };

    let bar_color: Color = db
        .get_color_collection()
        .first()
        .and_then(parse_umya_color_argb)
        .unwrap_or(Color::new(0x63, 0x8E, 0xC6)); // default blue

    let numeric_vals: Vec<f64> = collect_numeric_values_in_ranges(sheet, ranges);
    let Some((range_min, range_max, _)) = compute_min_max(&numeric_vals) else {
        return;
    };

    // Resolve the bar axis from the cfvo pair; fixed axes (num/percent) are
    // independent of the observed values, exactly like Excel.
    let cfvos = db.get_cfvo_collection();
    let axis_min: f64 = cfvos
        .first()
        .and_then(|cfvo| resolve_data_bar_cfvo(cfvo, range_min, range_max))
        .unwrap_or(range_min);
    let axis_max: f64 = cfvos
        .get(1)
        .and_then(|cfvo| resolve_data_bar_cfvo(cfvo, range_min, range_max))
        .unwrap_or(range_max);
    let axis_range: f64 = axis_max - axis_min;

    // Excel maps the axis onto [minLength, maxLength] percent of the cell
    // width (spec defaults 10/90), so the minimum still shows a short bar.
    let min_length: f64 = f64::from(raw_hint.and_then(|hint| hint.min_length).unwrap_or(10));
    let max_length: f64 = f64::from(raw_hint.and_then(|hint| hint.max_length).unwrap_or(90));

    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                if let Some(cell) = sheet.get_cell((col, row))
                    && let Some(val) = cell_numeric_value(cell)
                {
                    let fraction: f64 = if axis_range.abs() < f64::EPSILON {
                        0.5
                    } else {
                        ((val - axis_min) / axis_range).clamp(0.0, 1.0)
                    };
                    let pct: f64 = min_length + (max_length - min_length) * fraction;
                    let entry = overrides.entry((col, row)).or_default();
                    entry.data_bar = Some(DataBarInfo {
                        color: bar_color,
                        fill_pct: pct,
                    });
                }
            }
        }
    }
}

/// Resolve a dataBar cfvo to an absolute axis value. Returns None for types
/// that fall back to the observed range bounds (min/max/formula).
fn resolve_data_bar_cfvo(
    cfvo: &umya_spreadsheet::ConditionalFormatValueObject,
    range_min: f64,
    range_max: f64,
) -> Option<f64> {
    use umya_spreadsheet::ConditionalFormatValueObjectValues as CfvoType;
    match cfvo.get_type() {
        CfvoType::Number => cfvo.get_val().parse().ok(),
        CfvoType::Percent => {
            let pct: f64 = cfvo.get_val().parse().ok()?;
            Some(range_min + (range_max - range_min) * (pct / 100.0))
        }
        _ => None,
    }
}

/// Apply an IconSet conditional formatting rule to cells in the given ranges.
fn apply_icon_set_rule(
    sheet: &umya_spreadsheet::Worksheet,
    rule: &umya_spreadsheet::ConditionalFormattingRule,
    ranges: &[CellRange],
    overrides: &mut HashMap<CellPos, CondFmtOverride>,
    raw_hint: Option<&RawCondFmtHint>,
) {
    let numeric_vals: Vec<f64> = collect_numeric_values_in_ranges(sheet, ranges);
    let Some((min_val, max_val, val_range)) = compute_min_max(&numeric_vals) else {
        return;
    };

    // Prefer the cfvo (type, val) pairs parsed from the raw worksheet XML:
    // umya-spreadsheet drops cfvos written as start/end tag pairs, and its
    // values do not carry the cfvo type, so treating every value as a
    // percentage misplaced the bands (issue #406).
    let cfvo_thresholds: Vec<f64> = raw_hint
        .map(|hint| hint.icon_cfvos.as_slice())
        .filter(|cfvos| !cfvos.is_empty())
        .map(|cfvos| {
            cfvos
                .iter()
                .filter_map(|(kind, raw_val)| {
                    icon_cfvo_threshold(kind, raw_val, min_val, max_val, val_range, &numeric_vals)
                })
                .collect::<Vec<f64>>()
        })
        .filter(|thresholds| thresholds.len() >= 2)
        .unwrap_or_else(|| {
            // Legacy fallback: umya's cfvos (no type) treated as percent.
            rule.get_icon_set()
                .map(|is| is.get_cfvo_collection())
                .unwrap_or(&[])
                .iter()
                .filter_map(|cfvo| {
                    let pct: f64 = cfvo.get_val().parse().ok()?;
                    Some(min_val + val_range * (pct / 100.0))
                })
                .collect()
        });

    // Default to 3-icon equal-thirds if no thresholds available
    let thresholds: Vec<f64> = if cfvo_thresholds.len() >= 2 {
        cfvo_thresholds
    } else {
        vec![
            min_val,
            min_val + val_range / 3.0,
            min_val + val_range * 2.0 / 3.0,
        ]
    };

    let set_type: &str = raw_hint
        .and_then(|hint| hint.icon_set_type.as_deref())
        .unwrap_or("");
    let icons: Vec<(&'static str, Option<Color>)> =
        icon_set_glyphs(set_type, thresholds.len().max(3));

    for range in ranges {
        for row in range.start_row..=range.end_row {
            for col in range.start_col..=range.end_col {
                if let Some(cell) = sheet.get_cell((col, row))
                    && let Some(val) = cell_numeric_value(cell)
                {
                    let icon_idx: usize = evaluate_icon_index(val, &thresholds, icons.len());
                    let (glyph, color) = &icons[icon_idx];
                    let entry = overrides.entry((col, row)).or_default();
                    entry.icon_text = Some((*glyph).to_string());
                    entry.icon_color = *color;
                }
            }
        }
    }
}

/// Excel's icon band colors (sampled from Excel's own PDF output).
const ICON_RED: Color = Color {
    r: 214,
    g: 85,
    b: 50,
};
const ICON_YELLOW: Color = Color {
    r: 234,
    g: 191,
    b: 87,
};
const ICON_GREEN: Color = Color {
    r: 104,
    g: 164,
    b: 144,
};
const ICON_GRAY: Color = Color {
    r: 128,
    g: 128,
    b: 128,
};
const ICON_BLACK: Color = Color { r: 0, g: 0, b: 0 };

// The arrow bands are recorded as these shared codepoints so the renderer can
// recognize them and draw Excel's filled arrow shapes instead of a character
// (issue #377). Icon sets that stay characters — traffic lights, flags,
// symbols — use solid glyphs that keep text presentation and take the icon
// fill color, which the heavy "black arrow" codepoints do not: those resolve
// to color emoji.
use crate::ir::{
    ICON_ARROW_DOWN as ARROW_DOWN, ICON_ARROW_DOWN_RIGHT as ARROW_DOWN_RIGHT,
    ICON_ARROW_RIGHT as ARROW_RIGHT, ICON_ARROW_UP as ARROW_UP,
    ICON_ARROW_UP_RIGHT as ARROW_UP_RIGHT,
};

/// Map an OOXML iconSet type to per-band (glyph, color) pairs, low band first.
/// An absent attribute means the spec default 3TrafficLights1. Unknown set
/// types fall back to colored arrows of the requested band count.
fn icon_set_glyphs(set_type: &str, band_count: usize) -> Vec<(&'static str, Option<Color>)> {
    let effective_type: &str = if set_type.is_empty() {
        "3TrafficLights1"
    } else {
        set_type
    };
    match effective_type {
        "3TrafficLights1" | "3TrafficLights2" | "3Signs" => vec![
            ("●", Some(ICON_RED)),
            ("●", Some(ICON_YELLOW)),
            ("●", Some(ICON_GREEN)),
        ],
        "4TrafficLights" => vec![
            ("●", Some(ICON_BLACK)),
            ("●", Some(ICON_RED)),
            ("●", Some(ICON_YELLOW)),
            ("●", Some(ICON_GREEN)),
        ],
        "3Symbols" | "3Symbols2" => vec![
            ("✗", Some(ICON_RED)),
            ("!", Some(ICON_YELLOW)),
            ("✓", Some(ICON_GREEN)),
        ],
        "3Flags" => vec![
            ("⚑", Some(ICON_RED)),
            ("⚑", Some(ICON_YELLOW)),
            ("⚑", Some(ICON_GREEN)),
        ],
        "3Arrows" => vec![
            (ARROW_DOWN, Some(ICON_RED)),
            (ARROW_RIGHT, Some(ICON_YELLOW)),
            (ARROW_UP, Some(ICON_GREEN)),
        ],
        "3ArrowsGray" => vec![
            (ARROW_DOWN, Some(ICON_GRAY)),
            (ARROW_RIGHT, Some(ICON_GRAY)),
            (ARROW_UP, Some(ICON_GRAY)),
        ],
        "4Arrows" => vec![
            (ARROW_DOWN, Some(ICON_RED)),
            (ARROW_DOWN_RIGHT, Some(ICON_YELLOW)),
            (ARROW_UP_RIGHT, Some(ICON_YELLOW)),
            (ARROW_UP, Some(ICON_GREEN)),
        ],
        "4ArrowsGray" => vec![
            (ARROW_DOWN, Some(ICON_GRAY)),
            (ARROW_DOWN_RIGHT, Some(ICON_GRAY)),
            (ARROW_UP_RIGHT, Some(ICON_GRAY)),
            (ARROW_UP, Some(ICON_GRAY)),
        ],
        "5Arrows" => vec![
            (ARROW_DOWN, Some(ICON_RED)),
            (ARROW_DOWN_RIGHT, Some(ICON_YELLOW)),
            (ARROW_RIGHT, Some(ICON_YELLOW)),
            (ARROW_UP_RIGHT, Some(ICON_YELLOW)),
            (ARROW_UP, Some(ICON_GREEN)),
        ],
        "5ArrowsGray" => vec![
            (ARROW_DOWN, Some(ICON_GRAY)),
            (ARROW_DOWN_RIGHT, Some(ICON_GRAY)),
            (ARROW_RIGHT, Some(ICON_GRAY)),
            (ARROW_UP_RIGHT, Some(ICON_GRAY)),
            (ARROW_UP, Some(ICON_GRAY)),
        ],
        _ => {
            if band_count >= 5 {
                vec![
                    (ARROW_DOWN, None),
                    (ARROW_DOWN_RIGHT, None),
                    (ARROW_RIGHT, None),
                    (ARROW_UP_RIGHT, None),
                    (ARROW_UP, None),
                ]
            } else {
                vec![(ARROW_DOWN, None), (ARROW_RIGHT, None), (ARROW_UP, None)]
            }
        }
    }
}

/// Build a map of conditional formatting overrides for all cells in the sheet.
pub(crate) fn build_cond_fmt_overrides(
    sheet: &umya_spreadsheet::Worksheet,
    raw_hints: Option<&RawCondFmtHints>,
) -> HashMap<(u32, u32), CondFmtOverride> {
    let mut overrides: HashMap<CellPos, CondFmtOverride> = HashMap::new();

    for cf in sheet.get_conditional_formatting_collection() {
        let sqref = cf.get_sequence_of_references().get_sqref();
        let ranges: Vec<CellRange> = parse_sqref(&sqref);
        if ranges.is_empty() {
            continue;
        }

        for rule in cf.get_conditional_collection() {
            use umya_spreadsheet::ConditionalFormatValues;
            let raw_hint = raw_hints.and_then(|hints| hints.get(rule.get_priority()));

            match rule.get_type() {
                ConditionalFormatValues::CellIs => {
                    apply_cell_is_rule(sheet, rule, &ranges, &mut overrides);
                }
                ConditionalFormatValues::ContainsText
                | ConditionalFormatValues::NotContainsText
                | ConditionalFormatValues::BeginsWith
                | ConditionalFormatValues::EndsWith => {
                    apply_text_rule(sheet, rule, &ranges, &mut overrides);
                }
                ConditionalFormatValues::ColorScale => {
                    apply_color_scale_rule(sheet, rule, &ranges, &mut overrides);
                }
                ConditionalFormatValues::DataBar => {
                    apply_data_bar_rule(sheet, rule, &ranges, &mut overrides, raw_hint);
                }
                ConditionalFormatValues::IconSet => {
                    apply_icon_set_rule(sheet, rule, &ranges, &mut overrides, raw_hint);
                }
                _ => {}
            }
        }
    }

    overrides
}

/// Determine which icon index a value falls into based on thresholds.
/// Resolve one icon-set `<cfvo>` (type, value) into the numeric threshold a
/// cell value is compared against. Excel's cfvo types map differently:
/// `num` is a literal value, `percent` is a fraction of the value range,
/// `percentile` is the p-th percentile of the values, and `min`/`max` are
/// the extremes (issue #406). Unsupported types (e.g. `formula`) yield None.
fn icon_cfvo_threshold(
    kind: &str,
    raw_val: &str,
    min_val: f64,
    max_val: f64,
    val_range: f64,
    values: &[f64],
) -> Option<f64> {
    match kind {
        "min" => Some(min_val),
        "max" => Some(max_val),
        "num" => raw_val.parse::<f64>().ok(),
        "percent" => {
            let pct: f64 = raw_val.parse().ok()?;
            Some(min_val + val_range * (pct / 100.0))
        }
        "percentile" => {
            let pct: f64 = raw_val.parse().ok()?;
            Some(percentile(values, pct))
        }
        _ => None,
    }
}

/// The `pct`-th percentile (0-100) of `values` using linear interpolation
/// between closest ranks — Excel's `PERCENTILE.INC` convention.
fn percentile(values: &[f64], pct: f64) -> f64 {
    let mut sorted: Vec<f64> = values.to_vec();
    sorted.sort_by(f64::total_cmp);
    if sorted.is_empty() {
        return 0.0;
    }
    if sorted.len() == 1 {
        return sorted[0];
    }
    let rank: f64 = (pct / 100.0) * (sorted.len() as f64 - 1.0);
    let lower: usize = rank.floor() as usize;
    let upper: usize = rank.ceil() as usize;
    let weight: f64 = rank - lower as f64;
    sorted[lower] * (1.0 - weight) + sorted[upper] * weight
}

fn evaluate_icon_index(val: f64, thresholds: &[f64], num_icons: usize) -> usize {
    if num_icons == 0 {
        return 0;
    }
    // Iterate thresholds from highest to lowest
    for i in (1..thresholds.len()).rev() {
        if val >= thresholds[i] {
            return (i).min(num_icons - 1);
        }
    }
    0
}

#[cfg(test)]
#[path = "cond_fmt_tests.rs"]
mod tests;