"""Offline local-model evaluation wiring check using two tiny trained checkpoints.

Use the artifact directories produced by examples/training/cpu_smoke.py. This exercises real
Transformers generation and compatibility across changed model weights with one
frozen tokenizer. It does not measure model quality or establish a release gate.
"""

from __future__ import annotations

import argparse
import copy
import json
from pathlib import Path

from hessian_recipes.evaluation import checkpoint_sha256, compare, run


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--baseline", type=Path, required=True)
    parser.add_argument("--candidate", type=Path, required=True)
    parser.add_argument(
        "--tokenizer",
        type=Path,
        required=True,
        help="Local tokenizer with an explicit saved chat template",
    )
    parser.add_argument("--output", type=Path, required=True)
    args = parser.parse_args()
    from transformers import AutoTokenizer
    import torch

    torch.set_num_threads(1)
    output = args.output.resolve()
    if output.exists() and any(output.iterdir()):
        raise ValueError("choose a fresh output directory for smoke evidence")
    output.mkdir(parents=True, exist_ok=True)
    tokenizer = AutoTokenizer.from_pretrained(
        str(args.tokenizer.resolve()), local_files_only=True, trust_remote_code=False
    )
    if not tokenizer.chat_template:
        raise ValueError(
            "smoke tokenizer requires an explicit chat template; use the SFT checkpoint tokenizer"
        )
    tokenizer_dir = output / "frozen-tokenizer"
    tokenizer.save_pretrained(str(tokenizer_dir))
    tokenizer_digest = checkpoint_sha256(tokenizer_dir)
    root = Path(__file__).resolve().parents[1]
    fixture_path = root / "benchmarks/reasoning_reliability/spec.json"
    fixture = json.loads(fixture_path.read_text())
    fixture["benchmark"]["path"] = str(
        (fixture_path.parent / fixture["benchmark"]["path"]).resolve()
    )
    fixture["trials"] = 1
    fixture["sampling"].update(max_new_tokens=8)
    for label, checkpoint in (("baseline", args.baseline), ("candidate", args.candidate)):
        spec = copy.deepcopy(fixture)
        checkpoint = checkpoint.resolve()
        model_digest = checkpoint_sha256(checkpoint)
        spec["adapter"] = {
            "type": "transformers",
            "path": str(checkpoint),
            "sha256": model_digest,
            "tokenizer_path": str(tokenizer_dir),
            "tokenizer_sha256": tokenizer_digest,
        }
        spec["model"] = {
            "id": "local-tiny-" + label,
            "revision": model_digest,
            "tokenizer_id": "frozen-smoke-tokenizer",
            "tokenizer_revision": tokenizer_digest,
            "chat_template": tokenizer.chat_template,
        }
        spec_path = output / (label + "-spec.json")
        spec_path.write_text(json.dumps(spec, indent=2) + "\n")
        report = run(spec_path, output / label)
        if report["status"] != "complete":
            raise RuntimeError(
                f"{label} generation failed; inspect {output / label / 'report.json'}"
            )
    # Full tolerance deliberately checks schema/coverage/identity compatibility only.
    # It is never an example of a sensible quality threshold for an actual release.
    gate = compare(output / "baseline/report.json", output / "candidate/report.json", max_drop=1.0)
    summary = {
        "smoke_only": True,
        "release_eligible": False,
        "compatibility": gate,
        "notice": "Real CPU generation with tiny synthetic checkpoints. Full regression tolerance tests artifact compatibility only; no quality or training improvement claim.",
    }
    (output / "summary.json").write_text(json.dumps(summary, indent=2) + "\n")
    print(json.dumps(summary, indent=2))
    return 0 if gate["passed"] else 1


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