"""Group-clustered bootstrap and paired randomization for scored runs."""

from __future__ import annotations

import math
import random
from collections import defaultdict
from collections.abc import Mapping, Sequence
from typing import Any

from .core import EvaluationError


def _group_outcomes(rows: Sequence[Mapping[str, Any]], metric: str) -> dict[str, float]:
    grouped: dict[str, list[Mapping[str, Any]]] = defaultdict(list)
    for row in rows:
        group_id = row.get("group_id")
        if not isinstance(group_id, str) or not group_id:
            raise EvaluationError("scored row has no group_id")
        grouped[group_id].append(row)
    if metric == "strict_group_accuracy":
        return {
            group_id: float(all(bool(row.get("correct")) for row in group_rows))
            for group_id, group_rows in grouped.items()
        }
    if metric == "accuracy":
        return {
            group_id: sum(bool(row.get("correct")) for row in group_rows) / len(group_rows)
            for group_id, group_rows in grouped.items()
        }
    raise EvaluationError(f"unsupported paired metric: {metric!r}")


def _quantile(values: Sequence[float], probability: float) -> float:
    if not values:
        raise EvaluationError("cannot take a quantile of an empty sequence")
    ordered = sorted(values)
    position = (len(ordered) - 1) * probability
    lower = math.floor(position)
    upper = math.ceil(position)
    if lower == upper:
        return ordered[lower]
    fraction = position - lower
    return ordered[lower] * (1.0 - fraction) + ordered[upper] * fraction


def _holm(raw_p_values: Sequence[float]) -> list[float]:
    count = len(raw_p_values)
    order = sorted(range(count), key=lambda index: raw_p_values[index])
    adjusted = [0.0] * count
    running = 0.0
    for rank, index in enumerate(order):
        candidate = min(1.0, (count - rank) * raw_p_values[index])
        running = max(running, candidate)
        adjusted[index] = running
    return adjusted


def compare_runs(
    runs: Mapping[str, Sequence[Mapping[str, Any]]],
    *,
    reference: str,
    metric: str = "strict_group_accuracy",
    benchmark: str | None = None,
    bootstrap_replicates: int = 10_000,
    permutation_replicates: int = 10_000,
    seed: int = 20260728,
) -> dict[str, Any]:
    """Compare every run with one reference using base-group as the unit."""

    if reference not in runs:
        raise EvaluationError(f"reference run {reference!r} is absent")
    if bootstrap_replicates <= 0 or permutation_replicates <= 0:
        raise EvaluationError("statistical replicate counts must be positive")
    selected_runs: dict[str, list[Mapping[str, Any]]] = {}
    for run_id, rows in runs.items():
        selected = [
            row for row in rows if benchmark is None or row.get("benchmark") == benchmark
        ]
        if not selected:
            raise EvaluationError(
                f"run {run_id!r} has no rows for benchmark {benchmark!r}"
            )
        observed_benchmarks = {str(row.get("benchmark", "")) for row in selected}
        if benchmark is None and len(observed_benchmarks) > 1:
            raise EvaluationError(
                "scored rows contain multiple benchmarks; select one with --benchmark"
            )
        selected_runs[run_id] = selected
    outcomes = {run_id: _group_outcomes(rows, metric) for run_id, rows in selected_runs.items()}
    reference_groups = set(outcomes[reference])
    if not reference_groups:
        raise EvaluationError("reference score has no groups")
    for run_id, values in outcomes.items():
        if set(values) != reference_groups:
            raise EvaluationError(f"paired group coverage differs for run {run_id}")
    group_ids = sorted(reference_groups)
    comparisons: list[dict[str, Any]] = []
    rng = random.Random(seed)
    for run_id in sorted(run for run in outcomes if run != reference):
        deltas = [outcomes[run_id][group] - outcomes[reference][group] for group in group_ids]
        observed = sum(deltas) / len(deltas)
        bootstrap: list[float] = []
        for _ in range(bootstrap_replicates):
            bootstrap.append(
                sum(deltas[rng.randrange(len(deltas))] for _ in deltas) / len(deltas)
            )
        exceed = 0
        for _ in range(permutation_replicates):
            permuted = sum(delta if rng.getrandbits(1) else -delta for delta in deltas) / len(
                deltas
            )
            exceed += abs(permuted) >= abs(observed)
        comparisons.append(
            {
                "run_id": run_id,
                "reference": reference,
                "metric": metric,
                "group_count": len(group_ids),
                "difference": observed,
                "bootstrap_95_ci": [
                    _quantile(bootstrap, 0.025),
                    _quantile(bootstrap, 0.975),
                ],
                "paired_permutation_p": (exceed + 1) / (permutation_replicates + 1),
            }
        )
    adjusted = _holm([float(row["paired_permutation_p"]) for row in comparisons])
    for row, value in zip(comparisons, adjusted, strict=True):
        row["holm_adjusted_p"] = value
    return {
        "schema_version": 1,
        "kind": "paired_group_statistics",
        "reference": reference,
        "metric": metric,
        "benchmark": benchmark,
        "bootstrap_replicates": bootstrap_replicates,
        "permutation_replicates": permutation_replicates,
        "seed": seed,
        "comparisons": comparisons,
    }