"""Group-level dynamic sampling diagnostics for GRPO v1.1 / v1.2.

Filters on *total* reward when process scoring is on, otherwise on outcome.
Does not change group size, advantage math, KL, or clip ranges.
"""

from __future__ import annotations

import math
from dataclasses import dataclass, field
from typing import Sequence

SILENT = "silent"
OUTCOME_VARIATION = "outcome_variation"
PROCESS_ONLY = "process_only_variation"
ALL_MAX = "all_max"


def _finite_std(values: Sequence[float]) -> float:
    nums = [float(v) for v in values]
    if len(nums) < 2:
        return 0.0
    mean = sum(nums) / len(nums)
    var = sum((v - mean) ** 2 for v in nums) / len(nums)
    return math.sqrt(var)


def _all_close(values: Sequence[float], target: float | None = None, eps: float = 1e-8) -> bool:
    nums = [float(v) for v in values]
    if not nums:
        return True
    ref = nums[0] if target is None else float(target)
    return all(abs(v - ref) <= eps for v in nums)


def classify_group(
    total_rewards: Sequence[float],
    *,
    outcome_rewards: Sequence[float] | None = None,
    process_rewards: Sequence[float] | None = None,
    max_total: float,
    use_process: bool = True,
    eps: float = 1e-8,
) -> str:
    totals = [float(v) for v in total_rewards]
    if not totals:
        return SILENT
    if _all_close(totals, max_total, eps=eps):
        return ALL_MAX
    if _finite_std(totals) <= eps:
        return SILENT
    outcomes = list(outcome_rewards) if outcome_rewards is not None else totals
    if _finite_std(outcomes) > eps:
        return OUTCOME_VARIATION
    processes = list(process_rewards or [])
    if use_process and processes and _finite_std(processes) > eps:
        return PROCESS_ONLY
    return OUTCOME_VARIATION if _finite_std(totals) > eps else SILENT


def keep_group(label: str) -> bool:
    return label in {OUTCOME_VARIATION, PROCESS_ONLY}


@dataclass
class FilterResult:
    keep_indices: list[int]
    labels: list[str]
    resample: bool
    cap_exhausted: bool
    counts: dict[str, int] = field(default_factory=dict)


def apply_dynamic_sampling(
    groups: Sequence[Sequence[float]],
    *,
    outcome_groups: Sequence[Sequence[float]] | None = None,
    process_groups: Sequence[Sequence[float]] | None = None,
    max_total: float,
    use_process: bool = True,
    resample_attempt: int = 0,
    resample_cap: int = 3,
    eps: float = 1e-8,
) -> FilterResult:
    """Keep groups with nonzero total-reward std. Request resample if none remain."""
    labels: list[str] = []
    keep: list[int] = []
    counts = {SILENT: 0, OUTCOME_VARIATION: 0, PROCESS_ONLY: 0, ALL_MAX: 0}
    for i, totals in enumerate(groups):
        outcomes = outcome_groups[i] if outcome_groups is not None else None
        processes = process_groups[i] if process_groups is not None else None
        if not use_process:
            processes = None
            # v1.1: filter on outcome only
            label = classify_group(
                totals if outcomes is None else outcomes,
                outcome_rewards=outcomes if outcomes is not None else totals,
                process_rewards=None,
                max_total=max_total,
                use_process=False,
                eps=eps,
            )
        else:
            label = classify_group(
                totals,
                outcome_rewards=outcomes,
                process_rewards=processes,
                max_total=max_total,
                use_process=True,
                eps=eps,
            )
        labels.append(label)
        counts[label] = counts.get(label, 0) + 1
        if keep_group(label):
            keep.append(i)
    if keep:
        return FilterResult(keep_indices=keep, labels=labels, resample=False, cap_exhausted=False, counts=counts)
    if resample_attempt < resample_cap:
        return FilterResult(keep_indices=[], labels=labels, resample=True, cap_exhausted=False, counts=counts)
    return FilterResult(keep_indices=[], labels=labels, resample=False, cap_exhausted=True, counts=counts)


def chunk_rewards(rewards: Sequence[float], group_size: int) -> list[list[float]]:
    if group_size <= 0:
        raise ValueError("group_size must be positive")
    values = list(rewards)
    groups = [values[i : i + group_size] for i in range(0, len(values), group_size)]
    return groups


def summarize_filter(result: FilterResult) -> dict[str, float]:
    n = max(len(result.labels), 1)
    return {
        "dyn/n_groups": float(len(result.labels)),
        "dyn/n_kept": float(len(result.keep_indices)),
        "dyn/frac_silent": result.counts.get(SILENT, 0) / n,
        "dyn/frac_outcome_variation": result.counts.get(OUTCOME_VARIATION, 0) / n,
        "dyn/frac_process_only": result.counts.get(PROCESS_ONLY, 0) / n,
        "dyn/frac_all_max": result.counts.get(ALL_MAX, 0) / n,
        "dyn/resample": float(result.resample),
        "dyn/cap_exhausted": float(result.cap_exhausted),
    }