//! Every `--json` output of the CLI parses as JSON and carries the fields

//! the VS Code extension relies on (oxygen-vscode/docs/spec.md section 4).

use serde_json::Value;

use std::path::Path;

use std::process::Command;

fn oxy(dir: &Path, home: &Path, args: &[&str]) -> (i32, Vec<u8>, String) {

    let out = Command::new(env!("CARGO_BIN_EXE_oxy"))

        .arg("--plain")

        .args(args)

        .current_dir(dir)

        .env("OXY_HOME", home)

        .env("NO_COLOR", "1")

        .output()

        .unwrap();

    (

        out.status.code().unwrap_or(-1),

        out.stdout,

        String::from_utf8_lossy(&out.stderr).to_string(),

    )

}

fn json(dir: &Path, home: &Path, args: &[&str]) -> Value {

    let (code, out, err) = oxy(dir, home, args);

    assert!(

        code == 0 || code == 2 || code == 1,

        "oxy {args:?} exited {code}: {err}"

    );

    serde_json::from_slice(&out).unwrap_or_else(|e| {

        panic!(

            "oxy {args:?} is not JSON: {e}\n{}",

            String::from_utf8_lossy(&out)

        )

    })

}

fn write(dir: &Path, rel: &str, content: &str) {

    let p = dir.join(rel);

    std::fs::create_dir_all(p.parent().unwrap()).unwrap();

    std::fs::write(p, content).unwrap();

}

#[test]

fn machine_interface_round_trips() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let origin = tmp.path().join("origin");

    assert_eq!(

        oxy(tmp.path(), &home, &["init", origin.to_str().unwrap()]).0,

        0

    );

    let repo = tmp.path().join("repo");

    assert_eq!(

        oxy(

            tmp.path(),

            &home,

            &["clone", origin.to_str().unwrap(), repo.to_str().unwrap()]

        )

        .0,

        0

    );

    let r = repo.as_path();

    assert_eq!(

        oxy(

            r,

            &home,

            &[

                "identity",

                "create",

                "--name",

                "Ada",

                "--email",

                "[email protected]"

            ]

        )

        .0,

        0

    );

    assert_eq!(

        oxy(r, &home, &["config", "--user", "core.sign", "change"]).0,

        0

    );

    let v = json(r, &home, &["version", "--json"]);

    assert_eq!(v["protocol"], 1);

    let root = json(r, &home, &["root", "--json"]);

    assert_eq!(root["bookmark"], "main");

    assert!(root["root"].as_str().unwrap().ends_with("repo"));

    write(r, "a.txt", "1\n2\n3\n");

    write(r, "b.txt", "b\n");

    let st = json(r, &home, &["status", "--json"]);

    assert_eq!(st["paths"].as_array().unwrap().len(), 2);

    assert_eq!(oxy(r, &home, &["commit", "-m", "base"]).0, 0);

    write(r, "a.txt", "0\n1\n2\n3\n");

    write(r, "b.txt", "b\nbb\n");

    write(r, "c.txt", "c\n");

    // diff and hunks agree on the working copy.

    let d = json(r, &home, &["diff", "--json"]);

    let files = d["files"].as_array().unwrap();

    assert_eq!(files.len(), 3, "{d}");

    let a = files.iter().find(|f| f["path"] == "a.txt").unwrap();

    assert_eq!(a["kind"], "modified");

    assert_eq!(a["hunks"][0]["base_line"], 0);

    assert_eq!(a["hunks"][0]["added"][0], "0\n");

    let c = files.iter().find(|f| f["path"] == "c.txt").unwrap();

    assert_eq!(c["kind"], "added");

    let hunks = json(r, &home, &["hunks", "--json"]);

    let hunks = hunks.as_array().unwrap();

    assert!(hunks.len() >= 3, "{hunks:?}");

    let b_hunk = hunks.iter().find(|h| h["path"] == "b.txt").unwrap()["index"]

        .as_u64()

        .unwrap();

    // Commit only b's hunk; discard c by path; then discard a's remaining hunk.

    assert_eq!(

        oxy(

            r,

            &home,

            &["commit", "-m", "b only", "--hunks", &b_hunk.to_string()]

        )

        .0,

        0

    );

    assert_eq!(oxy(r, &home, &["discard", "c.txt"]).0, 0);

    assert!(!r.join("c.txt").exists());

    let hunks = json(r, &home, &["hunks", "--json"]);

    let a_hunk = hunks

        .as_array()

        .unwrap()

        .iter()

        .find(|h| h["path"] == "a.txt")

        .unwrap()["index"]

        .as_u64()

        .unwrap();

    assert_eq!(

        oxy(r, &home, &["discard", "--hunks", &a_hunk.to_string()]).0,

        0

    );

    assert_eq!(

        std::fs::read_to_string(r.join("a.txt")).unwrap(),

        "1\n2\n3\n"

    );

    let st = json(r, &home, &["status", "--json"]);

    assert_eq!(st["clean"], true, "{st}");

    // cat serves file content at states.

    let (code, out, _) = oxy(r, &home, &["cat", "b.txt"]);

    assert_eq!((code, out.as_slice()), (0, b"b\nbb\n".as_slice()));

    let (code, out, _) = oxy(r, &home, &["cat", "b.txt", "-r", "main"]);

    assert_eq!((code, out.as_slice()), (0, b"b\nbb\n".as_slice()));

    // log, show, verify, op log, bookmarks, remotes, sync.

    let log = json(r, &home, &["log", "--json"]);

    let changes = log["changes"].as_array().unwrap();

    assert_eq!(changes.len(), 3, "working copy plus two changes: {log}");

    let head = changes.iter().find(|c| c["message"] == "b only").unwrap();

    assert_eq!(head["signature"]["status"], "signed");

    assert_eq!(head["author"], "Ada");

    let hash = head["hash"].as_str().unwrap().to_string();

    let by_path = json(r, &home, &["log", "--json", "--path", "b.txt"]);

    assert_eq!(by_path["changes"].as_array().unwrap().len(), 2, "{by_path}");

    let show = json(r, &home, &["show", "--json", &format!("#{}", &hash[..12])]);

    assert_eq!(show["files"][0]["path"], "b.txt");

    let verify = json(r, &home, &["verify", "--json"]);

    assert!(verify

        .as_array()

        .unwrap()

        .iter()

        .all(|v| v["status"] == "signed"));

    let ops = json(r, &home, &["op", "log", "--json"]);

    assert!(ops[0]["current"] == true && ops.as_array().unwrap().len() > 3);

    assert_eq!(oxy(r, &home, &["bookmark", "create", "feature"]).0, 0);

    let bms = json(r, &home, &["bookmark", "list", "--json"]);

    assert_eq!(

        bms.as_array()

            .unwrap()

            .iter()

            .map(|b| b["name"].as_str().unwrap())

            .collect::<Vec<_>>(),

        vec!["feature", "main"]

    );

    let remotes = json(r, &home, &["remote", "list", "--json"]);

    assert_eq!(remotes[0]["name"], "origin");

    let push = json(r, &home, &["push", "--json"]);

    assert_eq!(push[0]["ok"], true, "{push}");

    let state = push[0]["state"].as_str().unwrap();

    assert!(

        state.len() == 64 && state.chars().all(|c| c.is_ascii_hexdigit()),

        "the state the push moved the bookmark to: {push}"

    );

    let fetch = json(r, &home, &["fetch", "--json"]);

    assert_eq!(fetch["remote"], "origin");

    let pull = json(r, &home, &["pull", "--json"]);

    assert_eq!(pull["changed"], false);

    assert_eq!(json(r, &home, &["resolve", "--json"])["conflicted"], false);

    assert!(json(r, &home, &["submodule", "status", "--json"])

        .as_array()

        .unwrap()

        .is_empty());

    assert!(json(r, &home, &["bisect", "status", "--json"]).is_null());

    assert!(json(r, &home, &["policy", "show", "--json"]).is_null());

    assert_eq!(oxy(r, &home, &["policy", "init"]).0, 0);

    let policy = json(r, &home, &["policy", "show", "--json"]);

    assert_eq!(policy["roots"][0]["name"], "Ada");

    assert_eq!(

        oxy(r, &home, &["tag", "create", "v1", "-m", "first tag"]).0,

        0

    );

    let tags = json(r, &home, &["tag", "list", "--json"]);

    assert_eq!(

        (tags[0]["name"].as_str(), tags[0]["message"].as_str()),

        (Some("v1"), Some("first tag"))

    );

    let ws = json(r, &home, &["workspace", "list", "--json"]);

    assert_eq!(

        (ws.as_array().unwrap().len(), ws[0]["current"].as_bool()),

        (1, Some(true))

    );

}

/// `oxy commit -F`, `oxy describe` naming and tags as changes (feedback

/// 4 and 6).

#[test]

fn commit_from_a_file_and_describe_for_builds() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let dir = tmp.path().join("r");

    std::fs::create_dir_all(&dir).unwrap();

    assert_eq!(oxy(&dir, &home, &["init"]).0, 0);

    write(&dir, "a.txt", "a\n");

    write(

        tmp.path(),

        "msg.txt",

        "Subject from a file\n\nA body\nof two lines.\n",

    );

    let msg = tmp.path().join("msg.txt");

    let (code, _, err) = oxy(&dir, &home, &["commit", "-F", msg.to_str().unwrap()]);

    assert_eq!(code, 0, "{err}");

    let log = json(&dir, &home, &["log", "--json", "-n", "2"]);

    assert_eq!(

        log["changes"][1]["message"],

        "Subject from a file\n\nA body\nof two lines."

    );

    assert_ne!(oxy(&dir, &home, &["commit"]).0, 0, "a message is required");

    // Untagged: bookmark and change; a tag names it; later work counts.

    let d = json(&dir, &home, &["describe", "--json"]);

    assert_eq!(

        (d["tag"].clone(), d["dirty"].clone()),

        (Value::Null, Value::Bool(false))

    );

    let change = d["change"].as_str().unwrap().to_string();

    assert_eq!(d["describe"], format!("main-{}", &change[..8]));

    assert_eq!(

        oxy(&dir, &home, &["tag", "create", "v0.1.0", "-m", "first"]).0,

        0

    );

    let (_, out, _) = oxy(&dir, &home, &["describe"]);

    assert_eq!(String::from_utf8_lossy(&out).trim(), "v0.1.0");

    let (code, out, err) = oxy(&dir, &home, &["show", "v0.1.0"]);

    assert_eq!(code, 0, "a tag names its change: {err}");

    assert!(String::from_utf8_lossy(&out).contains("Subject from a file"));

    write(&dir, "b.txt", "b\n");

    let d = json(&dir, &home, &["describe", "--json"]);

    assert_eq!(d["describe"], "v0.1.0-dirty");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "b"]).0, 0);

    write(&dir, "c.txt", "c\n");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "c"]).0, 0);

    let d = json(&dir, &home, &["describe", "--json"]);

    let change = d["change"].as_str().unwrap();

    assert_eq!(d["distance"], 2);

    assert_eq!(d["describe"], format!("v0.1.0-2-{}", &change[..8]));

}

/// `oxy log -L START,END:PATH`: the history of a range of lines.

#[test]

fn the_history_of_a_function() {

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let dir = tmp.path().join("r");

    std::fs::create_dir_all(&dir).unwrap();

    assert_eq!(oxy(&dir, &home, &["init"]).0, 0);

    write(&dir, "f.rs", "use x;\nfn a() {\n  one();\n}\n");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "add f"]).0, 0);

    write(&dir, "f.rs", "use y;\nfn a() {\n  one();\n}\n");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "import"]).0, 0);

    write(&dir, "f.rs", "use y;\nfn a() {\n  two();\n}\n");

    assert_eq!(oxy(&dir, &home, &["commit", "-m", "body"]).0, 0);

    let v = json(&dir, &home, &["log", "--json", "-L", "2,4:f.rs"]);

    let messages: Vec<&str> = v["changes"]

        .as_array()

        .unwrap()

        .iter()

        .map(|c| c["message"].as_str().unwrap())

        .collect();

    assert_eq!(messages, ["body", "add f"], "not the import");

    let (code, _, err) = oxy(&dir, &home, &["log", "-L", "2:f.rs"]);

    assert_ne!(code, 0);

    assert!(err.contains("START,END:PATH"), "{err}");

}

#[test]

fn receipts_verify_import_list_show_and_export() {

    use oxy_core::hash::{ObjectRef, ObjectType};

    use oxy_core::identity::SecretKey;

    use oxy_core::objects::StateObject;

    use oxy_core::receipt::{Receipt, SignedReceipt};

    let tmp = tempfile::tempdir().unwrap();

    let home = tmp.path().join("home");

    std::fs::create_dir_all(&home).unwrap();

    let r = tmp.path().join("repo");

    assert_eq!(oxy(tmp.path(), &home, &["init", r.to_str().unwrap()]).0, 0);

    write(&r, "a.txt", "a\n");

    assert_eq!(oxy(&r, &home, &["commit", "-m", "A"]).0, 0);

    let repo = oxy_core::repo::Repo::open(&r).unwrap();

    let heads = repo.bookmark_heads().unwrap();

    let state = oxy_core::hash::hash_object(ObjectType::State, &StateObject::new(heads).encode());

    let receipt = Receipt {

        job_name: "test".into(),

        pipeline_hash: ObjectRef([1; 32]),

        scope_tree_hash: ObjectRef([2; 32]),

        inputs: vec![],

        environment: ObjectRef([3; 32]),

        outputs: vec![],

        exit_code: 0,

        duration_ms: 2500,

    };

    let sk = SecretKey::generate();

    let runner = sk.identity("earth-1", "runner@earth", 1);

    let sr = SignedReceipt::sign(receipt, repo.id().unwrap(), state, "demo#7", &runner, &sk);

    let file = tmp.path().join("r.receipt");

    std::fs::write(&file, sr.encode()).unwrap();

    let f = file.to_str().unwrap();

    let v = json(&r, &home, &["receipt", "verify", f, "--json"]);

    assert_eq!(

        (v["valid"].as_bool(), v["job"].as_str(), v["run"].as_str()),

        (Some(true), Some("test"), Some("demo#7"))

    );

    assert!(v["attest"].is_null());

    assert!(json(&r, &home, &["receipt", "list", "--json"])

        .as_array()

        .unwrap()

        .is_empty());

    assert_eq!(oxy(&r, &home, &["receipt", "import", f]).0, 0);

    let list = json(&r, &home, &["receipt", "list", "--json"]);

    let list = list.as_array().unwrap();

    assert_eq!(list.len(), 1);

    assert_eq!(list[0]["runner_name"], "earth-1");

    assert_eq!(list[0]["state"], state.to_hex());

    let attest = list[0]["attest"].as_str().unwrap().to_string();

    let shown = json(&r, &home, &["receipt", "show", &attest[..10], "--json"]);

    assert_eq!(shown["duration_ms"], 2500);

    let out = tmp.path().join("out.receipt");

    assert_eq!(

        oxy(

            &r,

            &home,

            &["receipt", "export", &attest[..10], out.to_str().unwrap()]

        )

        .0,

        0

    );

    assert_eq!(std::fs::read(&out).unwrap(), sr.encode());

    // A receipt whose result was changed after signing does not verify.

    let mut forged = sr.clone();

    forged.receipt.exit_code = 3;

    std::fs::write(&file, forged.encode()).unwrap();

    let (code, out, _) = oxy(&r, &home, &["receipt", "verify", f]);

    assert_eq!(code, 1);

    assert!(String::from_utf8_lossy(&out).contains("different receipt"));

    let (code, _, err) = oxy(&r, &home, &["receipt", "import", f]);

    assert_ne!(code, 0);

    assert!(err.contains("does not verify"), "{err}");