"""StatePlay state utilities for state-aware training.

This module keeps StatePlay state loading separate from action preprocessing.
"""
from __future__ import annotations

import os

import numpy as np
import pandas as pd
import torch


_ALIASES = {
    "hp1": ("hp1", "p1_hp"),
    "hp2": ("hp2", "p2_hp"),
    "meter1": ("meter1", "p1_meter"),
    "meter2": ("meter2", "p2_meter"),
    "timer": ("timer",),
}


def parse_state_columns(columns: str) -> list[str]:
    cols = [c.strip() for c in columns.split(",") if c.strip()]
    if len(cols) != 5:
        raise ValueError(
            f"--state_columns must contain exactly 5 comma-separated columns; got {cols!r}"
        )
    return cols


def parse_state_norm_max(norm_max: str) -> torch.Tensor:
    vals = [float(x.strip()) for x in norm_max.split(",") if x.strip()]
    if len(vals) != 5:
        raise ValueError(
            f"--state_norm_max must contain exactly 5 comma-separated values; got {vals!r}"
        )
    if any(v <= 0 for v in vals):
        raise ValueError(f"--state_norm_max values must be positive; got {vals!r}")
    return torch.tensor(vals, dtype=torch.float32)


def _resolve_columns(df: pd.DataFrame, requested: list[str]) -> list[str]:
    actual = set(df.columns)
    resolved = []
    missing = []
    for col in requested:
        aliases = _ALIASES.get(col, (col,))
        hit = next((name for name in aliases if name in actual), None)
        if hit is None:
            missing.append((col, aliases))
        else:
            resolved.append(hit)
    if missing:
        details = "; ".join(
            f"{col} (accepted: {', '.join(aliases)})" for col, aliases in missing
        )
        raise KeyError(
            "[StatePlay state] Required state columns are missing from action/state parquet: "
            f"{details}. Available columns: {sorted(df.columns.tolist())}"
        )
    return resolved


def load_state_from_action_parquet(
    rel_path: str,
    base_path: str,
    num_frames: int,
    state_columns: list[str],
    state_norm_max: torch.Tensor,
) -> torch.Tensor:
    """Load normalized state as [1, T, 5] float32 from an action parquet."""
    full = os.path.join(base_path, rel_path)
    df = pd.read_parquet(full)
    cols = _resolve_columns(df, state_columns)
    arr = df[cols].values[:num_frames].astype(np.float32)
    if arr.shape[0] == 0:
        raise ValueError(f"[StatePlay state] {full} has no state rows.")
    state = torch.from_numpy(arr)
    norm = state_norm_max.to(dtype=state.dtype)
    state = torch.minimum(torch.clamp(state, min=0.0), norm) / norm
    state = state * 2.0 - 1.0
    return state.unsqueeze(0)


class StateAugmentedDataset(torch.utils.data.Dataset):
    """Wrap a StatePlay dataset and append state loaded from the action path."""

    def __init__(
        self,
        base_dataset: torch.utils.data.Dataset,
        metadata_path: str,
        base_path: str,
        num_frames: int,
        state_columns: str,
        state_norm_max: str,
    ):
        self.base_dataset = base_dataset
        self.base_path = base_path
        self.num_frames = num_frames
        self.state_columns = parse_state_columns(state_columns)
        self.state_norm_max = parse_state_norm_max(state_norm_max)
        df = pd.read_csv(metadata_path)
        if "action" not in df.columns:
            raise KeyError(
                "[StatePlay state] metadata must contain an 'action' column "
                "so state can be loaded from the same parquet as actions."
            )
        self.action_paths = df["action"].tolist()

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

    def __getitem__(self, idx: int) -> dict:
        data = self.base_dataset[idx]
        rel_path = self.action_paths[idx % len(self.action_paths)]
        data["state"] = load_state_from_action_parquet(
            rel_path=rel_path,
            base_path=self.base_path,
            num_frames=self.num_frames,
            state_columns=self.state_columns,
            state_norm_max=self.state_norm_max,
        )
        return data

    @property
    def load_from_cache(self) -> bool:
        return getattr(self.base_dataset, "load_from_cache", False)