"""Run the frozen REVYR registration suite and preserve raw and evaluated evidence.

The inference phase reads images and registration code only. Evaluation rules are
opened after every raw registration result has already been written to disk.
"""

from __future__ import annotations

import hashlib
import json
import sys
from datetime import datetime, timezone
from pathlib import Path

import cv2


ROOT = Path(__file__).resolve().parents[3]
CASE_DIR = ROOT / "concepts" / "revyr"
TOOLS_DIR = CASE_DIR / "tools"
ARTIFACT_DIR = CASE_DIR / "artifacts" / "verified-suite-v1"
MANIFEST_PATH = ARTIFACT_DIR / "input-manifest.json"
EVALUATOR_PATH = CASE_DIR / "tests" / "verified-suite-evaluator-v1.json"
RAW_LOG_PATH = ARTIFACT_DIR / "logs" / "registration-raw.json"
EVALUATED_LOG_PATH = ARTIFACT_DIR / "logs" / "registration-evaluated.json"
DETECTOR_PATH = TOOLS_DIR / "revyr_candidate_detector.py"

sys.path.insert(0, str(TOOLS_DIR))
from revyr_candidate_detector import build_vehicle_mask, register_reference  # noqa: E402


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()


def load_json(path: Path) -> dict:
    return json.loads(path.read_text(encoding="utf-8"))


def main() -> None:
    manifest = load_json(MANIFEST_PATH)
    generated_at = datetime.now(timezone.utc).isoformat()
    results: list[dict] = []

    for item in manifest["registration_pairs"]:
        reference_path = CASE_DIR / item["reference"]["path"]
        return_path = CASE_DIR / item["return"]["path"]
        reference = cv2.imread(str(reference_path), cv2.IMREAD_COLOR)
        returned = cv2.imread(str(return_path), cv2.IMREAD_COLOR)
        if reference is None or returned is None:
            results.append(
                {
                    "run_id": item["run_id"],
                    "variant": item["variant"],
                    "status": "error",
                    "error": "input image could not be decoded",
                }
            )
            continue

        mask = build_vehicle_mask(returned.shape[:2])
        try:
            _, metrics = register_reference(reference, returned, mask)
            results.append(
                {
                    "run_id": item["run_id"],
                    "variant": item["variant"],
                    "description": item["description"],
                    "status": "completed",
                    "reference": {
                        "path": item["reference"]["path"],
                        "sha256": sha256(reference_path),
                    },
                    "return": {
                        "path": item["return"]["path"],
                        "sha256": sha256(return_path),
                    },
                    "metrics": {
                        key: float(value) if isinstance(value, float) else int(value)
                        for key, value in metrics.items()
                    },
                }
            )
        except Exception as exc:  # preserve registration rejection as evidence
            results.append(
                {
                    "run_id": item["run_id"],
                    "variant": item["variant"],
                    "description": item["description"],
                    "status": "rejected",
                    "error": str(exc),
                    "reference": {
                        "path": item["reference"]["path"],
                        "sha256": sha256(reference_path),
                    },
                    "return": {
                        "path": item["return"]["path"],
                        "sha256": sha256(return_path),
                    },
                }
            )

    raw_log = {
        "schema_version": "1.0",
        "suite": "REVYR verified registration suite v1",
        "phase": "raw inference",
        "generated_at_utc": generated_at,
        "labels_opened": False,
        "evaluator_opened": False,
        "input_manifest": {
            "path": str(MANIFEST_PATH.relative_to(CASE_DIR)).replace("\\", "/"),
            "sha256": sha256(MANIFEST_PATH),
        },
        "implementation": {
            "path": str(DETECTOR_PATH.relative_to(CASE_DIR)).replace("\\", "/"),
            "sha256": sha256(DETECTOR_PATH),
            "algorithm": "SIFT + Lowe ratio + RANSAC homography",
        },
        "runs": results,
    }
    RAW_LOG_PATH.parent.mkdir(parents=True, exist_ok=True)
    RAW_LOG_PATH.write_text(json.dumps(raw_log, indent=2), encoding="utf-8")

    evaluator = load_json(EVALUATOR_PATH)
    gates = evaluator["registration_pass_rule"]
    evaluated_runs = []
    for result in results:
        metrics = result.get("metrics", {})
        checks = {
            "minimum_ratio_matches": metrics.get("matches", -1) >= gates["minimum_ratio_matches"],
            "minimum_ransac_inliers": metrics.get("inliers", -1) >= gates["minimum_ransac_inliers"],
            "minimum_inlier_ratio": metrics.get("inlier_ratio", -1) >= gates["minimum_inlier_ratio"],
            "maximum_reprojection_rmse_px": metrics.get("rmse", float("inf"))
            <= gates["maximum_reprojection_rmse_px"],
        }
        evaluated_runs.append(
            {
                "run_id": result["run_id"],
                "variant": result["variant"],
                "status": result["status"],
                "metrics": metrics,
                "checks": checks,
                "pass": result["status"] == "completed" and all(checks.values()),
            }
        )

    passed = sum(run["pass"] for run in evaluated_runs)
    evaluated_log = {
        "schema_version": "1.0",
        "suite": "REVYR verified registration suite v1",
        "phase": "evaluation",
        "generated_at_utc": datetime.now(timezone.utc).isoformat(),
        "raw_log": {
            "path": str(RAW_LOG_PATH.relative_to(CASE_DIR)).replace("\\", "/"),
            "sha256": sha256(RAW_LOG_PATH),
        },
        "evaluator": {
            "path": str(EVALUATOR_PATH.relative_to(CASE_DIR)).replace("\\", "/"),
            "sha256": sha256(EVALUATOR_PATH),
            "gates": gates,
        },
        "summary": {
            "runs": len(evaluated_runs),
            "passed": passed,
            "failed": len(evaluated_runs) - passed,
            "pass": passed == len(evaluated_runs) and len(evaluated_runs) >= 10,
        },
        "runs": evaluated_runs,
    }
    EVALUATED_LOG_PATH.write_text(json.dumps(evaluated_log, indent=2), encoding="utf-8")
    print(json.dumps(evaluated_log["summary"], indent=2))


if __name__ == "__main__":
    main()