"""Regenerate the DGR-012 concurrency-sweep evidence artifact.

Deterministic, download-free, GPU-free. Run from the repo root with the default
venv so the worktree ``meshnet_node`` package and the DGR-007 numpy reference
(``tests/test_hot_kv_state``) are importable:

    python .scratch/distributed-gguf-runtime/evidence/DGR-012/generate_evidence.py

Writes ``results.json`` beside this script.
"""

from __future__ import annotations

import json
import pathlib
import sys

_ROOT = pathlib.Path(__file__).resolve().parents[4]
sys.path.insert(0, str(_ROOT / "packages" / "node"))
sys.path.insert(0, str(_ROOT / "tests"))

from test_hot_kv_state import _KvDenseLlama, _KvReferenceShard  # noqa: E402

from meshnet_node.batch_scheduler import (  # noqa: E402
    ContinuousBatchScheduler,
    GenerationRequest,
    KvBatchEngine,
    NodeBudget,
    run_concurrency_sweep,
)
from meshnet_node.hot_kv_state import (  # noqa: E402
    HotKvStateManager,
    KvBoundaryAdapter,
    kv_recipe_for,
)

MODEL = _KvDenseLlama()


def make_engine() -> KvBatchEngine:
    shard = _KvReferenceShard(MODEL, 0, MODEL.n_layers - 1)
    manager = HotKvStateManager(kv_recipe_for(shard))
    return KvBatchEngine(KvBoundaryAdapter(shard, manager))


def main() -> int:
    prompts = {
        "s0": [1, 2, 3, 4], "s1": [5, 6, 7, 8], "s2": [9, 10, 11, 12],
        "s3": [13, 14, 15, 16], "s4": [17, 18, 19, 20], "s5": [21, 22, 23, 24],
        "s6": [25, 26, 27, 28], "s7": [29, 30, 31, 32],
    }
    n_new = 8
    requests = [
        GenerationRequest(sid, 0, tuple(p), n_new) for sid, p in prompts.items()
    ]
    sweep = run_concurrency_sweep(
        make_engine, requests, concurrency_levels=(1, 2, 4, 8)
    )

    # A representative telemetry snapshot mid-run at concurrency 4 (shows the live
    # capability signals a node advertises upward).
    engine = make_engine()
    scheduler = ContinuousBatchScheduler(
        engine,
        NodeBudget(
            max_active_sessions=4, max_batch_size=4, max_queue_depth=8,
            scratch_bytes_per_session=1, scratch_budget_bytes=4,
        ),
    )
    for request in requests:
        scheduler.submit(request)
    for _ in range(6):
        scheduler.run_tick()
    mid_run_telemetry = scheduler.telemetry().to_dict()

    artifact = {
        "schema_version": 1,
        "evidence_kind": "synthetic-unit",
        "model": {
            "reference": "pure-numpy KV-cached dense-Llama (tests/test_hot_kv_state)",
            "n_layers": MODEL.n_layers,
            "hidden": MODEL.hidden,
            "n_heads": MODEL.n_heads,
            "vocab": MODEL.vocab,
        },
        "workload": {
            "sessions": len(prompts),
            "prompt_len": 4,
            "max_new_tokens": n_new,
        },
        "concurrency_sweep": sweep.to_dict(),
        "mid_run_telemetry_concurrency_4": mid_run_telemetry,
    }

    out = pathlib.Path(__file__).with_name("results.json")
    out.write_text(json.dumps(artifact, indent=2, sort_keys=True) + "\n", encoding="utf-8")
    print(f"wrote {out}")
    print(
        "saturation_concurrency=%d corruption_free=%s"
        % (sweep.saturation_concurrency, sweep.corruption_free)
    )
    for result in sweep.results:
        print(
            "  c=%d ticks=%d avg_occ=%.3f tokens/tick=%.3f peak_kv=%dB"
            % (
                result.concurrency,
                result.ticks,
                result.avg_batch_occupancy,
                result.tokens_per_tick,
                result.peak_kv_bytes,
            )
        )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())