//! Reports pages (oxygenhub#127, docs/reports.md): the Reports tab, a

//! report's page with its metrics across runs and its own page in a

//! sandboxed frame, and the files that frame reads.

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::Viewer;

use crate::reports::{self, Metric, Report};

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use axum::http::{header, HeaderValue, StatusCode};

use axum::response::{IntoResponse, Response};

use serde::Deserialize;

/// Runs a report's page reads for its sparklines and run list.

const HISTORY: i64 = 60;

#[derive(Deserialize, Default)]

pub struct ReportsQuery {

    /// Only this bookmark's reports.

    bookmark: Option<String>,

    /// One report, by id.

    id: Option<i64>,

    /// Another run of the same report to compare with, by id (#127, RP4).

    compare: Option<i64>,

    /// Playing: seconds per run, carried from stop to stop.

    play: Option<u32>,

}

/// A stop on the timeline: one run of the report on its bookmark.

pub struct Stop {

    pub id: i64,

    pub href: String,

    pub label: String,

    pub tip: String,

    pub current: bool,

    pub compared: bool,

}

/// A metric shown against another run.

pub struct Compared {

    pub key: String,

    pub here: String,

    pub there: String,

    pub unit: String,

    /// here − there, `+1.5`; empty when equal or missing.

    pub delta: String,

    pub trend: &'static str,

}

/// A metric as shown: its value, and its change against the run before.

pub struct MetricView {

    pub key: String,

    pub value: String,

    pub unit: String,

    /// `+0.4`, empty when there is no run before or no change.

    pub delta: String,

    /// `better`, `worse` or `same`, by the metric's `better`.

    pub trend: &'static str,

    /// Its threshold, as words, when it has one.

    pub threshold: String,

    /// Whether it crosses its threshold.

    pub failing: bool,

    /// An inline SVG of its values across runs, oldest first.

    pub spark: String,

}

/// A report on the Reports tab.

pub struct Item {

    pub report: Report,

    pub metrics: Vec<MetricView>,

    /// `good`, `bad` or `neutral`: its thresholds met, one crossed, or none.

    pub health: &'static str,

    /// What the badge says: "2 thresholds met", "1 over its threshold".

    pub badge: String,

}

/// The Coverage or Tests entry on the Reports tab: its latest figure.

pub struct Builtin {

    pub big: String,

    pub sub: String,

    pub health: &'static str,

    pub when_ms: i64,

    pub bookmark: String,

}

/// The health and badge of a report from its metrics' thresholds.

fn health_of(metrics: &[MetricView]) -> (&'static str, String) {

    let with = metrics.iter().filter(|m| !m.threshold.is_empty()).count();

    let failing = metrics.iter().filter(|m| m.failing).count();

    match (with, failing) {

        (0, _) => ("neutral", format!("{} metric{}", metrics.len(), if metrics.len() == 1 { "" } else { "s" })),

        (_, 0) => ("good", format!("{with} threshold{} met", if with == 1 { "" } else { "s" })),

        (_, f) => ("bad", format!("{f} over {}", if f == 1 { "its threshold" } else { "their thresholds" })),

    }

}

#[derive(Template)]

#[template(path = "reports.html")]

pub struct ReportsPage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    items: Vec<Item>,

    coverage: Option<Builtin>,

    tests: Option<Builtin>,

}

#[derive(Template)]

#[template(path = "report.html")]

pub struct ReportPage {

    shell: Shell,

    repo: RepoShell,

    report: Report,

    bookmarks: Vec<String>,

    metrics: Vec<MetricView>,

    context: Vec<(String, String)>,

    /// Newest first, the one shown among them.

    runs: Vec<Report>,

    /// Where the frame loads the report's page from, when it has one.

    frame: Option<String>,

    files_base: String,

    /// Oldest first, the run shown marked.

    timeline: Vec<Stop>,

    /// The run compared with, its metrics against this one's, and its frame.

    compare: Option<(Report, Vec<Compared>, Option<String>)>,

    /// Seconds per run while playing.

    play: Option<u32>,

    /// The runs, oldest first, as JSON for the frame interface

    /// (`report.run()`, `report.history()`).

    runs_json: String,

}

/// A number as a person would write it: no trailing zeros.

fn num(v: f64) -> String {

    if v.fract() == 0.0 && v.abs() < 1e15 {

        format!("{v:.0}")

    } else {

        let s = format!("{v:.3}");

        s.trim_end_matches('0').trim_end_matches('.').to_string()

    }

}

fn spark(values: &[f64]) -> String {

    if values.len() < 2 {

        return String::new();

    }

    let (w, h) = (120.0, 28.0);

    let lo = values.iter().cloned().fold(f64::INFINITY, f64::min);

    let hi = values.iter().cloned().fold(f64::NEG_INFINITY, f64::max);

    let span = if hi > lo { hi - lo } else { 1.0 };

    let n = values.len();

    let pts: Vec<String> = values

        .iter()

        .enumerate()

        .map(|(i, v)| format!("{:.1},{:.1}", w * i as f64 / (n - 1) as f64, 2.0 + (h - 4.0) * (hi - v) / span))

        .collect();

    let last = pts.last().cloned().unwrap_or_default();

    let (lx, ly) = last.split_once(',').unwrap_or(("0", "0"));

    format!(

        r#"<svg class="rep-spark" viewBox="0 0 {w} {h}" width="{w}" height="{h}" aria-hidden="true"><polyline points="{}"/><circle cx="{lx}" cy="{ly}" r="2.5"/></svg>"#,

        pts.join(" ")

    )

}

/// The metrics of `now` against `before`, with each one's values across

/// `series` (oldest first) for a sparkline.

fn views(now: &[Metric], before: &[Metric], series: &[Vec<Metric>]) -> Vec<MetricView> {

    now.iter()

        .map(|m| {

            let prev = before.iter().find(|b| b.key == m.key).map(|b| b.value);

            let (delta, trend) = match prev {

                Some(p) if (m.value - p).abs() > f64::EPSILON => {

                    let up = m.value > p;

                    let trend = match m.better.as_str() {

                        "higher" if up => "better",

                        "higher" => "worse",

                        "lower" if up => "worse",

                        "lower" => "better",

                        _ => "same",

                    };

                    (format!("{}{}", if up { "+" } else { "" }, num(m.value - p)), trend)

                }

                _ => (String::new(), "same"),

            };

            let mut threshold = Vec::new();

            if let Some(a) = m.fail_above {

                threshold.push(format!("fails above {}", num(a)));

            }

            if let Some(b) = m.fail_below {

                threshold.push(format!("fails below {}", num(b)));

            }

            let failing = m.fail_above.is_some_and(|a| m.value > a) || m.fail_below.is_some_and(|b| m.value < b);

            let values: Vec<f64> = series.iter().filter_map(|ms| ms.iter().find(|x| x.key == m.key).map(|x| x.value)).collect();

            MetricView {

                key: m.key.clone(),

                value: num(m.value),

                unit: m.unit.clone(),

                delta,

                trend,

                threshold: threshold.join(", "),

                failing,

                spark: spark(&values),

            }

        })

        .collect()

}

/// The metrics of this run against another's, every key either has.

fn compared(here: &[Metric], there: &[Metric]) -> Vec<Compared> {

    let mut keys: Vec<&str> = here.iter().chain(there).map(|m| m.key.as_str()).collect();

    keys.sort();

    keys.dedup();

    keys.into_iter()

        .map(|k| {

            let (a, b) = (here.iter().find(|m| m.key == k), there.iter().find(|m| m.key == k));

            let (delta, trend) = match (a, b) {

                (Some(a), Some(b)) if (a.value - b.value).abs() > f64::EPSILON => {

                    let up = a.value > b.value;

                    let trend = match a.better.as_str() {

                        "higher" if up => "better",

                        "higher" => "worse",

                        "lower" if up => "worse",

                        "lower" => "better",

                        _ => "same",

                    };

                    (format!("{}{}", if up { "+" } else { "" }, num(a.value - b.value)), trend)

                }

                _ => (String::new(), "same"),

            };

            Compared {

                key: k.to_string(),

                here: a.map(|m| num(m.value)).unwrap_or_else(|| "–".into()),

                there: b.map(|m| num(m.value)).unwrap_or_else(|| "–".into()),

                unit: a.or(b).map(|m| m.unit.clone()).unwrap_or_default(),

                delta,

                trend,

            }

        })

        .collect()

}

/// `GET /{owner}/{name}/reports`: the newest of each report, with its

/// metrics against the run before on its bookmark.

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<ReportsQuery>,

) -> Result<Page<ReportsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/reports"), &viewer);

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let bookmark = q.bookmark.clone().filter(|b| !b.is_empty());

    let latest = reports::latest(&app.db, row.id, bookmark.as_deref()).await.map_err(e)?;

    let mut items = Vec::new();

    for r in latest {

        let history = reports::history(&app.db, row.id, &r.name, &r.bookmark, 2).await.map_err(e)?;

        let now = reports::metrics(&app.db, r.id).await.map_err(e)?;

        let before = match history.get(1) {

            Some(p) => reports::metrics(&app.db, p.id).await.map_err(e)?,

            None => vec![],

        };

        let metrics = views(&now, &before, &[]);

        let (health, badge) = health_of(&metrics);

        items.push(Item { metrics, report: r, health, badge });

    }

    let repo = RepoShell::new(&app, &row, "reports").with_role(role);

    // Coverage and Tests: their latest, on the default bookmark when it has

    // one, else wherever was newest.

    let pick = |list: Vec<String>| bookmark.clone().or_else(|| list.iter().find(|b| **b == row.default_bookmark).or(list.first()).cloned());

    let coverage = match pick(crate::coverage::bookmarks(&app.db, row.id).await.map_err(e)?).filter(|_| repo.coverage) {

        Some(b) => crate::coverage::on_bookmark(&app.db, row.id, &b, 1).await.map_err(e)?.into_iter().next().map(|c| Builtin {

            big: c.percent().map(|p| format!("{p:.1}%")).unwrap_or_else(|| "–".into()),

            sub: format!("{} of {} lines covered · {}", c.lines_hit, c.lines_found, c.source()),

            health: match c.percent() {

                Some(p) if p >= 75.0 => "good",

                Some(p) if p < 50.0 => "bad",

                _ => "neutral",

            },

            when_ms: c.created_ms,

            bookmark: c.bookmark.clone(),

        }),

        None => None,

    };

    let tests = match pick(crate::junit::bookmarks(&app.db, row.id).await.map_err(e)?).filter(|_| repo.tests) {

        Some(b) => crate::junit::on_bookmark(&app.db, row.id, &b, 1).await.map_err(e)?.into_iter().next().map(|t| Builtin {

            big: if t.broken() > 0 { format!("{} failing", t.broken()) } else { format!("{} passed", t.passed) },

            sub: t.summary(),

            health: if t.broken() > 0 { "bad" } else { "good" },

            when_ms: t.created_ms,

            bookmark: t.bookmark.clone(),

        }),

        None => None,

    };

    Ok(Page(ReportsPage { shell, coverage, tests, repo, bookmark: bookmark.unwrap_or_default(), items }))

}

/// `GET /{owner}/{name}/reports/{report}`: one report, the newest on its

/// bookmark unless `?id=` names a run, with its metrics across runs and

/// its page in a sandboxed frame.

pub async fn show(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, rname)): Path<(String, String, String)>,

    Query(q): Query<ReportsQuery>,

) -> Result<Page<ReportPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/reports/{rname}"), &viewer);

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let e = |e| Error::from_db(shell.clone(), e);

    let report = match q.id {

        Some(id) => reports::get(&app.db, row.id, id).await.map_err(e)?.filter(|r| r.name == rname),

        None => {

            let bookmarks = reports::bookmarks_of(&app.db, row.id, &rname).await.map_err(e)?;

            let bookmark = q

                .bookmark

                .clone()

                .or_else(|| bookmarks.iter().find(|b| **b == row.default_bookmark).cloned())

                .or_else(|| bookmarks.first().cloned());

            match bookmark {

                Some(b) => reports::history(&app.db, row.id, &rname, &b, 1).await.map_err(e)?.into_iter().next(),

                None => None,

            }

        }

    };

    let report = report.ok_or_else(|| Error::not_found(shell.clone()))?;

    let bookmarks = reports::bookmarks_of(&app.db, row.id, &rname).await.map_err(e)?;

    let runs = reports::history(&app.db, row.id, &rname, &report.bookmark, HISTORY).await.map_err(e)?;

    let now = reports::metrics(&app.db, report.id).await.map_err(e)?;

    // The run before the one shown, and every run up to it for the lines.

    let at = runs.iter().position(|r| r.id == report.id).unwrap_or(0);

    let before = match runs.get(at + 1) {

        Some(p) => reports::metrics(&app.db, p.id).await.map_err(e)?,

        None => vec![],

    };

    let mut series = Vec::new();

    for r in runs.iter().skip(at).rev() {

        series.push(reports::metrics(&app.db, r.id).await.map_err(e)?);

    }

    let base_of = |id: i64| format!("/{owner}/{name}/reports/files/{id}/{}", reports::file_mac(&app, id));

    let files_base = base_of(report.id);

    let frame = reports::file(&app.db, report.id, "index.html").await.map_err(e)?.map(|_| format!("{files_base}/index.html"));

    let label = |r: &Report| r.run_number.map(|n| format!("run #{n}")).unwrap_or_else(|| "upload".into());

    let page = format!("/{owner}/{name}/reports/{rname}");

    let keep = |id: i64| {

        let mut url = format!("{page}?id={id}");

        if let Some(c) = q.compare.filter(|c| *c != id) {

            url.push_str(&format!("&compare={c}"));

        }

        if let Some(p) = q.play {

            url.push_str(&format!("&play={p}"));

        }

        url

    };

    let timeline: Vec<Stop> = runs

        .iter()

        .rev()

        .map(|r| Stop {

            id: r.id,

            href: keep(r.id),

            label: label(r),

            tip: format!("{}{}", label(r), if r.summary.is_empty() { String::new() } else { format!(": {}", r.summary) }),

            current: r.id == report.id,

            compared: Some(r.id) == q.compare,

        })

        .collect();

    // Another run to compare with (RP4): every metric, both values, the

    // difference; and its page beside this one's.

    let compare = match q.compare.filter(|c| *c != report.id) {

        Some(cid) => match reports::get(&app.db, row.id, cid).await.map_err(e)?.filter(|r| r.name == rname) {

            Some(other) => {

                let theirs = reports::metrics(&app.db, other.id).await.map_err(e)?;

                let rows = compared(&now, &theirs);

                let f =

                    reports::file(&app.db, other.id, "index.html").await.map_err(e)?.map(|_| format!("{}/index.html", base_of(other.id)));

                Some((other, rows, f))

            }

            None => None,

        },

        None => None,

    };

    let runs_json = serde_json::to_string(

        &runs

            .iter()

            .rev()

            .map(|r| serde_json::json!({ "id": r.id, "run": r.run_number, "bookmark": r.bookmark, "created_ms": r.created_ms, "summary": r.summary, "files": base_of(r.id), "current": r.id == report.id }))

            .collect::<Vec<_>>(),

    )

    .unwrap_or_default();

    let repo = RepoShell::new(&app, &row, "reports").with_role(role);

    Ok(Page(ReportPage {

        shell,

        repo,

        context: report.context_rows(),

        metrics: views(&now, &before, &series),

        bookmarks,

        runs,

        frame,

        files_base,

        report,

        timeline,

        compare,

        play: q.play.map(|p| p.clamp(1, 60)),

        runs_json,

    }))

}

/// `page` with the report frame script added (#127).

fn with_frame_script(page: Vec<u8>, version: &str) -> Vec<u8> {

    let tag = format!(r#"<script src="/static/report-frame.js?v={version}"></script>"#);

    let lower = page.to_ascii_lowercase();

    let find = |needle: &[u8]| lower.windows(needle.len()).position(|w| w == needle);

    let at = find(b"</head>").or_else(|| find(b"<body")).unwrap_or(page.len());

    let mut out = Vec::with_capacity(page.len() + tag.len());

    out.extend_from_slice(&page[..at]);

    out.extend_from_slice(tag.as_bytes());

    out.extend_from_slice(&page[at..]);

    out

}

/// A file's type, by its extension.

pub(crate) fn content_type(path: &str) -> &'static str {

    match path.rsplit('.').next().unwrap_or("").to_ascii_lowercase().as_str() {

        "html" | "htm" => "text/html; charset=utf-8",

        "js" | "mjs" => "text/javascript; charset=utf-8",

        "css" => "text/css; charset=utf-8",

        "json" => "application/json",

        "csv" => "text/csv; charset=utf-8",

        "svg" => "image/svg+xml",

        "png" => "image/png",

        "jpg" | "jpeg" => "image/jpeg",

        "gif" => "image/gif",

        "webp" => "image/webp",

        "woff2" => "font/woff2",

        "woff" => "font/woff",

        "txt" | "toml" | "md" | "info" | "xml" => "text/plain; charset=utf-8",

        _ => "application/octet-stream",

    }