"""Pure metric functions — no I/O, fully unit-testable."""

from __future__ import annotations

from dataclasses import dataclass


@dataclass
class PRF:
    precision: float
    recall: float
    f1: float
    tp: int
    fp: int
    fn: int


def prf(tp: int, fp: int, fn: int) -> PRF:
    p = tp / (tp + fp) if (tp + fp) else 0.0
    r = tp / (tp + fn) if (tp + fn) else 0.0
    f = 2 * p * r / (p + r) if (p + r) else 0.0
    return PRF(p, r, f, tp, fp, fn)


def confusion(
    expected: list[set[str]], predicted: list[set[str]], labels: list[str]
) -> dict[str, PRF]:
    """Per-label P/R/F1 from per-sample expected/predicted label sets."""
    out: dict[str, PRF] = {}
    for lab in labels:
        tp = fp = fn = 0
        for exp, pred in zip(expected, predicted, strict=True):
            in_e, in_p = lab in exp, lab in pred
            if in_e and in_p:
                tp += 1
            elif in_p and not in_e:
                fp += 1
            elif in_e and not in_p:
                fn += 1
        out[lab] = prf(tp, fp, fn)
    return out


def macro_f1(metrics: dict[str, PRF]) -> float:
    return sum(m.f1 for m in metrics.values()) / len(metrics) if metrics else 0.0


def levenshtein(a: str, b: str) -> int:
    if a == b:
        return 0
    if not a:
        return len(b)
    if not b:
        return len(a)
    prev = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        cur = [i]
        for j, cb in enumerate(b, 1):
            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
        prev = cur
    return prev[-1]


def char_accuracy(pred: str, gold: str) -> float:
    if not gold:
        return 1.0 if not pred else 0.0
    return max(0.0, 1.0 - levenshtein(pred, gold) / len(gold))