//! Projects from the command line (spec §23.1): relations come from
//! `.oxymodules`, matched by remote, whichever is registered first; an agent
//! needs a registered project.

use spectra_core::keys::KeyPair;
use std::path::Path;
use std::process::{Command, Output};

fn hermetic(dir: &Path) -> Command {
    let mut c = Command::new(env!("CARGO_BIN_EXE_spectra"));
    c.env("SPECTRA_DATA", dir.join("data"))
        .env("OXY_HOME", dir.join("owner"))
        .env("HOME", dir)
        .env("XDG_DATA_HOME", dir.join("xdg"))
        .env("NO_COLOR", "1");
    c
}

fn run(dir: &Path, args: &[&str]) -> Output {
    hermetic(dir).args(args).output().unwrap()
}

fn text(o: &Output) -> String {
    format!("{}{}", String::from_utf8_lossy(&o.stdout), String::from_utf8_lossy(&o.stderr))
}

/// A checkout as `oxy` leaves one: an id, a remote, and the subrepos it pins.
fn checkout(at: &Path, remote: &str, pins: &[&str]) {
    std::fs::create_dir_all(at.join(".oxy")).unwrap();
    std::fs::write(at.join(".oxy/id"), "0123456789abcdef0123456789abcdef").unwrap();
    std::fs::write(at.join(".oxy/config"), format!("remote.origin.url = \"{remote}\"\n")).unwrap();
    let modules: String = pins.iter().enumerate().map(|(i, u)| format!("[deps/{i}]\nurl = {u}\nbookmark = main\n")).collect();
    std::fs::write(at.join(".oxymodules"), modules).unwrap();
}

fn setup() -> tempfile::TempDir {
    let dir = tempfile::tempdir().unwrap();
    KeyPair::create_home(&dir.path().join("owner"), "Andy McCall", "").unwrap();
    assert!(run(dir.path(), &["init"]).status.success());
    dir
}

fn projects(d: &Path) -> serde_json::Value {
    serde_json::from_slice(&run(d, &["project", "list", "--json"]).stdout).unwrap()
}

#[test]
fn relations_are_found_whichever_project_comes_first() {
    for hub_first in [false, true] {
        let dir = setup();
        let d = dir.path();
        checkout(&d.join("oxygen"), "https://hub.example/andy/oxygen", &[]);
        checkout(&d.join("oxygenhub"), "https://hub.example/andy/oxygenhub", &["https://hub.example/andy/oxygen"]);
        let order = if hub_first { ["oxygenhub", "oxygen"] } else { ["oxygen", "oxygenhub"] };
        for p in order {
            let o = run(d, &["project", "add", d.join(p).to_str().unwrap()]);
            assert!(o.status.success(), "{}", text(&o));
        }
        let list = projects(d);
        let hub = list.as_array().unwrap().iter().find(|p| p["name"] == "oxygenhub").unwrap();
        let oxy = list.as_array().unwrap().iter().find(|p| p["name"] == "oxygen").unwrap();
        assert_eq!(hub["depends_on"], serde_json::json!(["oxygen"]), "hub first: {hub_first}");
        assert_eq!(oxy["depended_on_by"], serde_json::json!(["oxygenhub"]));
        assert!(run(d, &["admin", "check"]).status.success());
        assert!(run(d, &["admin", "verify"]).status.success());
    }
}

#[test]
fn a_project_is_registered_once_and_an_agent_needs_one() {
    let dir = setup();
    let d = dir.path();
    checkout(&d.join("oxygen"), "https://hub.example/andy/oxygen", &[]);
    assert!(run(d, &["project", "add", d.join("oxygen").to_str().unwrap()]).status.success());
    let again = run(d, &["project", "add", d.join("oxygen").to_str().unwrap(), "--name", "other"]);
    assert!(!again.status.success() && text(&again).contains("already a project"), "{}", text(&again));
    let o = run(
        d,
        &["agent", "add", "kimi", "--kind", "kimi-code", "--project", "nowhere", "--home", d.join("kimi").to_str().unwrap(), "--wait", "0"],
    );
    assert!(!o.status.success() && text(&o).contains("no project named nowhere"), "{}", text(&o));
    assert!(!d.join("kimi").exists(), "no key is made for an agent that cannot be added");
}