"""Held-out INTERVALS carved from inside episodes, with a leak-proof guard.

WHY NOT HOLD OUT WHOLE EPISODES

There are 32 motherboard episodes and 194,445 frames. Holding out episodes
spends the scarce resource — episodes, and with them board layouts and lighting
— to buy independence that a short-horizon world model does not need: what it
must generalise over is dynamics within a scene, not scenes.

So the split is at INTERVAL level. Each episode contributes a few held-out
windows from its middle; the rest of that episode trains.

THE PART THAT LEAKS IF YOU GET IT WRONG

A training window starting shortly BEFORE a held-out interval still contains
its frames. Excluding only the interval is not enough. A window of span S
starting at s covers [s, s+S-1], so starts in [a-(S-1), b] must be rejected,
not just [a, b].

`guard_frames` is therefore `max_train_window - 1`, and it is RECORDED. A
loader using a longer window must FAIL rather than silently leak — see
`assert_window_fits`. That failure mode leaves no trace in any metric until
the numbers are suspiciously good.

Cost, measured over this release with a 64-frame training window:
    test 12.2%   guard 9.5%   train 78.4%   over 146 held-out intervals
The guard is what independence costs; naming it makes the price visible.

EPISODES TOO SHORT TO CARVE go entirely to test rather than being dropped,
which also yields a few wholly-unseen episodes for free.
"""
from __future__ import annotations

import json
from pathlib import Path

import numpy as np

FORMAT = "react-splits/1.0"
TEST_INTERVAL_FRAMES = 160      # 128-frame probe horizon + 4 context + slack
MAX_TRAIN_WINDOW = 64           # frames; guard = this - 1
TARGET_TEST_FRACTION = 0.12


def _bad_mask(entry: dict, T: int) -> np.ndarray:
    m = np.zeros(T, bool)
    for k in ("intensity_spikes", "pose_teleports_L", "pose_teleports_R",
              "ot_loss_L", "ot_loss_R"):
        for a, b in entry.get(k, []):
            m[max(0, a):min(T, b + 1)] = True
    return m


def build_splits(episodes, bad=None, seed: int = 0,
                 test_len: int = TEST_INTERVAL_FRAMES,
                 max_train_window: int = MAX_TRAIN_WINDOW,
                 target: float = TARGET_TEST_FRACTION) -> dict:
    """Carve held-out intervals. Deterministic given `episodes` and `seed`.

    `bad` is the `bad_frames.json` episodes dict, so an interval is never
    placed on a stretch of dropouts — a test window full of tracking loss
    measures the rig, not the model.
    """
    guard = int(max_train_window) - 1
    rng = np.random.default_rng(seed)
    need = 2 * test_len + 2 * guard
    out, n_test, n_guard, n_tot = {}, 0, 0, 0

    for e in sorted(episodes, key=lambda x: x["episode"]):
        key, N = e["episode"], int(e["n_frames"])
        n_tot += N
        if N < need:
            out[key] = {"n_frames": N, "whole": "test",
                        "test": [[0, N - 1]], "guard": []}
            n_test += N
            continue
        k = max(1, int(round(N * target / test_len)))
        k = min(k, max(1, (N - test_len) // (test_len + 2 * guard)))
        bm = _bad_mask(bad.get(key, {}) if bad else {}, N)
        lo, hi = guard, N - test_len - guard
        iv = []
        for c in np.linspace(lo, hi, k + 2)[1:-1]:
            a0 = int(np.clip(round(c + rng.integers(-test_len // 2, test_len // 2 + 1)),
                             lo, hi))
            for shift in (0, *[s for d in range(1, test_len + 1) for s in (d, -d)]):
                s = int(np.clip(a0 + shift, lo, hi))
                b = s + test_len - 1
                if bm[s:b + 1].any():
                    continue
                if any(not (b + guard < p or s - guard > q) for p, q in iv):
                    continue
                iv.append([s, b])
                break
        iv.sort()
        out[key] = {"n_frames": N, "whole": None, "test": iv,
                    "guard": [[max(0, s - guard), min(N - 1, b + guard)]
                              for s, b in iv]}
        n_test += sum(b - a + 1 for a, b in iv)
        n_guard += 2 * guard * len(iv)

    return {
        "format": FORMAT, "seed": int(seed), "policy": "interval",
        "test_interval_frames": int(test_len),
        "max_train_window": int(max_train_window), "guard_frames": guard,
        "guard_note": ("a training window of span S starting at s covers "
                       "[s, s+S-1], so starts in [a-(S-1), b] must be rejected, "
                       "not just [a, b]. guard_frames = max_train_window - 1; a "
                       "loader using a longer window must rebuild the split."),
        "episodes": out,
        "stats": {"n_episodes": len(out), "n_frames": n_tot,
                  "n_test_frames": n_test, "n_guard_frames": n_guard,
                  "test_fraction": round(n_test / n_tot, 4),
                  "guard_fraction": round(n_guard / n_tot, 4),
                  "n_test_intervals": sum(len(v["test"]) for v in out.values()),
                  "n_whole_test_episodes": sum(1 for v in out.values() if v["whole"])},
    }


def load_splits(path) -> dict:
    d = json.loads(Path(path).read_text())
    if d.get("format") != FORMAT:
        raise ValueError(f"expected {FORMAT}, got {d.get('format')!r}")
    return d


def assert_window_fits(splits: dict, window_span: int) -> None:
    """Refuse a training window the guard cannot cover."""
    if window_span - 1 > splits["guard_frames"]:
        raise ValueError(
            f"training window spans {window_span} frames but the split has "
            f"guard_frames={splits['guard_frames']} "
            f"(max_train_window={splits['max_train_window']}). A window this "
            f"long would overlap held-out intervals. Rebuild the split with "
            f"max_train_window >= {window_span}.")


def forbidden_starts(splits: dict, ep_key: str, window_span: int):
    """[(lo, hi)] inclusive start indices a TRAIN window may not begin at."""
    e = splits["episodes"].get(ep_key)
    if e is None:
        return []
    if e["whole"] == "test":
        return [(0, e["n_frames"] - 1)]
    return [(max(0, a - (window_span - 1)), b) for a, b in e["test"]]


def test_starts(splits: dict, ep_key: str, window_span: int):
    """[(lo, hi)] start indices whose whole window lies inside a test interval."""
    e = splits["episodes"].get(ep_key)
    if e is None:
        return []
    return [(a, b - window_span + 1) for a, b in e["test"]
            if b - a + 1 >= window_span]