"""Measure teacher proposal errors against resolved source-training reviews."""
from __future__ import annotations

import argparse
from collections import Counter, defaultdict
import json
from pathlib import Path

import numpy as np
from scipy.optimize import linear_sum_assignment

from pallet.annotation.workflow import is_resolved, load_jsonl
from pallet.audit_proposals import iou_xywh
from pallet.data.protocol import file_digest, load_protocol, write_json


def match_counts(reference_boxes, prediction_boxes, *, minimum_iou=.5):
    if not reference_boxes:
        return 0, len(prediction_boxes), 0
    if not prediction_boxes:
        return 0, 0, len(reference_boxes)
    scores = np.array([[iou_xywh(reference, prediction)
                        for prediction in prediction_boxes] for reference in reference_boxes])
    # One extra valid match must outweigh all possible IoU tie-break gains.
    benefit = (scores >= minimum_iou).astype(float) + (
        scores * (scores >= minimum_iou) / (min(scores.shape) + 1))
    rows, cols = linear_sum_assignment(-benefit)
    matches = sum(scores[row, col] >= minimum_iou for row, col in zip(rows, cols))
    return int(matches), len(prediction_boxes) - int(matches), len(reference_boxes) - int(matches)


def diagnose(round_dir, reviewed_labels, output, *, minimum_score=.05, minimum_iou=.5):
    round_dir = Path(round_dir)
    state = json.loads((round_dir / "round.json").read_text())
    if state["state"] != "complete" or state["reviewed_labels_sha256"] != file_digest(reviewed_labels):
        raise ValueError("diagnostics require the completed round's exact reviewed labels")
    records, assignments, _ = load_protocol(state["protocol"])
    by_id = {row.frame_id: row for row in records}
    labels = load_jsonl(reviewed_labels)
    predictions = json.loads((round_dir / "predictions.json").read_text())
    totals = Counter()
    domains = defaultdict(Counter)
    missed = []
    false_positive = []
    excluded = []
    for fid in state["frame_ids"]:
        row = by_id[fid]
        frame = labels.frames[fid]
        if assignments[row.group_id] != "train" or frame.group_id != row.group_id:
            raise ValueError(f"proposal diagnostic escaped source training: {fid}")
        if not is_resolved(frame):
            raise ValueError(f"unresolved round label: {fid}")
        if frame.status == "ignore" or frame.ignore_regions:
            excluded.append({"frame_id": fid, "reason": frame.status if frame.status == "ignore"
                             else "partial_ignore"})
            continue
        reference = [(box.x, box.y, box.width, box.height) for box in frame.boxes]
        proposed = [(box["xyxy"][0], box["xyxy"][1],
                     box["xyxy"][2] - box["xyxy"][0],
                     box["xyxy"][3] - box["xyxy"][1])
                    for box in predictions[fid] if box["score"] >= minimum_score]
        proposed = [box for box in proposed if box[2] > 0 and box[3] > 0]
        tp, fp, fn = match_counts(reference, proposed, minimum_iou=minimum_iou)
        update = {"frames": 1, "objects": len(reference), "true_positives": tp,
                  "false_positives": fp, "missed": fn}
        totals.update(update)
        domains[row.domain].update(update)
        if fn:
            missed.append({"frame_id": fid, "missed": fn, "domain": row.domain})
        if fp:
            false_positive.append({"frame_id": fid, "false_positives": fp, "domain": row.domain})
    result = {"scope": "source-training proposal quality only; not validation/test model AP",
              "round_id": state["round_id"],
              "teacher_sha256": state["teacher_sha256"],
              "reviewed_labels_sha256": file_digest(reviewed_labels),
              "minimum_score": minimum_score, "minimum_iou": minimum_iou,
              "overall": dict(totals), "per_domain": {key: dict(value) for key, value in domains.items()},
              "proposal_recall": totals["true_positives"] / totals["objects"] if totals["objects"] else None,
              "false_positives_per_scored_frame": totals["false_positives"] / totals["frames"] if totals["frames"] else None,
              "excluded": excluded, "missed_frames": missed,
              "false_positive_frames": false_positive}
    write_json(output, result)
    return result


if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument("--round", required=True)
    parser.add_argument("--reviewed-labels", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--minimum-score", type=float, default=.05)
    parser.add_argument("--minimum-iou", type=float, default=.5)
    args = parser.parse_args()
    result = diagnose(args.round, args.reviewed_labels, args.output,
                      minimum_score=args.minimum_score, minimum_iou=args.minimum_iou)
    print(json.dumps({key: result[key] for key in
                      ("overall", "proposal_recall", "false_positives_per_scored_frame") }))
