// test_swarm.el — end-to-end proof of the swarm capability on native El threads.
//
// Proves: native-thread fan-out/converge, bounded concurrency, per-worker CCR
// bounded context (with the security-boundary property), containment Rule 2
// enforcement, and durable work-tracking.

fn assert_true(label: String, cond: Bool, fails: Int) -> Int {
    if cond {
        print("  ok   " + label)
        return fails
    }
    print("  FAIL " + label)
    return fails + 1
}

fn main() -> Int {
    let fails = 0

    // ── 1) fan-out / converge (collect) over native threads ──
    let inputs: String = "[\"alpha\",\"bravo\",\"charlie\",\"delta\",\"echo\"]"
    let refs: String = "[]"
    let cfg: String = "{\"concurrency\":\"2\",\"strategy\":\"collect\",\"min_success_ratio\":\"1.0\"}"
    let res: String = swarm_run("analyze_item", refs, inputs, cfg)
    let status: String = json_get_string(res, "status")
    let fails = assert_true("swarm completed", str_eq(status, "completed"), fails)

    let merged: String = json_get_raw(res, "merged")
    let count: Int = json_array_len(merged)
    let fails = assert_true("collect returned 5 results (bounded concurrency=2)", count == 5, fails)

    // ── 2) work-tracking is durable + complete ──
    let corr: String = json_get_string(res, "corr_id")
    let started: Int = worktrack_count_kind(corr, "worker.started")
    let completed: Int = worktrack_count_kind(corr, "worker.completed")
    let created: Int = worktrack_count_kind(corr, "swarm.created")
    let done: Int = worktrack_count_kind(corr, "swarm.completed")
    let fails = assert_true("tracked 5 worker.started", started == 5, fails)
    let fails = assert_true("tracked 5 worker.completed", completed == 5, fails)
    let fails = assert_true("tracked swarm.created + swarm.completed", (created == 1) && (done == 1), fails)

    // ── 3) CCR: bounded, minimal, non-leaking per-worker context ──
    let wtoken: String = containment_worker_token(corr, corr + "/worker-0")
    let ctx: String = ccr_compile("analyze_item", refs, "alpha", corr, corr + "/worker-0", wtoken)
    let in_budget: Bool = ccr_within_budget(ctx)
    let fails = assert_true("CCR context within token budget", in_budget, fails)
    let this_input: String = json_get_string(ctx, "input")
    let fails = assert_true("CCR context contains THIS worker's input", str_eq(this_input, "alpha"), fails)
    // security boundary: a worker's compiled context must not carry a sibling input
    let leaks_sibling: Bool = str_contains(ctx, "charlie")
    let fails = assert_true("CCR context does NOT leak sibling inputs", !leaks_sibling, fails)

    // ── 4) containment Rule 2: a worker may not open a swarm ──
    let worker_caller_cfg: String = json_set(cfg, "caller_token", wtoken)
    let denied: String = swarm_run("analyze_item", refs, inputs, worker_caller_cfg)
    let dstatus: String = json_get_string(denied, "status")
    let fails = assert_true("worker-token caller denied opening a swarm (Rule 2)", str_eq(dstatus, "denied"), fails)

    // coordinator token IS allowed
    let coord: String = containment_coordinator_token("some-corr")
    let allow_reason: String = containment_check_open(coord)
    let fails = assert_true("coordinator token allowed to open a swarm", str_eq(allow_reason, ""), fails)

    // ── 5) containment Rule 3: no lateral worker->worker edge ──
    let lateral: String = containment_check_lateral(wtoken, "some-sibling")
    let fails = assert_true("lateral worker->worker edge rejected (Rule 3)", !str_eq(lateral, ""), fails)
    let vertical: String = containment_check_lateral(wtoken, "")
    let fails = assert_true("vertical worker->coordinator edge allowed", str_eq(vertical, ""), fails)

    if fails == 0 {
        print("PASS test_swarm")
        return 0
    }
    print("FAIL test_swarm (" + int_to_str(fails) + " failures)")
    return 1
}