//! Text contrast (hub spec §6.13): every text colour of each theme meets

//! WCAG AA (4.5:1) on every surface it is drawn on, and text never uses

//! `--dim`, which is for rules and decoration.

use std::collections::HashMap;

fn css() -> String {

    std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/../../templates/style.css")).unwrap()

}

/// `--name:#rrggbb` pairs of the block that starts with `selector`.

fn theme(css: &str, selector: &str) -> HashMap<String, String> {

    let start = css.find(selector).unwrap_or_else(|| panic!("{selector} missing"));

    let body = &css[start..start + css[start..].find('}').unwrap()];

    let mut out = HashMap::new();

    for part in body.split("--").skip(1) {

        let Some((name, rest)) = part.split_once(':') else { continue };

        let value = rest.trim_start();

        let valid = !name.is_empty() && name.chars().all(|c| c.is_ascii_alphanumeric() || c == '-');

        if valid && value.len() >= 7 && value.starts_with('#') && value[1..7].chars().all(|c| c.is_ascii_hexdigit()) {

            out.insert(name.to_string(), value[..7].to_lowercase());

        }

    }

    out

}

fn luminance(hex: &str) -> f64 {

    let c = |i: usize| {

        let x = u8::from_str_radix(&hex[i..i + 2], 16).unwrap() as f64 / 255.0;

        if x <= 0.03928 {

            x / 12.92

        } else {

            ((x + 0.055) / 1.055).powf(2.4)

        }

    };

    0.2126 * c(1) + 0.7152 * c(3) + 0.0722 * c(5)

}

fn ratio(a: &str, b: &str) -> f64 {

    let (x, y) = (luminance(a), luminance(b));

    (x.max(y) + 0.05) / (x.min(y) + 0.05)

}

#[test]

fn text_meets_aa_in_both_themes() {

    let css = css();

    let mut failures = Vec::new();

    for (name, sel) in [("dark", ":root {"), ("light", ":root[data-theme=\"light\"] {")] {

        let t = theme(&css, sel);

        let mut text: Vec<&str> = vec!["ink", "mute", "acc", "ok", "bad", "warn"];

        text.extend(t.keys().filter(|k| k.starts_with("sy-")).map(String::as_str));

        for fg in text {

            for bg in ["bg", "panel", "soft"] {

                let r = ratio(&t[fg], &t[bg]);

                if r < 4.5 {

                    failures.push(format!("{name}: --{fg} on --{bg} is {r:.2}:1"));

                }

            }

        }

        for (fg, bg) in [("band-ink", "band"), ("add-ink", "add"), ("del-ink", "del"), ("now-ink", "now")] {

            let r = ratio(&t[fg], &t[bg]);

            if r < 4.5 {

                failures.push(format!("{name}: --{fg} on --{bg} is {r:.2}:1"));

            }

        }

    }

    assert!(failures.is_empty(), "below WCAG AA:\n{}", failures.join("\n"));

}

#[test]

fn text_does_not_use_dim() {

    let css = css();

    let offenders: Vec<&str> = css.lines().filter(|l| l.contains("color: var(--dim)") && !l.contains("border")).collect();

    assert!(offenders.is_empty(), "--dim is too faint for text:\n{}", offenders.join("\n"));

}

/// `--name:rgba(r,g,b,a)` of the block that starts with `selector`.

fn rgba(css: &str, selector: &str, name: &str) -> (f64, f64, f64, f64) {

    let start = css.find(selector).unwrap_or_else(|| panic!("{selector} missing"));

    let body = &css[start..start + css[start..].find('}').unwrap()];

    let at = body.find(&format!("--{name}:rgba(")).unwrap_or_else(|| panic!("--{name} missing in {selector}"));

    let inner = &body[at + name.len() + 8..];

    let v: Vec<f64> = inner[..inner.find(')').unwrap()].split(',').map(|x| x.trim().parse().unwrap()).collect();

    (v[0], v[1], v[2], v[3])

}

/// Backdrops (docs/backgrounds.md §3): a resting mark is barely there,

/// under 1.3:1 against the page in every look and theme, and a lit one is

/// plainly visible.

#[test]

fn backdrop_marks_rest_barely_there() {

    let classic = css();

    let github = std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/github.css")).unwrap();

    let blocks = [

        (&classic, ":root {", ":root {"),

        (&classic, ":root[data-theme=\"light\"] {", ":root[data-theme=\"light\"] {"),

        (&github, ":root[data-look=\"github\"] {", ":root[data-look=\"github\"] {"),

        (&github, ":root[data-look=\"github\"][data-theme=\"dark\"] {", ":root[data-look=\"github\"][data-theme=\"dark\"] {"),

    ];

    let over = |c: (f64, f64, f64, f64), bg: &str| {

        let b = |i: usize| u8::from_str_radix(&bg[i..i + 2], 16).unwrap() as f64;

        let mix = |x: f64, y: f64| (x * c.3 + y * (1.0 - c.3)).round() as u8;

        format!("#{:02x}{:02x}{:02x}", mix(c.0, b(1)), mix(c.1, b(3)), mix(c.2, b(5)))

    };

    for (css, sel, bg_sel) in blocks {

        let bg = &theme(css, bg_sel)["bg"];

        let rest = ratio(&over(rgba(css, sel, "bd-mark"), bg), bg);

        let lit = ratio(&over(rgba(css, sel, "bd-lit"), bg), bg);

        assert!(rest < 1.3, "{sel}: a resting mark is {rest:.2}:1, too strong");

        assert!(lit >= 2.0, "{sel}: a lit mark is {lit:.2}:1, too faint");

    }

}