"""Contact metrics and reference-frame selection.

These reproduce the values shipped in the dataset parquet, and match
``react_toolbox.contact`` so producer and consumer agree by construction.
"""
from __future__ import annotations

import numpy as np

from .config import TAU


def l2_diff(frames: np.ndarray, reference: np.ndarray) -> np.ndarray:
    """Per-pixel L2 distance from a reference frame.

    frames: (..., H, W, 3) uint8/float, reference: (H, W, 3). -> (..., H, W)
    """
    d = frames.astype(np.float32) - reference.astype(np.float32)
    return np.sqrt((d ** 2).sum(axis=-1))


def contact_metrics(frames: np.ndarray, reference: np.ndarray, tau: float = TAU):
    """(intensity, area, mixed) for a block of frames.

    intensity = mean L2 distance, area = fraction above `tau`,
    mixed = mean of the thresholded distance.
    """
    d = l2_diff(frames, reference)
    above = d > tau
    axes = (-2, -1)
    return (d.mean(axis=axes).astype(np.float32),
            above.mean(axis=axes).astype(np.float32),
            (d * above).mean(axis=axes).astype(np.float32))


def smooth(x: np.ndarray, win: int) -> np.ndarray:
    w = max(1, min(win, len(x)))
    return np.convolve(x, np.ones(w) / w, mode="same")


def pick_p01_reference(intensity: np.ndarray, win: int) -> int:
    """Index of the quietest (least-contact) frame — the no-contact reference.

    Smoothing first avoids latching onto a single noisy frame.
    """
    return int(smooth(intensity, win).argmin())


class NewFrameTracker:
    """Flags which frames are genuinely new tactile captures.

    A GelSight frame repeated across consecutive rows means the sensor did not
    update between those camera ticks — true of ~72 % of rows in legacy
    recordings (tactile really ran at ~8 fps while rows were written at 30 Hz),
    and of ~40 % in fixed recordings (18.75 fps sensor, 30 Hz rows).

    Detection is an exact frame comparison, so it is correct for both the
    legacy (duplicate pixels) and timestamped (repeated index) layouts.
    """

    def __init__(self):
        self._prev = None

    def update(self, block: np.ndarray) -> np.ndarray:
        """block: (n, H, W, 3) uint8 -> (n,) bool, True where the frame changed."""
        n = len(block)
        out = np.empty(n, dtype=bool)
        for i in range(n):
            prev = block[i - 1] if i > 0 else self._prev
            out[i] = True if prev is None else not np.array_equal(block[i], prev)
        self._prev = block[-1].copy() if n else self._prev
        return out


def duplication_stats(is_new: np.ndarray, fps: float = 30.0) -> dict:
    """Summarise how much of a tactile stream is duplicated."""
    n = len(is_new)
    if n == 0:
        return {"n_frames": 0, "n_unique": 0, "duplicate_ratio": 0.0,
                "effective_fps": 0.0, "max_repeat_run": 0}
    n_unique = int(is_new.sum())
    runs, cur = [], 0
    for flag in is_new:
        if flag:
            if cur:
                runs.append(cur)
            cur = 1
        else:
            cur += 1
    if cur:
        runs.append(cur)
    return {
        "n_frames": n,
        "n_unique": n_unique,
        "duplicate_ratio": float(1.0 - n_unique / n),
        "effective_fps": float(n_unique / (n / fps)) if n else 0.0,
        "max_repeat_run": int(max(runs)) if runs else 0,
    }