//! Tests of the `sausage` command line.

use std::path::PathBuf;
use std::process::{Command, Stdio};
use std::time::{SystemTime, UNIX_EPOCH};

fn empty_dir(label: &str) -> PathBuf {
    let nonce = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_nanos();
    let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .parent()
        .unwrap()
        .join("target/test-cli")
        .join(format!("{label}-{}-{nonce}", std::process::id()));
    std::fs::create_dir_all(&dir).unwrap();
    dir
}

/// Bare `sausage` (as in `nix run <flake>`) without a world starts `init`
/// for ./world instead of printing a usage error.
#[test]
fn bare_command_without_a_world_starts_init() {
    let dir = empty_dir("bare");
    let output = Command::new(env!("CARGO_BIN_EXE_sausage"))
        .current_dir(&dir)
        .env_remove("SAUSAGE_API")
        .env_remove("SAUSAGE_BASE_URL")
        .env_remove("SAUSAGE_MODEL")
        .env_remove("SAUSAGE_API_TOKEN")
        .stdin(Stdio::null())
        .output()
        .unwrap();
    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);
    // With no answers on stdin, init stops at the first required value.
    assert!(!output.status.success(), "stdout:\n{stdout}\nstderr:\n{stderr}");
    assert!(stdout.contains("No world in ./world yet"), "stdout:\n{stdout}\nstderr:\n{stderr}");
    assert!(stderr.contains("SAUSAGE_BASE_URL"), "stdout:\n{stdout}\nstderr:\n{stderr}");
    assert!(!stderr.contains("Usage:"), "stderr:\n{stderr}");
    // It asks before it creates anything.
    assert!(!dir.join("world").exists());
}

/// `--headless` never reads stdin: with stdin at EOF the world stays up, and
/// SIGTERM stops it cleanly (exit code 0).
#[test]
fn headless_ignores_stdin_eof_and_stops_cleanly_on_sigterm() {
    use std::io::{BufRead, BufReader};
    let dir = empty_dir("headless");
    let world = dir.join("world");
    sausage::World::create(&world).unwrap();
    let mut child = Command::new(env!("CARGO_BIN_EXE_sausage"))
        .args(["run", "--headless"])
        .arg(&world)
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::null())
        .spawn()
        .unwrap();
    let mut lines = BufReader::new(child.stdout.take().unwrap()).lines();
    // The host prints this once it runs and the signal handlers are installed.
    let line = lines.next().expect("host exited before it started").unwrap();
    assert!(line.contains("headless"), "unexpected first line: {line}");
    // The host reaches EOF on stdin immediately; it must still be running.
    std::thread::sleep(std::time::Duration::from_millis(500));
    assert!(child.try_wait().unwrap().is_none(), "headless host exited on stdin EOF");
    let pid = child.id().to_string();
    assert!(Command::new("kill").args(["-TERM", &pid]).status().unwrap().success());
    let rest: Vec<String> = lines.map(|l| l.unwrap()).collect();
    let status = child.wait().unwrap();
    assert!(status.success(), "exit status {status:?}, output {rest:?}");
    assert!(rest.iter().any(|l| l.contains("Stopping actors")), "output {rest:?}");
}