//! Coverage pages (oxygenhub#113): a repository's coverage, its trend,

//! every file, and each file's lines marked run or missed; and a badge.

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

use crate::auth::Viewer;

use crate::coverage::{self, FileRow, Report};

use crate::repos::view::{self, FileBody, RefKind, RefTarget};

use crate::Shared;

use askama::Template;

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

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

use serde::Deserialize;

use std::collections::BTreeMap;

use std::sync::{Arc, Mutex};

/// Reports the charts and the recent list draw on.

const HISTORY: i64 = 200;

/// Runs listed under Recent runs.

const RECENT: usize = 10;

/// Files listed as changed against the run before.

const CHANGED: usize = 12;

#[derive(Deserialize, Default)]

pub struct CoverageQuery {

    /// A bookmark other than the default.

    bookmark: Option<String>,

    /// One report, by id.

    report: Option<i64>,

    /// `missed` (default), `percent` or `path`.

    sort: Option<String>,

}

/// A run in the Recent runs list.

pub struct RecentRow {

    pub report: Report,

    /// Against the report before it, in percentage points.

    pub delta: Option<f64>,

}

/// A file whose coverage moved against the run before.

pub struct Moved {

    pub path: String,

    pub before: Option<f64>,

    pub after: Option<f64>,

    pub delta: f64,

}

/// One band of the file distribution.

pub struct Band {

    pub label: &'static str,

    pub class: &'static str,

    pub files: usize,

    /// Of the widest band, for the bar's width.

    pub width: f64,

}

#[derive(Template)]

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

pub struct CoveragePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    bookmarks: Vec<String>,

    report: Option<Report>,

    /// The report before this one on the bookmark.

    previous: Option<Report>,

    delta: Option<f64>,

    files: Vec<FileRow>,

    sort: String,

    coverage_chart: String,

    lines_chart: String,

    runs: usize,

    first_ms: Option<i64>,

    recent: Vec<RecentRow>,

    moved: Vec<Moved>,

    /// Files that are new against the run before.

    added: usize,

    bands: Vec<Band>,

}

impl CoveragePage {

    pub fn pct(&self, p: Option<f64>) -> String {

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

    }

    pub fn pct_of(&self, p: &Option<f64>) -> String {

        self.pct(*p)

    }

    pub fn signed(&self, d: &f64) -> String {

        if d.abs() < 0.05 {

            "±0.0".to_string()

        } else {

            format!("{d:+.1}")

        }

    }

    pub fn delta_class(&self, d: &f64) -> &'static str {

        if *d >= 0.05 {

            "up"

        } else if *d <= -0.05 {

            "down"

        } else {

            "same"

        }

    }

    pub fn class_of(&self, p: Option<f64>) -> &'static str {

        level(p)

    }

    pub fn hits(&self, r: &Report) -> String {

        r.hits_per_line().map(|h| if h >= 100.0 { compact(h) } else { format!("{h:.1}") }).unwrap_or_else(|| "–".into())

    }

    pub fn lines_delta(&self) -> Option<(i64, i64)> {

        let (r, p) = (self.report.as_ref()?, self.previous.as_ref()?);

        Some((r.lines_found - p.lines_found, r.lines_hit - p.lines_hit))

    }

}

/// A count, short: 9.4k, 147.7k, 2.3M.

fn compact(v: f64) -> String {

    match v {

        v if v >= 1e9 => format!("{:.1}G", v / 1e9),

        v if v >= 1e6 => format!("{:.1}M", v / 1e6),

        v if v >= 1e3 => format!("{:.1}k", v / 1e3),

        v => format!("{v:.0}"),

    }

}

/// A colour class for a percentage.

pub fn level(p: Option<f64>) -> &'static str {

    match p {

        Some(p) if p >= 90.0 => "cov-good",

        Some(p) if p >= 75.0 => "cov-fair",

        Some(p) if p >= 50.0 => "cov-low",

        Some(_) => "cov-poor",

        None => "cov-none",

    }

}

/// A line of values across runs, for [`chart`].

struct Series<'a> {

    values: Vec<f64>,

    class: &'a str,

    /// Shade down to these values instead of to the axis: a band.

    floor: Option<Vec<f64>>,

}

/// An SVG chart of one or more series over runs, oldest on the left, with

/// a light grid and labels, and a column per run that names it on hover

/// and links to its report. `fmt` labels the y axis.

#[allow(clippy::too_many_arguments)] // one chart, described in full by its caller

fn chart(

    label: &str,

    runs: &[&Report],

    series: &[Series],

    lo: f64,

    hi: f64,

    fmt: &dyn Fn(f64) -> String,

    url: &str,

    tip: &dyn Fn(&Report) -> String,

) -> String {

    let (w, h) = (800.0, 180.0);

    let (left, right, top, bottom) = (52.0, 10.0, 12.0, 24.0);

    let (pw, ph) = (w - left - right, h - top - bottom);

    let n = runs.len();

    if n == 0 {

        return String::new();

    }

    let x = |i: usize| if n == 1 { left + pw / 2.0 } else { left + pw * i as f64 / (n - 1) as f64 };

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

    let y = |v: f64| top + ph * (hi - v) / span;

    let mut svg = format!(r#"<svg class="cov-chart" viewBox="0 0 {w} {h}" role="img" aria-label="{label}">"#);

    for i in 0..=4 {

        let v = lo + span * i as f64 / 4.0;

        svg.push_str(&format!(

            r#"<line class="grid" x1="{left}" x2="{x2}" y1="{yy:.1}" y2="{yy:.1}"/><text class="axis" x="{tx}" y="{ty:.1}" text-anchor="end">{t}</text>"#,

            x2 = w - right,

            yy = y(v),

            tx = left - 6.0,

            ty = y(v) + 3.5,

            t = fmt(v),

        ));

    }

    for s in series {

        let pts: Vec<String> = s.values.iter().enumerate().map(|(i, v)| format!("{:.1},{:.1}", x(i), y(*v))).collect();

        if n > 1 {

            let area = match &s.floor {

                Some(floor) => {

                    let back: Vec<String> = floor.iter().enumerate().rev().map(|(i, v)| format!("{:.1},{:.1}", x(i), y(*v))).collect();

                    format!("M{} L{} Z", pts.join(" L"), back.join(" L"))

                }

                None => format!("M{:.1},{:.1} L{} L{:.1},{:.1} Z", x(0), top + ph, pts.join(" L"), x(n - 1), top + ph),

            };

            svg.push_str(&format!(

                r#"<path class="area {c}" d="{area}"/><polyline class="line {c}" points="{line}"/>"#,

                c = s.class,

                line = pts.join(" ")

            ));

        }

        if let Some(last) = s.values.last() {

            svg.push_str(&format!(r#"<circle class="dot {}" cx="{:.1}" cy="{:.1}" r="4"/>"#, s.class, x(n - 1), y(*last)));

        }

    }

    // A column per run: its tip on hover, its report on a click.

    let col = if n == 1 { pw } else { pw / (n - 1) as f64 };

    for (i, r) in runs.iter().enumerate() {

        svg.push_str(&format!(

            r#"<a href="{url}/coverage?report={id}"><rect class="hit" x="{rx:.1}" y="{top}" width="{col:.1}" height="{ph}"><title>{t}</title></rect></a>"#,

            id = r.id,

            rx = x(i) - col / 2.0,

            t = tip(r),

        ));

    }

    if n > 1 {

        svg.push_str(&format!(

            r#"<text class="axis" x="{left}" y="{yb}">run #{first}</text><text class="axis" x="{xr}" y="{yb}" text-anchor="end">run #{last}</text>"#,

            yb = h - 6.0,

            xr = w - right,

            first = runs[0].run_number,

            last = runs[n - 1].run_number,

        ));

    }

    svg.push_str("</svg>");

    svg

}

/// `GET /{owner}/{name}/coverage`.

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<CoverageQuery>,

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

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

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

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

    let picked = match q.report {

        Some(id) => Some(coverage::report(&app.db, row.id, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?),

        None => None,

    };

    let bookmark = picked.as_ref().map(|r| r.bookmark.clone()).or(q.bookmark.clone()).unwrap_or_else(|| row.default_bookmark.clone());

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

    let history = coverage::on_bookmark(&app.db, row.id, &bookmark, HISTORY).await.map_err(e)?;

    let report = picked.or_else(|| history.first().cloned());

    // The report before the one shown, on the same bookmark.

    let previous = report

        .as_ref()

        .and_then(|r| history.iter().find(|h| h.created_ms < r.created_ms || (h.created_ms == r.created_ms && h.id < r.id)).cloned());

    let delta = report.as_ref().zip(previous.as_ref()).and_then(|(r, p)| Some(r.percent()? - p.percent()?));

    let mut files = match &report {

        Some(r) => coverage::files(&app.db, r.id).await.map_err(e)?,

        None => vec![],

    };

    // Files that moved against the run before, the largest moves first.

    let (mut moved, mut added) = (Vec::new(), 0);

    if let Some(p) = &previous {

        let before: std::collections::HashMap<String, Option<f64>> =

            coverage::files(&app.db, p.id).await.map_err(e)?.into_iter().map(|f| (f.path.clone(), f.percent())).collect();

        for f in &files {

            match before.get(&f.path) {

                None => added += 1,

                Some(b) => {

                    let d = f.percent().unwrap_or(0.0) - b.unwrap_or(0.0);

                    if d.abs() >= 0.05 {

                        moved.push(Moved { path: f.path.clone(), before: *b, after: f.percent(), delta: d });

                    }

                }

            }

        }

        moved.sort_by(|a, b| b.delta.abs().total_cmp(&a.delta.abs()).then(a.path.cmp(&b.path)));

        moved.truncate(CHANGED);

    }

    // How the files spread over coverage bands.

    let bounds: [(&str, &str, f64, f64); 5] = [

        ("100%", "cov-good", 100.0, 100.1),

        ("90 – 99%", "cov-good", 90.0, 100.0),

        ("75 – 89%", "cov-fair", 75.0, 90.0),

        ("50 – 74%", "cov-low", 50.0, 75.0),

        ("under 50%", "cov-poor", -1.0, 50.0),

    ];

    let counts: Vec<usize> =

        bounds.iter().map(|(_, _, lo, hi)| files.iter().filter(|f| f.percent().is_some_and(|p| p >= *lo && p < *hi)).count()).collect();

    let widest = counts.iter().copied().max().unwrap_or(0).max(1) as f64;

    let bands = bounds

        .iter()

        .zip(&counts)

        .map(|((label, class, _, _), n)| Band { label, class, files: *n, width: *n as f64 * 100.0 / widest })

        .collect();

    let sort = match q.sort.as_deref() {

        Some("percent") => "percent",

        Some("path") => "path",

        _ => "missed",

    };

    match sort {

        "percent" => files.sort_by(|a, b| a.percent().unwrap_or(101.0).total_cmp(&b.percent().unwrap_or(101.0)).then(a.path.cmp(&b.path))),

        "path" => {}

        _ => files.sort_by(|a, b| b.missed().cmp(&a.missed()).then(a.path.cmp(&b.path))),

    }

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

    // Charts: oldest on the left.

    let oldest_first: Vec<&Report> = history.iter().rev().filter(|r| r.lines_found > 0).collect();

    let pcts: Vec<f64> = oldest_first.iter().map(|r| r.percent().unwrap_or(0.0)).collect();

    let (lo, hi) = (

        (pcts.iter().copied().fold(100.0, f64::min) - 2.0).floor().max(0.0),

        (pcts.iter().copied().fold(0.0, f64::max) + 2.0).ceil().min(100.0),

    );

    let tip = |r: &Report| {

        format!(

            "Run #{} · {} · {} of {} lines",

            r.run_number,

            r.percent().map(|p| format!("{p:.1}%")).unwrap_or_default(),

            r.lines_hit,

            r.lines_found

        )

    };

    let coverage_chart = chart(

        &format!("Coverage of {bookmark} over the last {} runs", oldest_first.len()),

        &oldest_first,

        &[Series { values: pcts, class: "cov", floor: None }],

        lo,

        hi,

        &|v| format!("{v:.0}%"),

        &repo.url,

        &tip,

    );

    let top = oldest_first.iter().map(|r| r.lines_found).max().unwrap_or(0) as f64;

    let covered: Vec<f64> = oldest_first.iter().map(|r| r.lines_hit as f64).collect();

    let lines_chart = chart(

        &format!("Relevant and covered lines of {bookmark}"),

        &oldest_first,

        &[

            Series { values: covered.clone(), class: "covered", floor: None },

            Series { values: oldest_first.iter().map(|r| r.lines_found as f64).collect(), class: "relevant", floor: Some(covered) },

        ],

        0.0,

        (top * 1.08).max(1.0),

        &compact,

        &repo.url,

        &tip,

    );

    let recent = history

        .iter()

        .enumerate()

        .take(RECENT)

        .map(|(i, r)| RecentRow { report: r.clone(), delta: history.get(i + 1).and_then(|p| Some(r.percent()? - p.percent()?)) })

        .collect();

    let first_ms = coverage::first_ms(&app.db, row.id).await.map_err(e)?;

    Ok(Page(CoveragePage {

        shell,

        repo,

        bookmark,

        bookmarks,

        report,

        previous,

        delta,

        files,

        sort: sort.into(),

        coverage_chart,

        lines_chart,

        runs: oldest_first.len(),

        first_ms,

        recent,

        moved,

        added,

        bands,

    }))

}

/// One line of a file, as the file view shows it.

pub struct CovLine {

    pub number: usize,

    pub html: String,

    /// None: not an instrumented line.

    pub hits: Option<u64>,

}

#[derive(Template)]

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

pub struct CoverageFilePage {

    shell: Shell,

    repo: RepoShell,

    report: Report,

    file: FileRow,

    lines: Vec<CovLine>,

    note: Option<String>,

}

impl CoverageFilePage {

    pub fn pct(&self, p: Option<f64>) -> String {

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

    }

    pub fn class_of(&self, p: Option<f64>) -> &'static str {

        level(p)

    }

}

/// The line counts of the report last read, by file: the file view reads

/// the report's artifact again, so that browsing one report's files

/// parses it once.

type Parsed = Arc<BTreeMap<String, BTreeMap<u32, u64>>>;

static LAST: Mutex<Option<(String, Parsed)>> = Mutex::new(None);

async fn line_counts(app: &Shared, repo: &crate::repos::RepoName, blob: &str) -> Option<Parsed> {

    if let Some((b, p)) = LAST.lock().ok()?.as_ref() {

        if b == blob {

            return Some(p.clone());

        }

    }

    let r = oxy_core::hash::ObjectRef::from_hex(blob)?;

    let bytes = app.repos.read(repo, move |repo, _| Ok(repo.read_blob(&r)?)).await.ok()?;

    let parsed = tokio::task::spawn_blocking(move || {

        let text = String::from_utf8_lossy(&bytes);

        coverage::parse_lcov(&text).ok().map(|(files, _)| files.into_iter().map(|f| (f.path, f.lines)).collect::<BTreeMap<_, _>>())

    })

    .await

    .ok()??;

    let parsed = Arc::new(parsed);

    if let Ok(mut last) = LAST.lock() {

        *last = Some((blob.to_string(), parsed.clone()));

    }

    Some(parsed)

}

/// `GET /{owner}/{name}/coverage/{report}/file/{*path}`.

pub async fn file(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id, path)): Path<(String, String, i64, String)>,

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

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

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

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

    let report = coverage::report(&app.db, row.id, id).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;

    let file = coverage::files(&app.db, report.id)

        .await

        .map_err(e)?

        .into_iter()

        .find(|f| f.path == path)

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

    let counts = line_counts(&app, &repo_name, &report.blob).await.and_then(|p| p.get(&path).cloned()).unwrap_or_default();

    let heads: Vec<_> = report.head_list().into_iter().filter_map(oxy_core::hash::ChangeHash::from_hex).collect();

    let limit = app.config.limits.render_limit.0;