#!/usr/bin/env python3
"""Compare L78 exact tile hashes with the retained L76/L77-equivalent matrix."""
from __future__ import annotations

import json
import re
import subprocess
import time
from pathlib import Path


ROOT = Path(__file__).resolve().parents[4]
OUT = ROOT / "Saved/Linux/l78/hashes"
DATA = ROOT / "Standalone/data/owner_world.json"
BINARIES = {
    "clang": ROOT / "Saved/Linux/l78/bin/VoxelForgeCoreHeadless-l78-clang",
    "gcc": ROOT / "Saved/Linux/l78/bin/VoxelForgeCoreHeadless-l78-gcc",
}
CAMERAS = {
    0: (8.0, 16.0, -372.2626953125),
    1: (25.8369140625, 3.19921875, -737.0),
    2: (19.166015625, -14.2001953125, -753.3740234375),
    3: (-20.0625, -5.068359375, -900.353515625),
}
HASH = re.compile(
    r"^\[PipelineTileHash\] lod=(\d+) x=(-?\d+) y=(-?\d+) z=(-?\d+) "
    r"density=(0x[0-9a-fA-F]+) mesh=(0x[0-9a-fA-F]+) "
    r"payload=(0x[0-9a-fA-F]+) topology=(0x[0-9a-fA-F]+)$",
    re.M,
)


def read_hashes(path: Path) -> dict[tuple[int, int, int, int], tuple[str, ...]]:
    content = path.read_text(encoding="utf-8", errors="replace")
    return {
        tuple(int(match.group(i)) for i in range(1, 5)):
            tuple(value.lower() for value in match.groups()[4:])
        for match in HASH.finditer(content)
    }


def run(compiler: str, workers: int, strate: int) -> dict:
    OUT.mkdir(parents=True, exist_ok=True)
    log = OUT / compiler / f"w{workers}" / f"strate{strate}-after.log"
    log.parent.mkdir(parents=True, exist_ok=True)
    camera = ",".join(f"{value:.12f}" for value in CAMERAS[strate]) + ",0,0"
    command = [
        "taskset", "-c", "0-11", "prlimit", "--as=6442450944", "--",
        "timeout", "1740s", str(BINARIES[compiler]), str(DATA),
        "--world-assembler-prototype", "--stream-benchmark", "--stream-pipeline",
        "--force-generate", f"--workers={workers}", "--clip-radius=3",
        "--max-clip-level=8", "--max-level=8", f"--camera={camera}",
        "--stream-hash-tiles",
    ]
    started = time.monotonic()
    with log.open("w", encoding="utf-8") as output:
        result = subprocess.run(command, cwd=ROOT, stdout=output,
                                stderr=subprocess.STDOUT, check=False, timeout=1740)
    hashes = read_hashes(log)
    if result.returncode != 0 or not hashes:
        raise SystemExit(f"hash generation failed: {log}; exit={result.returncode}")
    reference = ROOT / "Saved/Linux/l76/hashes" / compiler / f"w{workers}" / f"strate{strate}-before.log"
    expected = read_hashes(reference)
    missing, extra = expected.keys() - hashes.keys(), hashes.keys() - expected.keys()
    mismatches = {name: 0 for name in ("density", "mesh", "payload", "topology")}
    examples = []
    for key in sorted(expected.keys() & hashes.keys()):
        for index, name in enumerate(mismatches):
            if expected[key][index] != hashes[key][index]:
                mismatches[name] += 1
                if len(examples) < 12:
                    examples.append({"tile": key, "field": name,
                                     "before": expected[key][index],
                                     "after": hashes[key][index]})
    row = {
        "compiler": compiler,
        "workers": workers,
        "strate": strate,
        "exit_code": result.returncode,
        "wall_s": round(time.monotonic() - started, 3),
        "expected_tiles": len(expected),
        "candidate_tiles": len(hashes),
        "missing_keys": len(missing),
        "extra_keys": len(extra),
        "mismatches": mismatches,
        "examples": examples,
        "equal": not missing and not extra and not any(mismatches.values()),
        "reference": str(reference.relative_to(ROOT)),
        "log": str(log.relative_to(ROOT)),
    }
    print("[L78HashCompare] " + json.dumps(row, sort_keys=True), flush=True)
    return row


def main() -> int:
    missing = [str(path) for path in (DATA, *BINARIES.values()) if not path.is_file()]
    if missing:
        raise SystemExit("missing input: " + ", ".join(missing))
    rows = []
    for compiler in ("clang", "gcc"):
        for workers in (1, 8, 12):
            for strate in range(4):
                row = run(compiler, workers, strate)
                rows.append(row)
                (OUT / "summary-partial.json").write_text(
                    json.dumps(rows, indent=2) + "\n", encoding="utf-8")
                if not row["equal"]:
                    raise SystemExit(f"hash mismatch; see {row['log']}")
    result = {"comparisons": rows, "equal": all(row["equal"] for row in rows)}
    (OUT / "summary.json").write_text(json.dumps(result, indent=2) + "\n",
                                      encoding="utf-8")
    return 0


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