//! Charts drawn by the hub (oxygenhub#257): inline SVG, coloured by CSS
//! classes from the theme's tokens, so they need no script, no library and
//! nothing the Content-Security-Policy forbids. Lines for times and levels,
//! stacked bars for counts; the x axis is relative (`−24 h` … `now`).

use crate::insights::{Range, Series};
use std::fmt::Write;

const W: f64 = 640.0;
const H: f64 = 190.0;
const LEFT: f64 = 52.0;
const RIGHT: f64 = 8.0;
const TOP: f64 = 10.0;
const BOTTOM: f64 = 22.0;

fn esc(s: &str) -> String {
    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
}

/// A round top for the y axis: 1, 2 or 5 times a power of ten.
fn nice(max: f64) -> f64 {
    if max <= 0.0 {
        return 1.0;
    }
    let p = 10f64.powf(max.log10().floor());
    for m in [1.0, 2.0, 5.0, 10.0] {
        if max <= m * p {
            return m * p;
        }
    }
    10.0 * p
}

/// The frame: grid lines with the y labels, and the relative x labels.
fn frame(out: &mut String, top: f64, range: Range, label: &dyn Fn(f64) -> String) {
    let plot_h = H - TOP - BOTTOM;
    for i in 0..=2 {
        let v = top * i as f64 / 2.0;
        let y = TOP + plot_h - plot_h * i as f64 / 2.0;
        let _ = write!(out, r#"<line class="grid" x1="{LEFT}" x2="{}" y1="{y:.1}" y2="{y:.1}"/>"#, W - RIGHT);
        let _ = write!(out, r#"<text class="axis" x="{}" y="{:.1}" text-anchor="end">{}</text>"#, LEFT - 6.0, y + 4.0, esc(&label(v)));
    }
    let (first, mid) = match range {
        Range::Hour => ("−60 min", "−30 min"),
        Range::Day => ("−24 h", "−12 h"),
        Range::Week => ("−7 d", "−3.5 d"),
    };
    let base = H - 6.0;
    let mid_x = LEFT + (W - LEFT - RIGHT) / 2.0;
    let _ = write!(out, r#"<text class="axis" x="{LEFT}" y="{base}">{first}</text>"#);
    let _ = write!(out, r#"<text class="axis" x="{mid_x}" y="{base}" text-anchor="middle">{mid}</text>"#);
    let _ = write!(out, r#"<text class="axis" x="{}" y="{base}" text-anchor="end">now</text>"#, W - RIGHT);
}

fn open(out: &mut String, title: &str) {
    let _ = write!(out, r#"<svg class="chart" viewBox="0 0 {W} {H}" role="img" aria-label="{}">"#, esc(title));
}

/// Lines, one per series; a missing value breaks its line.
pub fn lines(title: &str, range: Range, series: &[Series], label: &dyn Fn(f64) -> String) -> String {
    let max = series.iter().flat_map(|s| s.values.iter().flatten()).fold(0f64, |a, b| a.max(*b));
    let top = nice(max);
    let mut out = String::new();
    open(&mut out, title);
    frame(&mut out, top, range, label);
    let n = series.first().map_or(0, |s| s.values.len()).max(1);
    let step = (W - LEFT - RIGHT) / n as f64;
    let plot_h = H - TOP - BOTTOM;
    for s in series {
        let mut d = String::new();
        let mut pen = false;
        for (i, v) in s.values.iter().enumerate() {
            match v {
                Some(v) => {
                    let x = LEFT + step * (i as f64 + 0.5);
                    let y = TOP + plot_h - plot_h * (v / top).min(1.0);
                    let _ = write!(d, "{}{x:.1},{y:.1} ", if pen { "L" } else { "M" });
                    pen = true;
                }
                None => pen = false,
            }
        }
        if !d.is_empty() {
            let _ = write!(out, r#"<path class="line {}" d="{}"><title>{}</title></path>"#, s.class, d.trim_end(), esc(s.name));
        }
        // A lone point between gaps would not show as a line: a dot.
        for (i, v) in s.values.iter().enumerate() {
            let alone = v.is_some() && (i == 0 || s.values[i - 1].is_none()) && s.values.get(i + 1).is_none_or(|n| n.is_none());
            if let (true, Some(v)) = (alone, v) {
                let x = LEFT + step * (i as f64 + 0.5);
                let y = TOP + plot_h - plot_h * (v / top).min(1.0);
                let _ = write!(out, r#"<circle class="dot {}" cx="{x:.1}" cy="{y:.1}" r="2.5"/>"#, s.class);
            }
        }
    }
    out.push_str("</svg>");
    out
}

/// Stacked bars: each bucket's series on top of one another.
pub fn stacked(title: &str, range: Range, series: &[Series], label: &dyn Fn(f64) -> String) -> String {
    let n = series.first().map_or(0, |s| s.values.len());
    let totals: Vec<f64> = (0..n).map(|i| series.iter().map(|s| s.values[i].unwrap_or(0.0)).sum()).collect();
    let top = nice(totals.iter().fold(0f64, |a, b| a.max(*b)));
    let mut out = String::new();
    open(&mut out, title);
    frame(&mut out, top, range, label);
    let step = (W - LEFT - RIGHT) / n.max(1) as f64;
    let plot_h = H - TOP - BOTTOM;
    for i in 0..n {
        let mut y = TOP + plot_h;
        let x = LEFT + step * i as f64 + step * 0.1;
        for s in series {
            let v = s.values[i].unwrap_or(0.0);
            if v <= 0.0 {
                continue;
            }
            let h = plot_h * v / top;
            y -= h;
            let _ = write!(
                out,
                r#"<rect class="bar {}" x="{x:.1}" y="{y:.1}" width="{:.1}" height="{h:.1}"><title>{} {}</title></rect>"#,
                s.class,
                step * 0.8,
                label(v),
                esc(s.name)
            );
        }
    }
    out.push_str("</svg>");
    out
}

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

    #[test]
    fn charts_are_svg_with_classes_and_no_styles() {
        let s = vec![Series { name: "median", class: "s-main", values: vec![Some(1.0), None, Some(3.0), Some(4.0)] }];
        let svg = lines("Pickup", Range::Hour, &s, &|v| format!("{v:.0}"));
        assert!(svg.starts_with("<svg class=\"chart\"") && svg.ends_with("</svg>"));
        assert!(svg.contains("class=\"line s-main\"") && svg.contains("class=\"dot s-main\""), "{svg}");
        assert!(!svg.contains("style="), "no inline styles: the CSP");
        let bars = stacked("Jobs", Range::Day, &s, &|v| format!("{v:.0}"));
        assert_eq!(bars.matches("<rect").count(), 3);
        assert_eq!(nice(7.0), 10.0);
        assert_eq!(nice(130.0), 200.0);
    }
}