//! World-loaded messages and lineage, including SIGKILL after reply placement.
use sausage::{harness::run_module, world::World};
use std::{
    path::Path,
    process::Command,
    time::{Duration, Instant},
};
const BUNDLE: &str = include_str!("../../js/messages-test-bundle.js");
static PREPARE: std::sync::Mutex<()> = std::sync::Mutex::new(());
fn prepare(dir: &Path) -> anyhow::Result<()> {
    let _guard = PREPARE.lock().unwrap();
    let disk = dir.join("world");
    let repo = disk.join("src/sausage");
    if repo.join(".git").exists() {
        return Ok(());
    }
    let source = Path::new(env!("CARGO_MANIFEST_DIR")).join("..");
    let target = crate::common::build_git();
    std::fs::create_dir_all(disk.join("bin"))?;
    std::fs::copy(
        target.join("wasm32-wasip2/release/git.wasm"),
        disk.join("bin/git.wasm"),
    )?;
    for directory in [
        "extensions/subagents",
        "extensions/messages",
        "extensions/lineage",
        "extensions/models",
        "extensions/core",
        "agents",
    ] {
        std::fs::create_dir_all(repo.join(directory))?;
    }
    for directory in [
        "extensions/subagents",
        "extensions/messages",
        "extensions/lineage",
        "extensions/models",
    ] {
        for entry in std::fs::read_dir(source.join(directory))? {
            let entry = entry?;
            if entry.path().extension().is_some_and(|ext| ext == "ts") {
                std::fs::copy(entry.path(), repo.join(directory).join(entry.file_name()))?;
            }
        }
    }
    std::fs::create_dir_all(repo.join("extensions/probe"))?;
    std::fs::write(
        repo.join("extensions/probe/server.ts"),
        "export default host => { globalThis.testHost = host; globalThis.subagentService = host.need({name:'subagents'}); globalThis.messageService = host.need({name:'messages'}); globalThis.lineageService = host.need({name:'lineage'}); host.implement({name:'conversations'}, {summaryModel: async () => globalThis.summaryRef, concludedIn: async () => new Set(), generatedTitle: async () => {}, setStanding: async () => {}, setAutomaticSummaries: async () => {}}); return {name:'probe'}; }",
    )?;
    std::fs::copy(
        source.join("extensions/core/agents.ts"),
        repo.join("extensions/core/agents.ts"),
    )?;
    std::fs::write(
        repo.join("agents/models.json"),
        r#"{"default":{"model":"faux/faux-1"}}"#,
    )?;
    std::fs::write(
        repo.join("agents/scout.md"),
        "---\nname: scout\ndescription: Search\nresident: true\ndenyTools: [subagent]\nisolate: none\n---\nScout instructions\n",
    )?;
    std::fs::write(
        repo.join("agents/ultimate.md"),
        "---\nname: ultimate\ndescription: Primary\nresident: true\nisolate: none\n---\nPrimary agent\n",
    )?;
    std::fs::write(
        repo.join("agents/coordinator.md"),
        "---\nname: coordinator\ndescription: Coordinate\nisolate: none\n---\nCoordinator agent\n",
    )?;
    for args in [
        vec!["init", "-b", "main"],
        vec!["add", "."],
        vec!["commit", "--no-gpg-sign", "-m", "messages fixture"],
    ] {
        assert!(
            Command::new("git")
                .args(args)
                .current_dir(&repo)
                .env("GIT_AUTHOR_NAME", "Test")
                .env("GIT_AUTHOR_EMAIL", "test@example.com")
                .env("GIT_COMMITTER_NAME", "Test")
                .env("GIT_COMMITTER_EMAIL", "test@example.com")
                .status()?
                .success()
        );
    }
    Ok(())
}
async fn run(dir: &Path, mode: &str) -> anyhow::Result<()> {
    let world = World::open(dir)?;
    prepare(dir)?;
    let exec = sausage::process::exec(World {
        root: world.root.clone(),
        host_dir: world.host_dir.clone(),
        processes: world.processes.clone(),
    })?;
    run_module(
        world,
        exec,
        &format!("globalThis.messagesMode={mode:?};\n{BUNDLE}"),
    )
    .await
}
#[tokio::test(flavor = "current_thread")]
async fn coordination() -> anyhow::Result<()> {
    let dir = tempfile::tempdir()?;
    run(dir.path(), "normal").await
}
#[tokio::test(flavor = "current_thread")]
async fn restart_child() -> anyhow::Result<()> {
    if let Ok(dir) = std::env::var("MESSAGES_DIR") {
        run(Path::new(&dir), &std::env::var("MESSAGES_MODE")?).await?;
    }
    Ok(())
}
#[test]
fn sigkill_after_reply_placement() -> anyhow::Result<()> {
    let dir = tempfile::tempdir()?;
    World::open(dir.path())?;
    prepare(dir.path())?;
    let spawn = |mode: &str| {
        Command::new(std::env::current_exe().unwrap())
            .args(["--exact", "messages::restart_child", "--nocapture"])
            .env("MESSAGES_DIR", dir.path())
            .env("MESSAGES_MODE", mode)
            .spawn()
    };
    let mut child = spawn("kill")?;
    let deadline = Instant::now() + Duration::from_secs(30);
    while !dir.path().join("world/report-ready").exists() {
        if let Some(status) = child.try_wait()? {
            anyhow::bail!("Child exited before reply: {status}");
        }
        if Instant::now() > deadline {
            child.kill()?;
            child.wait()?;
            anyhow::bail!("Delivery did not reach reply");
        }
        std::thread::yield_now();
    }
    child.kill()?;
    child.wait()?;
    for _ in 0..2 {
        let mut child = spawn("resume")?;
        let deadline = Instant::now() + Duration::from_secs(30);
        loop {
            if let Some(status) = child.try_wait()? {
                assert!(status.success());
                break;
            }
            if Instant::now() > deadline {
                child.kill()?;
                child.wait()?;
                anyhow::bail!("Reply recovery timed out");
            }
            std::thread::yield_now();
        }
    }
    Ok(())
}