//! Coverage reports (oxygenhub#113): Coveralls built into the hub. An

//! OxygenFlow job that declares an artifact named `coverage` in LCOV

//! format (what `cargo llvm-cov --lcov`, Istanbul, coverage.py and

//! gcov/lcov write) or Cobertura XML has it parsed when it is uploaded. The totals and each

//! file's counts are kept per run; the per-line counts are read again from

//! the artifact's blob for the file view. Paths are taken relative to the

//! job's workspace (`/src`), and only files of the run's state are kept.

use crate::db::{now_ms, Pool};

use crate::Shared;

use std::collections::{BTreeMap, HashSet};

use std::sync::Mutex;

/// The artifact name a pipeline gives its report.

pub const ARTIFACT: &str = "coverage";

/// The largest report parsed.

pub const MAX_REPORT: usize = 64 << 20;

/// One file's coverage, from a report.

#[derive(Clone, Debug, Default, PartialEq, Eq)]

pub struct FileCoverage {

    /// Relative to the repository's root.

    pub path: String,

    /// Each instrumented line and how often it ran, by line number.

    pub lines: BTreeMap<u32, u64>,

    pub functions_found: u64,

    pub functions_hit: u64,

    pub branches_found: u64,

    pub branches_hit: u64,

    /// The file's own `LF`/`LH` totals, when it had one record: the tool's

    /// own count, which can name lines the `DA` lines leave out (llvm-cov

    /// does), so the hub agrees with what the tool printed.

    pub declared_lines: Option<(u64, u64)>,

}

impl FileCoverage {

    pub fn lines_found(&self) -> u64 {

        self.declared_lines.map(|d| d.0).unwrap_or(self.lines.len() as u64)

    }

    pub fn lines_hit(&self) -> u64 {

        self.declared_lines.map(|d| d.1).unwrap_or_else(|| self.lines.values().filter(|n| **n > 0).count() as u64)

    }

    /// Every run of every line, added up.

    pub fn hits(&self) -> u64 {

        self.lines.values().fold(0u64, |a, n| a.saturating_add(*n))

    }

}

/// A path as a report names it, relative to the repository: the Flow

/// workspace's `/src/` and a leading `./` taken off. `None` for a path

/// outside the repository.

pub fn relative(path: &str) -> Option<String> {

    let p = path.trim();

    let p = p.strip_prefix("/src/").unwrap_or(p);

    let p = p.strip_prefix("./").unwrap_or(p);

    if p.is_empty() || p.starts_with('/') || p.contains('\\') || p.split('/').any(|s| s.is_empty() || s == "." || s == "..") {

        return None;

    }

    Some(p.to_string())

}

#[derive(Default)]

struct Acc {

    lines: BTreeMap<u32, u64>,

    functions: BTreeMap<String, u64>,

    branches: BTreeMap<(u32, String, String), u64>,

    declared_fn: (u64, u64),

    declared_br: (u64, u64),

    declared_lines: (Option<u64>, Option<u64>),

    records: u32,

}

/// Parse an LCOV report into each file's coverage, records for the same

/// file (from several test binaries) added together. Files whose paths

/// are outside the repository are counted in the second value.

pub fn parse_lcov(text: &str) -> Result<(Vec<FileCoverage>, usize), String> {

    let mut files: BTreeMap<String, Acc> = BTreeMap::new();

    let mut current: Option<Option<String>> = None;

    let mut outside = HashSet::new();

    let mut records = 0usize;

    // A new SF: record has begun and not yet been counted for its file.

    let mut started = false;

    let num = |s: &str| s.trim().parse::<u64>().unwrap_or(0);

    for line in text.lines() {

        let line = line.trim();

        if let Some(path) = line.strip_prefix("SF:") {

            records += 1;

            let rel = relative(path);

            if rel.is_none() {

                outside.insert(path.to_string());

            }

            current = Some(rel);

            started = true;

            continue;

        }

        if line == "end_of_record" {

            current = None;

            continue;

        }

        let Some(Some(path)) = &current else { continue };

        let acc = files.entry(path.clone()).or_default();

        if line == "TN:" || line.starts_with("TN:") {

            continue;

        }

        if std::mem::take(&mut started) {

            acc.records += 1;

        }

        if let Some(n) = line.strip_prefix("LF:") {

            acc.declared_lines.0 = Some(num(n));

        } else if let Some(n) = line.strip_prefix("LH:") {

            acc.declared_lines.1 = Some(num(n));

        } else if let Some(rest) = line.strip_prefix("DA:") {

            let mut parts = rest.split(',');

            if let (Some(l), Some(n)) = (parts.next(), parts.next()) {

                if let Ok(l) = l.trim().parse::<u32>() {

                    *acc.lines.entry(l).or_default() += num(n);

                }

            }

        } else if let Some(rest) = line.strip_prefix("FN:") {

            if let Some((_, name)) = rest.split_once(',') {

                acc.functions.entry(name.to_string()).or_default();

            }

        } else if let Some(rest) = line.strip_prefix("FNDA:") {

            if let Some((n, name)) = rest.split_once(',') {

                *acc.functions.entry(name.to_string()).or_default() += num(n);

            }

        } else if let Some(rest) = line.strip_prefix("BRDA:") {

            let parts: Vec<&str> = rest.split(',').collect();

            if let [l, block, branch, taken] = parts[..] {

                if let Ok(l) = l.trim().parse::<u32>() {

                    let taken = if taken.trim() == "-" { 0 } else { num(taken) };

                    *acc.branches.entry((l, block.to_string(), branch.to_string())).or_default() += taken;

                }

            }

        } else if let Some(n) = line.strip_prefix("FNF:") {

            acc.declared_fn.0 = acc.declared_fn.0.max(num(n));

        } else if let Some(n) = line.strip_prefix("FNH:") {

            acc.declared_fn.1 = acc.declared_fn.1.max(num(n));

        } else if let Some(n) = line.strip_prefix("BRF:") {

            acc.declared_br.0 = acc.declared_br.0.max(num(n));

        } else if let Some(n) = line.strip_prefix("BRH:") {

            acc.declared_br.1 = acc.declared_br.1.max(num(n));

        }

    }

    if records == 0 {

        return Err("this is not an LCOV report: it names no source file (no SF: line)".into());

    }

    let out = files

        .into_iter()

        .map(|(path, a)| {

            let (functions_found, functions_hit) = if a.functions.is_empty() {

                a.declared_fn

            } else {

                (a.functions.len() as u64, a.functions.values().filter(|n| **n > 0).count() as u64)

            };

            let (branches_found, branches_hit) = if a.branches.is_empty() {

                a.declared_br

            } else {

                (a.branches.len() as u64, a.branches.values().filter(|n| **n > 0).count() as u64)

            };

            let declared_lines = match (a.records, a.declared_lines) {

                (1, (Some(f), Some(h))) if h <= f && f >= a.lines.len() as u64 => Some((f, h)),

                _ => None,

            };

            FileCoverage { path, lines: a.lines, functions_found, functions_hit, branches_found, branches_hit, declared_lines }

        })

        .collect();

    Ok((out, outside.len()))

}

/// Parse a report in either format the hub reads: Cobertura XML (it

/// starts with `<`) or LCOV. Returns the files, those outside the

/// repository, and the format's name.

pub fn parse(text: &str) -> Result<(Vec<FileCoverage>, usize, &'static str), String> {

    if text.trim_start().starts_with('<') {

        parse_cobertura(text).map(|(f, o)| (f, o, "cobertura"))

    } else {

        parse_lcov(text).map(|(f, o)| (f, o, "lcov"))

    }

}

fn xml_attr(e: &quick_xml::events::BytesStart, name: &str) -> String {

    e.try_get_attribute(name)

        .ok()

        .flatten()

        .and_then(|a| a.normalized_value(quick_xml::XmlVersion::Implicit1_0).ok().map(|v| v.into_owned()))

        .unwrap_or_default()

}

/// Parse a Cobertura XML report (coverage.py `coverage xml`, JaCoCo via

/// cover2cover, .NET Coverlet, `cargo llvm-cov --cobertura`): each

/// `<class>`'s `<line number hits>` by file, with `branch` lines'

/// `condition-coverage="50% (1/2)"` as branches and `<method>`s as

/// functions (one is hit when any of its lines ran). A file named by

/// several classes is added together. A `<source>` is tried as the base of

/// a relative filename, the workspace's `/src` among them.

pub fn parse_cobertura(text: &str) -> Result<(Vec<FileCoverage>, usize), String> {

    use quick_xml::events::Event;

    let mut r = quick_xml::Reader::from_str(text);

    let mut sources: Vec<String> = Vec::new();

    let mut in_source = false;

    let mut source_text = String::new();

    // Files as the classes name them, resolved once the sources are known.

    let mut raw: BTreeMap<String, Acc> = BTreeMap::new();

    let mut file: Option<String> = None;

    let mut method: Option<(String, bool)> = None;

    let mut seen_root = false;

    loop {

        let ev = r.read_event().map_err(|e| format!("this is not a Cobertura report: {e}"))?;

        match ev {

            Event::Start(ref e) | Event::Empty(ref e) => {

                let tag = e.local_name().as_ref().to_string();

                match tag.as_str() {

                    "coverage" => seen_root = true,

                    "source" if matches!(ev, Event::Start(_)) => {

                        in_source = true;

                        source_text.clear();

                    }

                    "class" => {

                        let f = xml_attr(e, "filename");

                        raw.entry(f.clone()).or_default().records += 1;

                        file = Some(f);

                    }

                    "method" => method = Some((xml_attr(e, "name") + &xml_attr(e, "signature"), false)),

                    "line" => {

                        let Some(f) = &file else { continue };

                        let Ok(n) = xml_attr(e, "number").trim().parse::<u32>() else { continue };

                        let hits = xml_attr(e, "hits").trim().parse::<u64>().unwrap_or(0);

                        if let Some((_, hit)) = &mut method {

                            *hit |= hits > 0;

                            // A method's lines repeat the class's; count them once.

                            continue;

                        }

                        let acc = raw.entry(f.clone()).or_default();

                        *acc.lines.entry(n).or_default() += hits;

                        if xml_attr(e, "branch") == "true" {

                            // "50% (1/2)": covered of total conditions.

                            let cc = xml_attr(e, "condition-coverage");

                            if let Some((hit, total)) = cc

                                .split_once('(')

                                .and_then(|(_, rest)| rest.trim_end_matches(')').split_once('/'))

                                .and_then(|(h, t)| Some((h.trim().parse::<u64>().ok()?, t.trim().parse::<u64>().ok()?)))

                            {

                                for i in 0..total {

                                    let b = acc.branches.entry((n, "0".into(), i.to_string())).or_default();

                                    *b = (*b).max(u64::from(i < hit));

                                }

                            }

                        }

                    }

                    _ => {}

                }

                if matches!(ev, Event::Empty(_)) && tag == "method" {

                    if let (Some(f), Some((name, hit))) = (&file, method.take()) {

                        *raw.entry(f.clone()).or_default().functions.entry(name).or_default() += u64::from(hit);

                    }

                }

            }

            Event::Text(t) if in_source => source_text.push_str(&t.xml10_content()),

            Event::End(e) => match e.local_name().as_ref() {

                "source" => {

                    in_source = false;

                    sources.push(source_text.trim().trim_end_matches('/').to_string());

                }

                "class" => file = None,

                "method" => {

                    if let (Some(f), Some((name, hit))) = (&file, method.take()) {

                        *raw.entry(f.clone()).or_default().functions.entry(name).or_default() += u64::from(hit);

                    }

                }

                _ => {}

            },

            Event::Eof => break,

            _ => {}

        }

    }

    if !seen_root {

        return Err("this is not a Cobertura report: no <coverage> element".into());

    }

    if raw.is_empty() {

        return Err("this Cobertura report names no source file (no <class filename>)".into());

    }

    // A filename relative to one of the sources, or to the workspace.

    let resolve = |f: &str| -> Option<String> {

        if f.starts_with('/') {

            return relative(f);

        }

        sources.iter().filter(|s| !s.is_empty() && *s != ".").find_map(|s| relative(&format!("{s}/{f}"))).or_else(|| relative(f))

    };

    let mut files: BTreeMap<String, Acc> = BTreeMap::new();

    let mut outside = HashSet::new();

    for (f, a) in raw {

        let Some(path) = resolve(&f) else {

            outside.insert(f);

            continue;

        };

        let into = files.entry(path).or_default();

        for (l, n) in a.lines {

            *into.lines.entry(l).or_default() += n;

        }

        for (k, n) in a.functions {

            *into.functions.entry(k).or_default() += n;

        }

        for (k, n) in a.branches {

            let b = into.branches.entry(k).or_default();

            *b = (*b).max(n);

        }

    }

    let out = files

        .into_iter()

        .map(|(path, a)| FileCoverage {

            path,

            functions_found: a.functions.len() as u64,

            functions_hit: a.functions.values().filter(|n| **n > 0).count() as u64,

            branches_found: a.branches.len() as u64,

            branches_hit: a.branches.values().filter(|n| **n > 0).count() as u64,

            lines: a.lines,

            declared_lines: None,

        })

        .collect();

    Ok((out, outside.len()))

}

/// A percentage to one decimal place, or none when nothing was counted.

pub fn percent(hit: i64, found: i64) -> Option<f64> {

    (found > 0).then(|| (hit as f64 * 1000.0 / found as f64).round() / 10.0)

}

#[derive(Clone, Debug, sqlx::FromRow)]

pub struct Report {

    pub id: i64,

    pub repo_id: i64,

    /// The Flow run and job it came from; none for an upload (#136).

    pub run_id: Option<i64>,

    pub job_id: Option<i64>,

    pub job: String,

    pub run_number: i64,

    pub bookmark: String,

    pub state: String,

    pub heads: String,

    pub blob: String,

    pub format: String,

    pub lines_found: i64,

    pub lines_hit: i64,

    pub functions_found: i64,

    pub functions_hit: i64,

    pub branches_found: i64,

    pub branches_hit: i64,

    pub hits: i64,

    pub files: i64,

    pub dropped: i64,

    pub created_ms: i64,

    /// Who uploaded it from a workstation (#136); empty for a job's report.

    pub uploader: String,

}

impl Report {

    /// Whether it was uploaded rather than measured by a Flow job.

    pub fn uploaded(&self) -> bool {

        !self.uploader.is_empty()

    }

    /// Where its figure came from: "run #61", or "uploaded by NAME".

    pub fn source(&self) -> String {

        if self.uploaded() {

            format!("uploaded by {}", self.uploader)

        } else {

            format!("run #{}", self.run_number)

        }

    }

    /// How often an instrumented line ran, on average.

    pub fn hits_per_line(&self) -> Option<f64> {

        (self.lines_found > 0).then(|| self.hits as f64 / self.lines_found as f64)

    }

    pub fn percent(&self) -> Option<f64> {

        percent(self.lines_hit, self.lines_found)

    }

    pub fn functions_percent(&self) -> Option<f64> {

        percent(self.functions_hit, self.functions_found)

    }

    pub fn branches_percent(&self) -> Option<f64> {

        percent(self.branches_hit, self.branches_found)

    }

    pub fn head_list(&self) -> Vec<&str> {

        self.heads.split(',').filter(|h| !h.is_empty()).collect()

    }

}

#[derive(Clone, Debug, sqlx::FromRow)]

pub struct FileRow {

    pub report_id: i64,

    pub path: String,

    pub lines_found: i64,

    pub lines_hit: i64,

    pub functions_found: i64,

    pub functions_hit: i64,

    pub branches_found: i64,

    pub branches_hit: i64,

}

impl FileRow {

    pub fn percent(&self) -> Option<f64> {

        percent(self.lines_hit, self.lines_found)

    }

    pub fn missed(&self) -> i64 {

        self.lines_found - self.lines_hit

    }

}

/// Repositories with a report, so their pages show the Coverage tab:

/// keyed by the hub's repository root and the id, unique even between

/// hubs in one process.

static HAS: Mutex<Option<HashSet<String>>> = Mutex::new(None);

fn key(app: &Shared, repo_id: i64) -> String {

    format!("{}#{repo_id}", app.repos.root().display())

}

pub fn has_reports(app: &Shared, repo_id: i64) -> bool {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).as_ref().is_some_and(|s| s.contains(&key(app, repo_id)))

}

fn mark(app: &Shared, repo_id: i64) {

    HAS.lock().unwrap_or_else(|p| p.into_inner()).get_or_insert_with(HashSet::new).insert(key(app, repo_id));

}

/// At start: which repositories have reports.

pub async fn load(app: &Shared) -> sqlx::Result<()> {