//! `flow deps check` (#101): whether every crate a `Cargo.lock` needs is
//! vendored in the build image at that version. Jobs run with no network,
//! so a crate the image lacks fails the run with "no matching package";
//! this says so before the push, naming the versions the image does have.

use std::collections::{BTreeMap, BTreeSet};
use std::path::Path;

/// A crate at a version.
pub type Crate = (String, String);

/// The packages of a `Cargo.lock` that come from somewhere (a registry or
/// git): the ones `cargo vendor` copies. A workspace's own members have no
/// `source` and are left out.
pub fn from_lock(text: &str) -> Result<BTreeSet<Crate>, String> {
    let lock: toml::Value = text.parse().map_err(|e| format!("not a Cargo.lock: {e}"))?;
    let mut out = BTreeSet::new();
    for p in lock.get("package").and_then(|p| p.as_array()).into_iter().flatten() {
        let (Some(name), Some(version)) = (p.get("name").and_then(|v| v.as_str()), p.get("version").and_then(|v| v.as_str())) else {
            continue;
        };
        if p.get("source").is_some() {
            out.insert((name.to_string(), version.to_string()));
        }
    }
    Ok(out)
}

/// A crate list as `flow deps list` and the image's `crates.txt` write it:
/// `NAME VERSION` a line; blank lines and `#` comments are skipped.
pub fn from_list(text: &str) -> BTreeSet<Crate> {
    text.lines()
        .map(str::trim)
        .filter(|l| !l.is_empty() && !l.starts_with('#'))
        .filter_map(|l| {
            let mut w = l.split_whitespace();
            Some((w.next()?.to_string(), w.next()?.to_string()))
        })
        .collect()
}

/// The crates of a `cargo vendor` directory (the image's `/opt/vendor`):
/// each subdirectory's `Cargo.toml` names its package and version.
pub fn from_vendor(dir: &Path) -> Result<BTreeSet<Crate>, String> {
    let entries = std::fs::read_dir(dir).map_err(|e| format!("{}: {e}", dir.display()))?;
    let mut out = BTreeSet::new();
    for e in entries.flatten() {
        let manifest = e.path().join("Cargo.toml");
        let Ok(text) = std::fs::read_to_string(&manifest) else { continue };
        let Ok(v) = text.parse::<toml::Value>() else { continue };
        let pkg = v.get("package");
        let field = |k: &str| pkg.and_then(|p| p.get(k)).and_then(|x| x.as_str()).map(str::to_string);
        if let (Some(n), Some(ver)) = (field("name"), field("version")) {
            out.insert((n, ver));
        }
    }
    Ok(out)
}

/// What `need` lacks from `have`, each with the versions of that crate
/// `have` does hold (empty when it holds none).
pub fn missing(need: &BTreeSet<Crate>, have: &BTreeSet<Crate>) -> Vec<(Crate, Vec<String>)> {
    let mut versions: BTreeMap<&str, Vec<String>> = BTreeMap::new();
    for (n, v) in have {
        versions.entry(n.as_str()).or_default().push(v.clone());
    }
    need.iter().filter(|c| !have.contains(*c)).map(|c| (c.clone(), versions.get(c.0.as_str()).cloned().unwrap_or_default())).collect()
}

/// A crate list in the form [`from_list`] reads.
pub fn render_list(crates: &BTreeSet<Crate>) -> String {
    crates.iter().map(|(n, v)| format!("{n} {v}\n")).collect()
}

#[cfg(test)]
mod tests {
    use super::*;

    const LOCK: &str = r#"
version = 4

[[package]]
name = "mine"
version = "0.1.0"
dependencies = ["rustls"]

[[package]]
name = "rustls"
version = "0.23.45"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "tokio-rustls"
version = "0.26.5"
source = "registry+https://github.com/rust-lang/crates.io-index"

[[package]]
name = "deranged"
version = "0.5.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
"#;

    #[test]
    fn names_what_the_image_lacks_and_what_it_has_instead() {
        let need = from_lock(LOCK).unwrap();
        assert_eq!(need.len(), 3, "the workspace's own package is not vendored");
        let have = from_list("# the image\nrustls 0.23.45\ntokio-rustls 0.26.4\n\n");
        let m = missing(&need, &have);
        assert_eq!(
            m,
            vec![(("deranged".into(), "0.5.8".into()), vec![]), (("tokio-rustls".into(), "0.26.5".into()), vec!["0.26.4".into()]),]
        );
        assert!(missing(&need, &need).is_empty());
        assert_eq!(from_list(&render_list(&need)), need);
        assert!(from_lock("not = [toml").is_err());
    }

    #[test]
    fn reads_a_vendor_directory() {
        let dir = tempfile::tempdir().unwrap();
        for (d, n, v) in [("rustls-0.23.45", "rustls", "0.23.45"), ("pre-1.0.0-rc.1", "pre", "1.0.0-rc.1")] {
            std::fs::create_dir(dir.path().join(d)).unwrap();
            std::fs::write(dir.path().join(d).join("Cargo.toml"), format!("[package]\nname = \"{n}\"\nversion = \"{v}\"\n")).unwrap();
        }
        std::fs::create_dir(dir.path().join("junk")).unwrap();
        let got = from_vendor(dir.path()).unwrap();
        assert_eq!(got, from_list("rustls 0.23.45\npre 1.0.0-rc.1\n"));
    }
}