//! 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 drawn on the trend.

const TREND: i64 = 30;

#[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>,

}

#[derive(Template)]

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

pub struct CoveragePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    report: Option<Report>,

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

    delta: Option<f64>,

    files: Vec<FileRow>,

    sort: String,

    trend: String,

    runs: usize,

}

impl CoveragePage {

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

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

    }

    pub fn delta_text(&self) -> Option<String> {

        self.delta.map(|d| if d.abs() < 0.05 { "unchanged".to_string() } else { format!("{d:+.1}") })

    }

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

        level(p)

    }

}

/// 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",

    }

}

/// The trend as an SVG line chart, oldest on the left.

fn trend_svg(reports: &[Report], url: &str) -> String {

    let points: Vec<(f64, &Report)> = reports.iter().rev().filter_map(|r| r.percent().map(|p| (p, r))).collect();

    if points.len() < 2 {

        return String::new();

    }

    let (w, h, pad) = (640.0, 120.0, 8.0);

    let lo = points.iter().map(|p| p.0).fold(100.0f64, f64::min).floor().max(0.0);

    let hi = points.iter().map(|p| p.0).fold(0.0f64, f64::max).ceil().min(100.0);

    let (lo, hi) = if hi - lo < 2.0 { ((lo - 1.0).max(0.0), (hi + 1.0).min(100.0)) } else { (lo, hi) };

    let step = (w - 2.0 * pad) / (points.len() - 1) as f64;

    let y = |p: f64| pad + (hi - p) / (hi - lo) * (h - 2.0 * pad);

    let line: Vec<String> = points.iter().enumerate().map(|(i, (p, _))| format!("{:.1},{:.1}", pad + i as f64 * step, y(*p))).collect();

    let mut svg = format!(

        r#"<svg class="cov-trend" viewBox="0 0 {w} {h}" role="img" aria-label="Coverage over the last {n} runs, from {first:.1}% to {last:.1}%"><text x="{w}" y="12" text-anchor="end" class="axis">{hi}%</text><text x="{w}" y="{hb}" text-anchor="end" class="axis">{lo}%</text><polyline points="{pts}"/>"#,

        n = points.len(),

        first = points[0].0,

        last = points[points.len() - 1].0,

        hb = h - 2.0,

        pts = line.join(" "),

    );

    for (i, (p, r)) in points.iter().enumerate() {

        svg.push_str(&format!(

            r#"<a href="{url}/coverage?report={id}"><circle cx="{x:.1}" cy="{y:.1}" r="3.5"><title>Run #{run}: {p:.1}%</title></circle></a>"#,

            id = r.id,

            x = pad + i as f64 * step,

            y = y(*p),

            run = r.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 report = 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 = report.as_ref().map(|r| r.bookmark.clone()).or(q.bookmark.clone()).unwrap_or_else(|| row.default_bookmark.clone());

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

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

    let delta = report.as_ref().and_then(|r| {

        let before = history.iter().find(|h| h.created_ms < r.created_ms || (h.created_ms == r.created_ms && h.id < r.id))?;

        Some(r.percent()? - before.percent()?)

    });

    let mut files = match &report {

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

        None => vec![],

    };

    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);

    let trend = trend_svg(&history, &repo.url);

    Ok(Page(CoveragePage { shell, repo, bookmark, report, delta, files, sort: sort.into(), trend, runs: history.len() }))

}

/// 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;

    let p = path.clone();

    let target = RefTarget { label: report.state.clone(), kind: RefKind::Change, heads };

    let fv = app

        .repos

        .read(&repo_name, move |r, cache| view::file(r, cache, target, &p, limit))

        .await

        .map_err(|e| Error::from_repo(shell.clone(), e))?;

    let (lines, note) = match &fv.body {

        FileBody::Text(text) => {

            let html = crate::render::highlight::lines(&path, text);

            let lines = html

                .into_iter()

                .enumerate()

                .map(|(i, h)| CovLine { number: i + 1, html: h, hits: counts.get(&(i as u32 + 1)).copied() })

                .collect();

            (lines, None)

        }

        FileBody::Binary => (vec![], Some("This file is binary.".to_string())),

        FileBody::TooLarge => (vec![], Some("This file is too large to show.".to_string())),

    };

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

    Ok(Page(CoverageFilePage { shell, repo, report, file, lines, note }))

}

/// `GET /{owner}/{name}/coverage/badge.svg`: the default bookmark's latest coverage.

pub async fn badge(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Response, Error> {

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

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

    let latest = coverage::on_bookmark(&app.db, row.id, &row.default_bookmark, 1).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let pct = latest.first().and_then(|r| r.percent());

    let text = pct.map(|p| format!("{p:.1}%")).unwrap_or_else(|| "unknown".into());

    let colour = match level(pct) {

        "cov-good" => "#2da44e",

        "cov-fair" => "#97ca00",

        "cov-low" => "#dfb317",

        "cov-poor" => "#e05d44",

        _ => "#6e7781",

    };

    let label = "coverage";

    let (lw, tw) = (label.len() as u32 * 7 + 10, text.len() as u32 * 7 + 10);

    let svg = format!(

        r##"<svg xmlns="http://www.w3.org/2000/svg" width="{w}" height="20" role="img" aria-label="{label}: {text}"><title>{label}: {text}</title><rect width="{lw}" height="20" rx="3" fill="#555"/><rect x="{lw}" width="{tw}" height="20" rx="3" fill="{colour}"/><rect x="{lw}" width="4" height="20" fill="{colour}"/><g fill="#fff" font-family="Verdana,DejaVu Sans,sans-serif" font-size="11" text-anchor="middle"><text x="{lx}" y="14">{label}</text><text x="{tx}" y="14">{text}</text></g></svg>"##,

        w = lw + tw,

        lx = lw / 2,

        tx = lw + tw / 2,

    );

    Ok((

        [(axum::http::header::CONTENT_TYPE, "image/svg+xml; charset=utf-8"), (axum::http::header::CACHE_CONTROL, "no-cache, max-age=60")],

        svg,

    )

        .into_response())

}