use super::*;

fn count(binary: &Path) -> i64 {
    let result = execute(binary, "demo.account.job_count", "{}");
    assert!(
        result.status.success(),
        "{}",
        String::from_utf8_lossy(&result.stderr)
    );
    serde_json::from_slice::<serde_json::Value>(&result.stdout).unwrap()["data"]
        .as_i64()
        .unwrap()
}

fn submit(port: u16, bearer: &str, subject: &str) {
    let (status, body) = request(
        port,
        "POST",
        "/demo/account/admin/jobs/job_submit",
        "fixture.test",
        &format!("{bearer}Content-Type: application/json\r\n"),
        &serde_json::json!({"subject":subject,"key":subject}).to_string(),
    );
    assert_eq!(status, 200, "{body}");
}

fn worker(binary: &Path, settings: &serde_json::Value) -> Server {
    let path = binary.parent().unwrap().join("worker.json");
    let mut settings = settings.clone();
    settings["runtime"] = serde_json::json!({"mode":"worker","shutdown_ms":1000});
    settings["job"] = serde_json::json!({"workers":1,"poll_ms":10,"lease_ms":2000});
    std::fs::write(&path, settings.to_string()).unwrap();
    Server(
        Command::new(binary)
            .args(["--config"])
            .arg(path)
            .spawn()
            .unwrap(),
    )
}

fn until(binary: &Path, server: &mut Server, expected: i64) {
    let deadline = Instant::now() + Duration::from_secs(10);
    while count(binary) != expected {
        assert!(server.0.try_wait().unwrap().is_none(), "worker exited");
        assert!(Instant::now() < deadline, "Job result not committed");
        std::thread::sleep(Duration::from_millis(10));
    }
}

pub(super) fn before_revocation(
    binary: &Path,
    port: u16,
    bearer: &str,
    settings: &serde_json::Value,
) -> i64 {
    let before = count(binary);
    submit(port, bearer, "job-valid");
    let mut server = worker(binary, settings);
    until(binary, &mut server, before + 1);
    assert!(
        Command::new("sh")
            .args(["-c", "kill -TERM \"$1\"", "--", &server.0.id().to_string()])
            .status()
            .unwrap()
            .success()
    );
    assert!(server.0.wait().unwrap().success());
    submit(port, bearer, "job-revoked");
    before + 1
}

pub(super) fn after_revocation(binary: &Path, settings: &serde_json::Value, before: i64) {
    let submitted = execute(
        binary,
        "demo.account.job_submit",
        r#"{"subject":"job-system","key":"system"}"#,
    );
    assert!(submitted.status.success());
    let mut server = worker(binary, settings);
    until(binary, &mut server, before + 1);
    std::thread::sleep(Duration::from_millis(60));
    assert_eq!(count(binary), before + 1, "revoked User job executed");
}