"""Memory-mapped reader for DRIVE-UGC frozen post and OCR-MASK region features.

Event indices are zero-based positions in splits/<split>/events.npz. Arrays retain
all events; use `paired_indices` for the image-bearing BGFP/RRP protocol subset.
"""
from __future__ import annotations

from pathlib import Path

import numpy as np

SPLITS = ("B_train", "A_train", "A_val", "A_test")


class FeatureSplit:
    def __init__(self, root: str | Path, split: str):
        if split not in SPLITS:
            raise ValueError(f"split must be one of {SPLITS}")
        root = Path(root)
        folder = root / "features" / split
        self.text = np.load(folder / "text.npy", mmap_mode="r", allow_pickle=False)
        self.text_offsets = np.load(folder / "text_event_offsets.npy", allow_pickle=False)
        self.regions = np.load(folder / "regions.npy", mmap_mode="r", allow_pickle=False)
        self.region_offsets = np.load(folder / "region_event_offsets.npy", allow_pickle=False)
        self.image_offsets = np.load(folder / "region_image_offsets.npy", allow_pickle=False)
        with np.load(root / "splits" / split / "events.npz", allow_pickle=False) as meta:
            self.ids = meta["ids"].copy()
            self.groups = meta["groups"].copy()
            self.y = meta["y"].copy()
            self.paired = meta["paired"].copy()
        n = len(self.ids)
        if not (len(self.groups) == len(self.y) == len(self.paired) == n):
            raise ValueError("Event metadata lengths disagree")
        if self.text.shape[1:] != (1024,) or self.regions.shape[1:] != (1152,):
            raise ValueError("Unexpected feature dimensions")
        if self.regions.dtype != np.float16:
            raise ValueError("Expected float16 OCR-MASK regions")
        if len(self.text_offsets) != n + 1 or len(self.region_offsets) != n + 1:
            raise ValueError("Event offset lengths disagree")
        if self.text_offsets[0] != 0 or self.text_offsets[-1] != len(self.text):
            raise ValueError("Invalid post offsets")
        if self.region_offsets[0] != 0 or self.region_offsets[-1] != len(self.regions):
            raise ValueError("Invalid region offsets")
        if self.image_offsets[0] != 0 or self.image_offsets[-1] != len(self.regions):
            raise ValueError("Invalid image offsets")
        if not np.all(np.diff(self.image_offsets) == 81):
            raise ValueError("Each image must have exactly 81 regions")
        if not np.all(self.region_offsets % 81 == 0):
            raise ValueError("Event boundaries do not align with images")
        if not np.array_equal(self.paired, np.diff(self.region_offsets) > 0):
            raise ValueError("Paired flags disagree with image-bearing events")

    def __len__(self) -> int:
        return len(self.ids)

    @property
    def paired_indices(self) -> np.ndarray:
        return np.flatnonzero(self.paired)

    def event(self, public_event_index: int) -> dict:
        i = int(public_event_index)
        if i < 0 or i >= len(self):
            raise IndexError(i)
        p0, p1 = map(int, self.text_offsets[i:i+2])
        r0, r1 = map(int, self.region_offsets[i:i+2])
        image0, image1 = r0 // 81, r1 // 81
        boundaries = self.image_offsets[image0:image1+1] - r0
        return {
            "public_event_index": i,
            "event_id": str(self.ids[i]),
            "content_group_id": str(self.groups[i]),
            "label": int(self.y[i]),
            "paired": bool(self.paired[i]),
            "posts": self.text[p0:p1],
            "regions": self.regions[r0:r1],
            "image_region_offsets": boundaries,
        }


def load_split(root: str | Path, split: str) -> FeatureSplit:
    return FeatureSplit(root, split)