from __future__ import annotations

import argparse
import json
import math
from pathlib import Path
from typing import Any


def load_result(path: str | Path) -> dict[str, Any]:
    value = json.loads(Path(path).read_text(encoding="utf-8"))
    if not isinstance(value, dict):
        raise ValueError(f"Evaluation root must be an object: {path}")
    return value


def gate_result(
    candidate: dict[str, Any],
    *,
    baseline: dict[str, Any] | None = None,
    max_loss: float | None = None,
    min_improvement: float = 0.0,
) -> dict[str, Any]:
    loss = float(candidate["validation_loss"])
    if not math.isfinite(loss):
        raise ValueError("Candidate validation loss is not finite")
    if max_loss is not None and loss > max_loss:
        raise ValueError(
            f"Candidate loss {loss:.6f} exceeds maximum {max_loss:.6f}"
        )
    baseline_loss = None
    improvement = None
    if baseline is not None:
        baseline_loss = float(baseline["validation_loss"])
        if not math.isfinite(baseline_loss):
            raise ValueError("Baseline validation loss is not finite")
        improvement = baseline_loss - loss
        if improvement < min_improvement:
            raise ValueError(
                f"Loss improvement {improvement:.6f} is below required "
                f"{min_improvement:.6f}"
            )
    samples = candidate.get("samples")
    if not isinstance(samples, list) or not samples:
        raise ValueError("Candidate evaluation has no generation samples")
    return {
        "passed": True,
        "candidate_loss": loss,
        "baseline_loss": baseline_loss,
        "loss_improvement": improvement,
        "sample_count": len(samples),
    }


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Stop a staged training pipeline when evaluation regresses."
    )
    parser.add_argument("--candidate", required=True)
    parser.add_argument("--baseline")
    parser.add_argument("--max-loss", type=float)
    parser.add_argument("--min-improvement", type=float, default=0.0)
    args = parser.parse_args()
    result = gate_result(
        load_result(args.candidate),
        baseline=load_result(args.baseline) if args.baseline else None,
        max_loss=args.max_loss,
        min_improvement=args.min_improvement,
    )
    print(json.dumps(result, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()