from __future__ import annotations

import argparse
import hashlib
import json
import os
import time
from concurrent.futures import ProcessPoolExecutor
from pathlib import Path

import numpy as np

from hutace_benchmark.config import EnvConfig
from hutace_benchmark.datasets import ManifestTerrainDataset
from hutace_benchmark.evaluation import fixed_specs, run_episode
from hutace_benchmark.heuristics import MAIN_HEURISTICS, full_map_greedy_oracle_diagnostic


ROOT = Path(__file__).resolve().parents[1]
MANIFEST = ROOT / "artifacts" / "phase10" / "final" / "selected_manifest.jsonl"
OUTPUT = ROOT / "artifacts" / "phase13" / "heuristics"
REPORT = ROOT / "reports" / "phase13_heuristic_test.json"
_DATASET = None
_CONTROLLER = None
_CFG = None


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest().upper()


def init_worker(method: str) -> None:
    global _DATASET, _CONTROLLER, _CFG
    _DATASET = ManifestTerrainDataset(MANIFEST, root=ROOT, cache_size=8)
    _CONTROLLER = (
        full_map_greedy_oracle_diagnostic
        if method == "full_map_greedy_oracle_diagnostic"
        else MAIN_HEURISTICS[method]
    )
    _CFG = EnvConfig()


def evaluate_spec(index_and_spec):
    index, spec = index_and_spec
    row, curve, _ = run_episode(
        _DATASET, spec, _CONTROLLER, _CFG, allow_test=True
    )
    return index, row, curve


def write_jsonl(path: Path, rows: list[dict]) -> None:
    path.write_text(
        "".join(json.dumps(row, sort_keys=True) + "\n" for row in rows),
        encoding="utf-8",
    )


def summarize(rows: list[dict]) -> dict:
    return {
        "episodes": len(rows),
        "final_coverage": float(np.mean([row["coverage"] for row in rows])),
        "coverage_energy_auc": float(np.mean([row["coverage_auc"] for row in rows])),
        "coverage_at_320": float(np.mean([row["coverage_at_320"] for row in rows])),
        "revisit_ratio": float(np.mean([row["revisit_ratio"] for row in rows])),
        "reach_rate_0_50": float(np.mean([row["reached_0_50"] for row in rows])),
        "energy_to_0_50_censored": float(np.mean([row["energy_to_0_50"] for row in rows])),
        "distance_m": float(np.mean([row["distance_m"] for row in rows])),
        "decisions": float(np.mean([row["decisions"] for row in rows])),
    }


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--episodes", type=int, default=256)
    parser.add_argument("--workers", type=int, default=min(8, os.cpu_count() or 1))
    args = parser.parse_args()
    OUTPUT.mkdir(parents=True, exist_ok=True)
    REPORT.parent.mkdir(parents=True, exist_ok=True)
    dataset = ManifestTerrainDataset(MANIFEST, root=ROOT)
    specs = fixed_specs(dataset, "test", args.episodes, 230524)
    methods = list(MAIN_HEURISTICS) + ["full_map_greedy_oracle_diagnostic"]
    report = {
        "schema_version": 1,
        "phase": 13,
        "status": "running",
        "test_episodes": args.episodes,
        "fixed_spec_seed": 230524,
        "workers": args.workers,
        "test_accessed": True,
        "protocol": {
            "fair_baselines_use_partial_observation_only": True,
            "oracle_excluded_from_primary_comparison": True,
        },
        "methods": {},
    }
    REPORT.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    for method in methods:
        started = time.perf_counter()
        results = []
        with ProcessPoolExecutor(
            max_workers=args.workers, initializer=init_worker, initargs=(method,)
        ) as pool:
            for count, result in enumerate(
                pool.map(evaluate_spec, enumerate(specs), chunksize=1), 1
            ):
                results.append(result)
                if count % 16 == 0 or count == len(specs):
                    print(
                        f"PHASE13_HEURISTIC_PROGRESS={method}:{count}/{len(specs)}",
                        flush=True,
                    )
        results.sort(key=lambda item: item[0])
        rows = [item[1] for item in results]
        curves = np.stack([item[2] for item in results])
        rows_path = OUTPUT / f"{method}_test_rows.jsonl"
        curves_path = OUTPUT / f"{method}_test_curves.npz"
        write_jsonl(rows_path, rows)
        np.savez_compressed(curves_path, curves=curves)
        report["methods"][method] = {
            **summarize(rows),
            "wall_seconds": time.perf_counter() - started,
            "rows_sha256": sha256(rows_path),
            "curves_sha256": sha256(curves_path),
            "diagnostic_only": method == "full_map_greedy_oracle_diagnostic",
            "fair_primary_baseline": method != "full_map_greedy_oracle_diagnostic",
        }
        REPORT.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    report["status"] = "completed"
    report["gate_passed"] = True
    REPORT.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    print("PHASE13_HEURISTIC_RESULT=" + json.dumps(report, separators=(",", ":")), flush=True)


if __name__ == "__main__":
    main()