#!/usr/bin/env python3
"""Compare owner four-strata hashes at W1/W8/W12 with both compilers."""
import json
import re
import subprocess
from pathlib import Path


ROOT = Path(__file__).resolve().parents[4]
OUT = ROOT / "Saved/Linux/l68"
DATA = ROOT / "Standalone/data/owner_world.json"
LAYOUT = OUT / "layouts/final-clang-owner.json"
BINARIES = {
    "clang": OUT / "bin-final-clang/VoxelForgeCoreHeadless-l68-final-clang",
    "gcc": OUT / "bin-final-gcc/VoxelForgeCoreHeadless-l68-final-gcc",
}
HASH_RE = re.compile(r"^\[Pipeline(?:FullDetailHash|WholeViewHash|LODHash|ExactQueryHash)\].*$", re.M)
RESULTS = []


def hashes(path):
    return HASH_RE.findall(path.read_text(encoding="utf-8", errors="replace"))


def cameras_by_strate():
    layout = json.loads(LAYOUT.read_text(encoding="utf-8"))
    scale = float(layout["core_voxel_size_um"]) / 256_000_000.0
    cameras = {}
    for passage in layout["passages"]:
        upper = str(int(passage["upper_strate_index"]))
        lower = str(int(passage["lower_strate_index"]))
        cameras.setdefault(upper, tuple(float(v) * scale for v in passage["upper_mouth_q"]))
        cameras[lower] = tuple(float(v) * scale for v in passage["lower_mouth_q"])
    if set(cameras) != {"0", "1", "2", "3"}:
        raise RuntimeError(f"expected a camera for all four strata; found {sorted(cameras)}")
    return cameras


def main():
    (OUT / "verify").mkdir(parents=True, exist_ok=True)
    logs = OUT / "logs/determinism"
    layouts = OUT / "layouts/determinism"
    logs.mkdir(parents=True, exist_ok=True)
    layouts.mkdir(parents=True, exist_ok=True)
    cameras = cameras_by_strate()
    for compiler, binary in BINARIES.items():
        for strate in range(4):
            camera = ",".join(f"{value:.6f}" for value in (*cameras[str(strate)], 0.0, 0.0))
            outputs = {}
            codes = {}
            for workers in (1, 8, 12):
                name = f"owner-new-plan-{compiler}-strate{strate}-w{workers}"
                log_path = logs / f"{name}.log"
                layout_path = layouts / f"{name}.json"
                command = [
                    "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
                    "timeout", "1740s", str(binary), str(DATA), f"--workers={workers}",
                    "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
                    "--force-generate", "--clip-radius=1", "--max-clip-level=8",
                    "--max-level=0", "--recipe=surface-world", "--stream-hash",
                    "--max-clip-level=0", "--render-distance-chunks=0", f"--camera={camera}",
                    f"--resolved-layout-output={layout_path}",
                ]
                with log_path.open("w", encoding="utf-8") as stream:
                    result = subprocess.run(command, cwd=ROOT, stdout=stream,
                        stderr=subprocess.STDOUT, timeout=1740, check=False)
                outputs[workers] = hashes(log_path)
                codes[workers] = result.returncode
                print(json.dumps({"compiler": compiler, "strate": strate,
                    "workers": workers, "exit_code": result.returncode,
                    "hash_rows": len(outputs[workers]), "log": str(log_path.relative_to(ROOT))},
                    sort_keys=True), flush=True)
                if result.returncode != 0 or len(outputs[workers]) != 12:
                    break
            passed = (set(codes) == {1, 8, 12} and all(code == 0 for code in codes.values())
                and outputs[1] == outputs[8] == outputs[12])
            RESULTS.append({"compiler": compiler, "strate": strate,
                "workers": {str(k): len(v) for k, v in outputs.items()},
                "exit_codes": {str(k): v for k, v in codes.items()},
                "w1_w8_w12_equal": passed})
            if not passed:
                break
        if RESULTS[-1]["compiler"] != compiler or not RESULTS[-1]["w1_w8_w12_equal"]:
            break
    passed = len(RESULTS) == 8 and all(row["w1_w8_w12_equal"] for row in RESULTS)
    summary = {"status": "PASS" if passed else "FAIL", "strata": RESULTS}
    (OUT / "verify/owner-w1-w8-w12-determinism.json").write_text(
        json.dumps(summary, indent=2) + "\n", encoding="utf-8")
    print(f"[L68OwnerW1W8W12] status={summary['status']} rows={len(RESULTS)}", flush=True)
    return 0 if passed else 1


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