"""Score localization-given-labels predictions (bound mean IoU / accuracy)."""

from __future__ import annotations

from collections import defaultdict
from typing import Any, Sequence

from localization.schema import (
    GoldSegment,
    LabelSpec,
    PredictedInterval,
    PredictionResult,
)


def interval_iou(a_start: float, a_end: float, b_start: float, b_end: float) -> float:
    intersection = max(0.0, min(a_end, b_end) - max(a_start, b_start))
    union = max(a_end, b_end) - min(a_start, b_start)
    if union <= 0:
        return 0.0
    return intersection / union


def optimal_group_assignment(
    gold_segments: Sequence[GoldSegment],
    pred_segments: Sequence[PredictedInterval],
) -> dict[int, int]:
    """Within-label 1:1 assignment maximizing summed IoU (deterministic ties)."""
    gold_count = len(gold_segments)
    pred_count = len(pred_segments)
    target_assignments = min(gold_count, pred_count)
    if target_assignments == 0:
        return {}

    memo: dict[tuple[int, int, int], tuple[float, tuple[int | None, ...]]] = {}
    none_rank = pred_count + 1

    def better(
        left: tuple[float, tuple[int | None, ...]],
        right: tuple[float, tuple[int | None, ...]] | None,
    ) -> tuple[float, tuple[int | None, ...]]:
        if right is None:
            return left
        left_score, left_key = left
        right_score, right_key = right
        if left_score > right_score + 1e-12:
            return left
        if right_score > left_score + 1e-12:
            return right
        left_tie = tuple(none_rank if item is None else item for item in left_key)
        right_tie = tuple(none_rank if item is None else item for item in right_key)
        return left if left_tie < right_tie else right

    def solve(
        gold_index: int,
        used_mask: int,
        assignments_left: int,
    ) -> tuple[float, tuple[int | None, ...]]:
        key = (gold_index, used_mask, assignments_left)
        if key in memo:
            return memo[key]
        if gold_index == gold_count:
            if assignments_left == 0:
                return 0.0, ()
            return float("-inf"), ()

        best: tuple[float, tuple[int | None, ...]] | None = None
        remaining_gold = gold_count - gold_index
        if remaining_gold > assignments_left:
            suffix_score, suffix = solve(gold_index + 1, used_mask, assignments_left)
            best = better((suffix_score, (None, *suffix)), best)

        if assignments_left > 0:
            gold = gold_segments[gold_index]
            for pred_index, pred in enumerate(pred_segments):
                if used_mask & (1 << pred_index):
                    continue
                iou = interval_iou(
                    gold.start_sec,
                    gold.end_sec,
                    pred.start_sec,
                    pred.end_sec,
                )
                suffix_score, suffix = solve(
                    gold_index + 1,
                    used_mask | (1 << pred_index),
                    assignments_left - 1,
                )
                best = better((iou + suffix_score, (pred_index, *suffix)), best)

        if best is None:
            best = float("-inf"), ()
        memo[key] = best
        return best

    _, assignment_key = solve(0, 0, target_assignments)
    return {
        gold_index: pred_index
        for gold_index, pred_index in enumerate(assignment_key)
        if pred_index is not None
    }


def _collision_counts(pred_segments: Sequence[PredictedInterval]) -> dict[str, int]:
    overlap_pairs = 0
    duplicate_pairs = 0
    for left_index, left in enumerate(pred_segments):
        for right in pred_segments[left_index + 1 :]:
            iou = interval_iou(
                left.start_sec,
                left.end_sec,
                right.start_sec,
                right.end_sec,
            )
            if iou > 0:
                overlap_pairs += 1
            if (
                abs(left.start_sec - right.start_sec) <= 1e-9
                and abs(left.end_sec - right.end_sec) <= 1e-9
            ):
                duplicate_pairs += 1
    return {"overlap_pairs": overlap_pairs, "duplicate_pairs": duplicate_pairs}


def score_episode(
    *,
    episode_id: str,
    family: str,
    gold_segments: Sequence[GoldSegment],
    specs: Sequence[LabelSpec],
    prediction: PredictionResult,
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    """Per-gold-event IoU under grouped binding. No snapping."""
    expected = {spec.label: spec.multiplicity for spec in specs}
    gold_by_label: dict[str, list[tuple[int, GoldSegment]]] = defaultdict(list)
    for gold_index, segment in enumerate(gold_segments):
        gold_by_label[segment.label].append((gold_index, segment))

    pred_by_label: dict[str, list[PredictedInterval]] = defaultdict(list)
    malformed = 0
    unexpected_labels = 0
    for item in prediction.labels:
        if item.label not in expected:
            unexpected_labels += 1
            continue
        for interval in item.intervals:
            if (
                interval.label_echo != item.label
                or interval.end_sec <= interval.start_sec
            ):
                malformed += 1
                continue
            pred_by_label[item.label].append(interval)

    rows: list[dict[str, Any]] = []
    exact_count_labels = 0
    collision_pairs = 0
    duplicate_collision_pairs = 0
    for spec in specs:
        label = spec.label
        gold_items = gold_by_label[label]
        gold_for_label = [segment for _, segment in gold_items]
        pred_segments = pred_by_label.get(label, [])
        if len(pred_segments) == spec.multiplicity:
            exact_count_labels += 1
        collisions = _collision_counts(pred_segments)
        collision_pairs += collisions["overlap_pairs"]
        duplicate_collision_pairs += collisions["duplicate_pairs"]
        assignment = optimal_group_assignment(gold_for_label, pred_segments)
        for local_gold_index, (gold_index, gold) in enumerate(gold_items):
            pred_index = assignment.get(local_gold_index)
            pred = pred_segments[pred_index] if pred_index is not None else None
            iou = (
                interval_iou(
                    gold.start_sec,
                    gold.end_sec,
                    pred.start_sec,
                    pred.end_sec,
                )
                if pred is not None
                else 0.0
            )
            rows.append(
                {
                    "episode_id": episode_id,
                    "family": family,
                    "gold_index": gold_index,
                    "label": label,
                    "multiplicity": spec.multiplicity,
                    "gold_start_sec": gold.start_sec,
                    "gold_end_sec": gold.end_sec,
                    "pred_index_within_label": pred_index,
                    "pred_start_sec": None if pred is None else pred.start_sec,
                    "pred_end_sec": None if pred is None else pred.end_sec,
                    "iou": iou,
                    "hit_0_75": iou >= 0.75,
                }
            )

    diagnostics = {
        "labels_total": len(specs),
        "labels_exact_count": exact_count_labels,
        "label_coverage": exact_count_labels / len(specs) if specs else 1.0,
        "events_total": len(gold_segments),
        "malformed_intervals": malformed,
        "unexpected_label_groups": unexpected_labels,
        "within_group_collision_pairs": collision_pairs,
        "within_group_duplicate_pairs": duplicate_collision_pairs,
    }
    return sorted(rows, key=lambda row: row["gold_index"]), diagnostics


def metrics_from_rows(rows: Sequence[dict[str, Any]]) -> dict[str, Any]:
    """Aggregate per-event IoUs into run-level metrics.

    Reporting contract (localization given labels):
    - Per event: ``iou`` on each gold event after within-label 1:1 assignment.
    - Run / split: ``mean_iou`` is the mean of those per-event IoUs.
    - ``continuous_f1`` is the same number under this protocol (Ng = Np when
      the model returns the requested multiplicities): bound mean IoU ≡
      continuous F1 under one-to-one binding. Both keys are always emitted.
    - ``f1_at_0_75``: fraction of gold events with IoU ≥ 0.75. Under 1:1
      binding with Ng = Np this equals thresholded precision = recall = F1,
      i.e. the same F1@0.75 Macrodata uses for free segmentation (no snap).
    """
    if not rows:
        return {
            "events": 0,
            "mean_iou": None,
            "continuous_f1": None,
            "f1_at_0_75": None,
        }
    ious = [float(row["iou"]) for row in rows]
    mean_iou = sum(ious) / len(ious)
    return {
        "events": len(rows),
        "mean_iou": mean_iou,
        "continuous_f1": mean_iou,
        "f1_at_0_75": sum(iou >= 0.75 for iou in ious) / len(ious),
    }


def summarize_event_rows(rows: Sequence[dict[str, Any]]) -> dict[str, Any]:
    by_family: dict[str, list[dict[str, Any]]] = defaultdict(list)
    for row in rows:
        by_family[str(row["family"])].append(row)
    return {
        "overall": metrics_from_rows(rows),
        "by_family": {
            family: metrics_from_rows(family_rows)
            for family, family_rows in sorted(by_family.items())
        },
    }