"""字符检测（Detection / End-to-End Spotting）打分。

  - Detection：仅看 bbox，IoU > 0.75 视为 TP，包含 [UNK]
  - Spotting：IoU > 0.75 且字符匹配视为 TP，排除 [UNK]
均输出 per-sample F1。GT bbox 像素单位会被归一化到 0-1000 与模型输出对齐。
"""

from __future__ import annotations

from ..utils.unk import is_unk_char

IOU_THRESH = 0.75


def _iou(a, b) -> float:
    ax1, ay1, ax2, ay2 = a
    bx1, by1, bx2, by2 = b
    if ax2 <= ax1 or ay2 <= ay1 or bx2 <= bx1 or by2 <= by1:
        return 0.0
    ix1, iy1 = max(ax1, bx1), max(ay1, by1)
    ix2, iy2 = min(ax2, bx2), min(ay2, by2)
    iw, ih = ix2 - ix1, iy2 - iy1
    if iw <= 0 or ih <= 0:
        return 0.0
    inter = iw * ih
    union = (ax2 - ax1) * (ay2 - ay1) + (bx2 - bx1) * (by2 - by1) - inter
    return inter / union if union > 0 else 0.0


def _parse_gt(row: dict) -> tuple[list[dict], int, int]:
    """解析 GT spotting，返回 [{'bbox':[x1,y1,x2,y2],'char':str}, ...] + 图像 W/H。"""
    sp = row.get("spotting") or []
    W = int(row.get("width") or 0)
    H = int(row.get("height") or 0)
    items: list[dict] = []
    for it in sp:
        if not isinstance(it, dict):
            continue
        ch = it.get("modern_char")
        if ch is None:
            ch = it.get("text", "")
        ch = str(ch or "").strip()

        bbox = it.get("bbox")
        if bbox is None:
            continue
        x1 = y1 = x2 = y2 = None
        if isinstance(bbox, dict):
            try:
                x1, y1, x2, y2 = (float(bbox[k]) for k in ("x1", "y1", "x2", "y2"))
            except (KeyError, TypeError, ValueError):
                continue
        elif isinstance(bbox, (list, tuple)) and len(bbox) == 4:
            try:
                bx = [float(v) for v in bbox]
            except (TypeError, ValueError):
                continue
            if bx[2] < bx[0] or bx[3] < bx[1]:
                x1, y1, x2, y2 = bx[0], bx[1], bx[0] + bx[2], bx[1] + bx[3]
            else:
                if "modern_char" in it:
                    x1, y1, x2, y2 = bx[0], bx[1], bx[0] + bx[2], bx[1] + bx[3]
                else:
                    x1, y1, x2, y2 = bx
        else:
            continue
        if x2 <= x1 or y2 <= y1:
            continue
        items.append({"bbox": [float(x1), float(y1), float(x2), float(y2)], "char": ch})
    return items, W, H


def _scale_to_1000(items: list[dict], W: int, H: int) -> list[dict]:
    if W <= 0 or H <= 0:
        return []
    sx, sy = 1000.0 / W, 1000.0 / H
    return [
        {"bbox": [it["bbox"][0] * sx, it["bbox"][1] * sy, it["bbox"][2] * sx, it["bbox"][3] * sy], "char": it["char"]}
        for it in items
    ]


def _match(preds: list[dict], gts: list[dict], iou_thresh: float, require_char: bool) -> tuple[int, int, int]:
    if not preds or not gts:
        return 0, len(preds), len(gts)
    pairs: list[tuple[float, int, int]] = []
    for pi, p in enumerate(preds):
        for gi, g in enumerate(gts):
            if require_char and p.get("char", "") != g.get("char", ""):
                continue
            iou = _iou(p["bbox"], g["bbox"])
            if iou >= iou_thresh:
                pairs.append((iou, pi, gi))
    pairs.sort(key=lambda x: x[0], reverse=True)
    used_p, used_g, tp = set(), set(), 0
    for _, pi, gi in pairs:
        if pi in used_p or gi in used_g:
            continue
        used_p.add(pi)
        used_g.add(gi)
        tp += 1
    return tp, len(preds) - tp, len(gts) - tp


def _f1(tp: int, fp: int, fn: int) -> float:
    if tp == 0:
        return 0.0
    p = tp / (tp + fp) if (tp + fp) else 0.0
    r = tp / (tp + fn) if (tp + fn) else 0.0
    return 2 * p * r / (p + r) if (p + r) else 0.0


def judge(extract: dict, row: dict, iou_thresh: float = IOU_THRESH) -> dict:
    gt_raw, W, H = _parse_gt(row)
    gts = _scale_to_1000(gt_raw, W, H)

    preds_src = (extract or {}).get("items") or []
    preds: list[dict] = []
    for it in preds_src:
        if not isinstance(it, dict):
            continue
        bb = it.get("bbox")
        if not isinstance(bb, (list, tuple)) or len(bb) != 4:
            continue
        try:
            bb = [float(v) for v in bb]
        except (TypeError, ValueError):
            continue
        if bb[2] <= bb[0] or bb[3] <= bb[1]:
            continue
        preds.append({"bbox": bb, "char": str(it.get("char", "") or "").strip()})

    det_tp, det_fp, det_fn = _match(preds, gts, iou_thresh, require_char=False)
    det_f1 = _f1(det_tp, det_fp, det_fn)

    spot_gts = [it for it in gts if not is_unk_char(it["char"])]
    spot_preds = [it for it in preds if not is_unk_char(it["char"])]
    spot_tp, spot_fp, spot_fn = _match(spot_preds, spot_gts, iou_thresh, require_char=True)
    spot_f1 = _f1(spot_tp, spot_fp, spot_fn)

    return {
        "score": spot_f1,
        "iou_thresh": iou_thresh,
        "detection_f1": det_f1,
        "spotting_f1": spot_f1,
        "detection": {"tp": det_tp, "fp": det_fp, "fn": det_fn},
        "spotting": {"tp": spot_tp, "fp": spot_fp, "fn": spot_fn},
        "n_pred": len(preds),
        "n_gt": len(gts),
    }