"""Taxonomy-relaxed metrics driven by a frozen semantic-pair policy."""

from __future__ import annotations

from collections import defaultdict
from dataclasses import dataclass

from metrics._f_beta import ViolationCounts, aggregate_summary, summarise_counts
from metrics._labels import to_use_case_id
from metrics.localisation import _compute_iou, maximum_match_pairs
from schemas.ground_truth import GoldRecord
from schemas.inference import InferenceResponse


@dataclass(frozen=True)
class SemanticPolicy:
    """A symmetric class-pair acceptance matrix with similarity provenance."""

    class_ids: tuple[str, ...]
    similarities: tuple[tuple[float, ...], ...]
    accepted: tuple[tuple[int, ...], ...]

    @classmethod
    def from_dict(cls, payload: dict) -> "SemanticPolicy":
        return cls(
            class_ids=tuple(payload["class_ids"]),
            similarities=tuple(tuple(row) for row in payload["cosine_matrix"]),
            accepted=tuple(tuple(row) for row in payload["accepted_matrix"]),
        )

    def _indices(self, predicted: str, gold: str) -> tuple[int, int] | None:
        try:
            return self.class_ids.index(predicted), self.class_ids.index(gold)
        except ValueError:
            return None

    def allows(self, predicted: str, gold: str) -> bool:
        indices = self._indices(predicted, gold)
        return bool(indices and self.accepted[indices[0]][indices[1]])

    def similarity(self, predicted: str, gold: str) -> float:
        indices = self._indices(predicted, gold)
        return self.similarities[indices[0]][indices[1]] if indices else 0.0


def _maximum_semantic_pairs(
    predicted: list[str], gold: list[str], policy: SemanticPolicy
) -> list[tuple[int, int]]:
    """Maximum-cardinality deterministic matching for non-exact class pairs."""
    candidates = [
        sorted(
            (j for j, gold_id in enumerate(gold) if pred_id != gold_id and policy.allows(pred_id, gold_id)),
            key=lambda j: (-policy.similarity(pred_id, gold[j]), j),
        )
        for pred_id in predicted
    ]
    gold_owner: dict[int, int] = {}

    def assign(pred_index: int, seen: set[int]) -> bool:
        for gold_index in candidates[pred_index]:
            if gold_index in seen:
                continue
            seen.add(gold_index)
            owner = gold_owner.get(gold_index)
            if owner is None or assign(owner, seen):
                gold_owner[gold_index] = pred_index
                return True
        return False

    for pred_index in sorted(
        range(len(predicted)),
        key=lambda i: (-max((policy.similarity(predicted[i], gold[j]) for j in candidates[i]), default=0.0), i),
    ):
        assign(pred_index, set())
    return sorted((pred_index, gold_index) for gold_index, pred_index in gold_owner.items())


def _negative_fields(prediction_labels: set[str], record: GoldRecord, totals: dict) -> None:
    if record.gold.no_violation_detected:
        totals["negative_images"] += 1
        if prediction_labels:
            totals["false_positive_images"] += 1
        else:
            totals["true_negative_images"] += 1


def compute_semantic_classification_metrics(
    predictions: list[InferenceResponse],
    ground_truths: list[GoldRecord],
    policy: SemanticPolicy,
) -> dict:
    """Score unique class sets with exact-first, one-to-one semantic matching."""
    gt_by_id = {record.image_id: record for record in ground_truths}
    counts: dict[str, ViolationCounts] = defaultdict(ViolationCounts)
    totals = {"negative_images": 0, "true_negative_images": 0, "false_positive_images": 0}
    credited = []
    evaluated = 0
    for prediction in predictions:
        record = gt_by_id.get(prediction.image_id)
        if record is None or record.gold.reported:
            continue
        evaluated += 1
        gt_labels = {item.use_case_id for item in record.gold.violations}
        pred_labels = {to_use_case_id(item.category_id) for item in prediction.detections}
        exact = gt_labels & pred_labels
        for label in exact:
            counts[label].tp += 1
        unmatched_pred = sorted(pred_labels - exact)
        unmatched_gt = sorted(gt_labels - exact)
        pairs = _maximum_semantic_pairs(unmatched_pred, unmatched_gt, policy)
        matched_pred = {pred_index for pred_index, _ in pairs}
        matched_gt = {gold_index for _, gold_index in pairs}
        for pred_index, gold_index in pairs:
            predicted_id, gold_id = unmatched_pred[pred_index], unmatched_gt[gold_index]
            counts[gold_id].tp += 1
            credited.append({
                "image_id": prediction.image_id,
                "predicted_class": predicted_id,
                "gold_class": gold_id,
                "similarity": round(policy.similarity(predicted_id, gold_id), 6),
            })
        for index, label in enumerate(unmatched_pred):
            if index not in matched_pred:
                counts[label].fp += 1
        for index, label in enumerate(unmatched_gt):
            if index not in matched_gt:
                counts[label].fn += 1
        _negative_fields(pred_labels, record, totals)
    negatives = totals["negative_images"]
    return {
        "per_violation": summarise_counts(counts),
        "summary": aggregate_summary(counts),
        "n_images": evaluated,
        **totals,
        "negative_false_positive_rate": round(totals["false_positive_images"] / negatives, 4) if negatives else None,
        "credited_matches": credited,
    }


def _maximum_semantic_box_pairs(predictions: list[dict], gold: list[dict], policy: SemanticPolicy, threshold: float) -> list[tuple[int, int, float]]:
    candidates = [
        sorted(
            (
                j for j, target in enumerate(gold)
                if item["label"] != target["label"]
                and policy.allows(item["label"], target["label"])
                and _compute_iou(item["bbox"], target["bbox"]) >= threshold
            ),
            key=lambda j: (
                -policy.similarity(item["label"], gold[j]["label"]),
                -_compute_iou(item["bbox"], gold[j]["bbox"]),
                gold[j]["index"],
            ),
        )
        for item in predictions
    ]
    gold_owner: dict[int, int] = {}

    def assign(pred_index: int, seen: set[int]) -> bool:
        for gold_index in candidates[pred_index]:
            if gold_index in seen:
                continue
            seen.add(gold_index)
            owner = gold_owner.get(gold_index)
            if owner is None or assign(owner, seen):
                gold_owner[gold_index] = pred_index
                return True
        return False

    for pred_index in sorted(range(len(predictions)), key=lambda i: predictions[i]["index"]):
        assign(pred_index, set())
    return sorted(
        (
            pred_index,
            gold_index,
            _compute_iou(predictions[pred_index]["bbox"], gold[gold_index]["bbox"]),
        )
        for gold_index, pred_index in gold_owner.items()
    )


def compute_semantic_localisation_metrics(
    predictions: list[InferenceResponse],
    ground_truths: list[GoldRecord],
    policy: SemanticPolicy,
    iou_threshold: float = 0.50,
) -> dict:
    """Score boxes with exact-label matches first, then accepted class pairs."""
    gt_by_id = {record.image_id: record for record in ground_truths}
    counts: dict[str, ViolationCounts] = defaultdict(ViolationCounts)
    totals = {"negative_images": 0, "true_negative_images": 0, "false_positive_images": 0}
    credited = []
    evaluated = n_predictions = n_gt_boxes = 0
    for prediction in predictions:
        record = gt_by_id.get(prediction.image_id)
        if record is None or record.gold.reported:
            continue
        evaluated += 1
        pred_items = [
            {"index": i, "label": to_use_case_id(item.category_id), "bbox": item.bbox}
            for i, item in enumerate(prediction.detections)
        ]
        gt_items = [
            {"index": i, "label": item.use_case_id, "bbox": item.bbox}
            for i, item in enumerate(record.gold.violations)
        ]
        n_predictions += len(pred_items)
        n_gt_boxes += len(gt_items)
        matched_pred: set[int] = set()
        matched_gt: set[int] = set()
        labels = {item["label"] for item in pred_items + gt_items}
        for label in sorted(labels):
            preds = [item for item in pred_items if item["label"] == label]
            golds = [item for item in gt_items if item["label"] == label]
            for local_pred, local_gt, _ in maximum_match_pairs(
                [item["bbox"] for item in preds], [item["bbox"] for item in golds], iou_threshold
            ):
                matched_pred.add(preds[local_pred]["index"])
                matched_gt.add(golds[local_gt]["index"])
                counts[label].tp += 1
        remaining_pred = [item for item in pred_items if item["index"] not in matched_pred]
        remaining_gt = [item for item in gt_items if item["index"] not in matched_gt]
        semantic_pairs = _maximum_semantic_box_pairs(remaining_pred, remaining_gt, policy, iou_threshold)
        semantic_pred = {pred_index for pred_index, _, _ in semantic_pairs}
        semantic_gt = {gold_index for _, gold_index, _ in semantic_pairs}
        for pred_index, gold_index, iou in semantic_pairs:
            pred_item, gold_item = remaining_pred[pred_index], remaining_gt[gold_index]
            counts[gold_item["label"]].tp += 1
            credited.append({
                "image_id": prediction.image_id,
                "prediction_index": pred_item["index"],
                "gold_index": gold_item["index"],
                "predicted_class": pred_item["label"],
                "gold_class": gold_item["label"],
                "similarity": round(policy.similarity(pred_item["label"], gold_item["label"]), 6),
                "iou": round(iou, 6),
            })
        for index, item in enumerate(remaining_pred):
            if index not in semantic_pred:
                counts[item["label"]].fp += 1
        for index, item in enumerate(remaining_gt):
            if index not in semantic_gt:
                counts[item["label"]].fn += 1
        _negative_fields({item["label"] for item in pred_items}, record, totals)
    negatives = totals["negative_images"]
    return {
        "per_violation": summarise_counts(counts),
        "summary": aggregate_summary(counts),
        "iou_threshold": iou_threshold,
        "n_images": evaluated,
        "n_predictions": n_predictions,
        "n_gt_boxes": n_gt_boxes,
        **totals,
        "negative_false_positive_rate": round(totals["false_positive_images"] / negatives, 4) if negatives else None,
        "credited_matches": credited,
    }