//! `spectra admin verify|check|rebuild` against a real ledger, run as the

//! built binary in a hermetic environment: a temporary data directory and

//! `SPECTRA_HOME`, never the user's own.

use spectra_core::event::NewEvent;

use spectra_core::keys::KeyPair;

use spectra_core::ledger::Ledger;

use std::path::Path;

use std::process::Command;

/// The binary with every directory it might read pointed at `dir`.

fn hermetic(dir: &Path) -> Command {

    let mut c = Command::new(env!("CARGO_BIN_EXE_spectra"));

    c.env("SPECTRA_DATA", dir.join("data"))

        .env("SPECTRA_HOME", dir.join("owner-home"))

        .env("HOME", dir)

        .env("XDG_DATA_HOME", dir.join("xdg"))

        .env("NO_COLOR", "1");

    c

}

async fn ledger_with_events(data: &Path, n: usize) {

    std::fs::create_dir_all(data).unwrap();

    let instance = KeyPair::instance(data, "test").unwrap();

    let ledger = Ledger::open(&data.join("spectra.db"), Some(instance.clone())).await.unwrap();

    // As `spectra init` records it: signed by the instance key.

    ledger

        .append_one(spectra_core::principals::signed_event(

            &instance,

            "system",

            "identity.instance",

            spectra_core::principals::identity_payload(&instance.identity),

        ))

        .await

        .unwrap();

    for i in 0..n {

        ledger.append_one(NewEvent::system("test.message", serde_json::json!({ "n": i }))).await.unwrap();

    }

    ledger.checkpoint().await.unwrap();

}

#[tokio::test]

async fn verify_check_and_rebuild_on_a_clean_and_a_tampered_ledger() {

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

    let data = dir.path().join("data");

    ledger_with_events(&data, 40).await;

    let out = hermetic(dir.path()).args(["admin", "verify", "--json"]).output().unwrap();

    assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));

    let v: serde_json::Value = serde_json::from_slice(&out.stdout).expect("one JSON document on stdout");

    assert_eq!(v["events"], 42);

    assert_eq!(v["findings"].as_array().unwrap().len(), 0);

    assert_eq!(v["uncovered"], 0);

    assert!(hermetic(dir.path()).args(["admin", "check"]).status().unwrap().success());

    assert!(hermetic(dir.path()).args(["admin", "rebuild"]).status().unwrap().success());

    let pool = sqlx::SqlitePool::connect(&format!("sqlite://{}", data.join("spectra.db").display())).await.unwrap();

    sqlx::query("UPDATE events SET actor = 'agent:mallory' WHERE seq = 10").execute(&pool).await.unwrap();

    pool.close().await;

    let out = hermetic(dir.path()).args(["admin", "verify"]).output().unwrap();

    assert_eq!(out.status.code(), Some(1));

    let text = String::from_utf8_lossy(&out.stdout);

    assert!(text.contains("does not verify") && text.contains("#10") && text.contains("HashMismatch"), "{text}");

}

#[test]

fn a_missing_data_directory_says_what_to_do() {

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

    let out = hermetic(dir.path()).args(["admin", "verify"]).output().unwrap();

    assert_eq!(out.status.code(), Some(1));

    assert!(String::from_utf8_lossy(&out.stderr).contains("spectra init"));

}