//! The Tests tab (oxygenhub#114): a bookmark's test results from its runs'

//! JUnit reports, their trend, what changed against the run before, the

//! slowest tests, and those that failed and passed across recent runs.

use super::coverage::{chart, compact, Point, Series};

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

use crate::auth::Viewer;

use crate::junit::{self, Case, Flaky, Report};

use crate::Shared;

use askama::Template;

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

use serde::Deserialize;

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

const HISTORY: i64 = 200;

/// Runs listed under Recent runs.

const RECENT: usize = 10;

/// Runs a test must have failed and passed in to be listed as flaky.

const FLAKY_RUNS: usize = 30;

/// Rows of the slowest and flaky lists, and of the changed lists.

const LISTED: i64 = 15;

#[derive(Deserialize, Default)]

pub struct TestsQuery {

    /// A bookmark other than the default.

    bookmark: Option<String>,

    /// One report, by id.

    report: Option<i64>,

}

/// A run in the Recent runs list.

pub struct RecentRow {

    pub report: Report,

    /// Tests added against the report before it.

    pub delta: Option<i64>,

}

/// A test whose result changed against the run before.

pub struct Changed {

    pub title: String,

    pub status: String,

}

#[derive(Template)]

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

pub struct TestsPage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    bookmarks: Vec<String>,

    report: Option<Report>,

    previous: Option<Report>,

    /// Tests that fail now and passed in the run before.

    broke: Vec<Changed>,

    /// Tests that pass now and failed in the run before.

    fixed: Vec<Changed>,

    /// Tests new since the run before.

    added: usize,

    failures: Vec<Case>,

    slowest: Vec<Case>,

    flaky: Vec<Flaky>,

    flaky_runs: usize,

    rate_chart: String,

    count_chart: String,

    runs: usize,

    first_ms: Option<i64>,

    recent: Vec<RecentRow>,

}

/// Passed of the tests that ran (skipped ones left out), as a percentage.

pub fn pass_rate(r: &Report) -> Option<f64> {

    let ran = r.tests - r.skipped;

    (ran > 0).then(|| r.passed as f64 * 100.0 / ran as f64)

}

impl TestsPage {

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

        match pass_rate(r) {

            Some(p) if p >= 99.95 => "100%".into(),

            Some(p) => format!("{p:.1}%"),

            None => "–".into(),

        }

    }

    /// A colour class: all passing, a few failing, many.

    pub fn class_of(&self, r: &Report) -> &'static str {

        match pass_rate(r) {

            None => "cov-none",

            Some(_) if r.broken() == 0 => "cov-good",

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

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

        }

    }

    pub fn time(&self, ms: &i64) -> String {

        crate::flow::human_ms(*ms)

    }

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

        if *d == 0 {

            "±0".into()

        } else {

            format!("{d:+}")

        }

    }

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

        Some(self.report.as_ref()?.tests - self.previous.as_ref()?.tests)

    }

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

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

        if p.time_ms == 0 {

            return None;

        }

        let d = (r.time_ms - p.time_ms) as f64 * 100.0 / p.time_ms as f64;

        (d.abs() >= 1.0).then(|| format!("{d:+.0}%"))

    }

}

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

pub async fn overview(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<TestsQuery>,

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

    let shell = Shell::new(&app, &format!("/{owner}/{name}/tests"), &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(junit::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 = junit::bookmarks(&app.db, row.id).await.map_err(e)?;

    let history = junit::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, of the same job on the bookmark.

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

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

    });

    let (mut broke, mut fixed, mut added) = (vec![], vec![], 0);

    let (mut failures, mut slowest) = (vec![], vec![]);

    if let Some(r) = &report {

        failures = junit::failures(&app.db, r.id, 50).await.map_err(e)?;

        slowest = junit::slowest(&app.db, r.id, LISTED).await.map_err(e)?;

        if let Some(p) = &previous {

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

            let before = junit::statuses(&app.db, p.id).await.map_err(e)?;

            let bad = |s: &str| s == "failed" || s == "error";

            let title = |(c, n): &(String, String)| if c.is_empty() { n.clone() } else { format!("{c}::{n}") };

            for (k, s) in &now {

                match before.get(k) {

                    None => added += 1,

                    Some(b) if bad(s) && !bad(b) => broke.push(Changed { title: title(k), status: s.clone() }),

                    Some(b) if s == "passed" && bad(b) => fixed.push(Changed { title: title(k), status: s.clone() }),

                    _ => {}

                }

            }

            broke.sort_by(|a, b| a.title.cmp(&b.title));

            fixed.sort_by(|a, b| a.title.cmp(&b.title));

            broke.truncate(LISTED as usize);

            fixed.truncate(LISTED as usize);

        }

    }

    let recent_ids: Vec<i64> = history.iter().take(FLAKY_RUNS).map(|r| r.id).collect();

    let flaky = junit::flaky(&app.db, &recent_ids, LISTED).await.map_err(e)?;

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

    // Charts: oldest on the left.

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

    let points: Vec<Point> = oldest_first

        .iter()

        .map(|r| Point {

            run: r.run_number,

            href: format!("{}/tests?report={}", repo.url, r.id),

            tip: format!("Run #{} · {} · {}", r.run_number, r.summary(), crate::flow::human_ms(r.time_ms)),

        })

        .collect();

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

    let lo = (rates.iter().copied().fold(100.0, f64::min) - 2.0).floor().max(0.0);

    let rate_chart = chart(

        &format!("Tests passing on {bookmark} over the last {} runs", oldest_first.len()),

        &points,

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

        lo,

        100.0,

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

    );

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

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

    let count_chart = chart(

        &format!("Tests passing and failing on {bookmark}"),

        &points,

        &[

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

            Series { values: oldest_first.iter().map(|r| (r.tests - r.skipped) as f64).collect(), class: "relevant", floor: Some(passed) },

        ],

        0.0,

        (top * 1.08).max(1.0),

        &compact,

    );

    let recent = history

        .iter()

        .enumerate()

        .take(RECENT)

        .map(|(i, r)| RecentRow { report: r.clone(), delta: history.get(i + 1).filter(|p| p.job == r.job).map(|p| r.tests - p.tests) })

        .collect();

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

    Ok(Page(TestsPage {

        shell,

        repo,

        bookmark,

        bookmarks,

        report,

        previous,

        broke,

        fixed,

        added,

        failures,

        slowest,

        flaky,

        flaky_runs: recent_ids.len(),

        rate_chart,

        count_chart,

        runs: oldest_first.len(),

        first_ms,

        recent,

    }))

}

#[derive(Deserialize)]

pub struct CaseQuery {

    #[serde(default)]

    classname: String,

    name: String,

    bookmark: Option<String>,

}

#[derive(Template)]

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

pub struct TestCasePage {

    shell: Shell,

    repo: RepoShell,

    bookmark: String,

    title: String,

    runs: Vec<junit::Run>,

    passed: usize,

    failed: usize,

    time_chart: String,

}

impl TestCasePage {

    pub fn time(&self, ms: &i64) -> String {

        crate::flow::human_ms(*ms)

    }

}

/// `GET /{owner}/{name}/tests/case?classname=&name=`: one test across the

/// bookmark's last runs: its result, time and message in each.

pub async fn case(

    State(app): State<Shared>,

    viewer: Viewer,

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

    Query(q): Query<CaseQuery>,

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

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

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

    let bookmark = q.bookmark.unwrap_or_else(|| row.default_bookmark.clone());

    let runs =

        junit::history(&app.db, row.id, &bookmark, &q.classname, &q.name, HISTORY).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    if runs.is_empty() {

        return Err(Error::not_found(shell));

    }

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

    let passed = runs.iter().filter(|r| r.status == "passed").count();

    let failed = runs.iter().filter(|r| r.status == "failed" || r.status == "error").count();

    let oldest: Vec<&junit::Run> = runs.iter().rev().collect();

    let points: Vec<Point> = oldest

        .iter()

        .map(|r| Point {

            run: r.run_number,

            href: format!("{}/tests?report={}", repo.url, r.report_id),

            tip: format!("Run #{} · {} · {}", r.run_number, r.status, crate::flow::human_ms(r.time_ms)),

        })

        .collect();

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

    let time_chart = chart(

        "Time per run",

        &points,

        &[Series { values: oldest.iter().map(|r| r.time_ms as f64).collect(), class: "cov", floor: None }],

        0.0,

        (top * 1.1).max(1.0),

        &|v| crate::flow::human_ms(v as i64),

    );

    let title = if q.classname.is_empty() { q.name.clone() } else { format!("{}::{}", q.classname, q.name) };

    Ok(Page(TestCasePage { shell, repo, bookmark, title, runs, passed, failed, time_chart }))

}