"""FairTalking-Bench dataset classes.

File layout assumed:
    <root>/Real/<basename>_Real_<source>.mp4
    <root>/<Generator>/<basename_num>_Fake_<Generator>.mp4       (e.g. Float/0001_Fake_Float.mp4)
    <root>/{train,val,test}.csv    with columns:
        basename, Label, gender, race4, age_group,
        duration_range, duration_seconds, source, basename_old

    where `basename` is like "0022_Fake" or "0852_Real" (no extension, no source suffix).

Key notes (from user):
  * Real and Fake identities are DIFFERENT in the main benchmark.
  * Within the 8 generator dirs, the same numeric prefix (e.g. "0000")
    shares the same reference image and driving audio across all 8 generators.
  * Audio is embedded in the mp4; we extract wavs once into <root>/_audio/
    via scripts/prepare_audio.sh for fast loading.
"""
from __future__ import annotations

import os
import random
import warnings
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple

import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset

# --- video reading -----------------------------------------------------------
try:
    import decord
    decord.bridge.set_bridge("torch")
    _HAS_DECORD = True
except Exception:  # pragma: no cover
    _HAS_DECORD = False

import soundfile as sf


GENERATORS = (
    "AniPortrait", "Ditto", "EDTalk", "Float",
    "Hallo", "Joyvasa", "SadTalk", "Sonic",
)


# =============================================================================
# helpers
# =============================================================================

def _load_video_clip_decord(
    path: str, num_frames: int, stride: int, frame_size: int,
) -> torch.Tensor:
    """Return (T, 3, H, W) float in [0,1]. Uniformly random-offset clip."""
    vr = decord.VideoReader(path, width=frame_size, height=frame_size)
    total = len(vr)
    span = (num_frames - 1) * stride + 1
    if total < span:
        # not enough frames: repeat-pad
        idx = np.arange(num_frames) * stride
        idx = np.clip(idx, 0, total - 1)
    else:
        start = random.randint(0, total - span)
        idx = start + np.arange(num_frames) * stride
    frames = vr.get_batch(idx.tolist())          # (T, H, W, 3) uint8 torch
    frames = frames.float().permute(0, 3, 1, 2) / 255.0
    return frames


def _load_video_clip_pyav(
    path: str, num_frames: int, stride: int, frame_size: int,
) -> torch.Tensor:
    import av
    container = av.open(path)
    stream = container.streams.video[0]
    stream.codec_context.skip_frame = "NONKEY"
    frames = []
    for i, frame in enumerate(container.decode(video=0)):
        img = frame.to_ndarray(format="rgb24")
        frames.append(img)
    container.close()
    if not frames:
        raise RuntimeError(f"no frames decoded for {path}")
    arr = np.stack(frames)
    total = len(arr)
    span = (num_frames - 1) * stride + 1
    if total < span:
        idx = np.arange(num_frames) * stride
        idx = np.clip(idx, 0, total - 1)
    else:
        start = random.randint(0, total - span)
        idx = start + np.arange(num_frames) * stride
    arr = arr[idx]
    import cv2
    resized = np.stack([cv2.resize(f, (frame_size, frame_size)) for f in arr])
    t = torch.from_numpy(resized).float().permute(0, 3, 1, 2) / 255.0
    return t


def load_video_clip(
    path: str, num_frames: int, stride: int, frame_size: int,
) -> torch.Tensor:
    if _HAS_DECORD:
        try:
            return _load_video_clip_decord(path, num_frames, stride, frame_size)
        except Exception as e:  # pragma: no cover
            warnings.warn(f"decord failed on {path}: {e}; falling back to pyav")
    return _load_video_clip_pyav(path, num_frames, stride, frame_size)


def load_audio_clip(
    wav_path: str, seconds: float, sample_rate: int,
) -> torch.Tensor:
    """Return (num_samples,) float32. Uniform random crop."""
    wav, sr = sf.read(wav_path, dtype="float32", always_2d=False)
    if wav.ndim > 1:
        wav = wav.mean(axis=1)
    if sr != sample_rate:
        # lightweight resample
        import librosa
        wav = librosa.resample(wav, orig_sr=sr, target_sr=sample_rate)
    target = int(seconds * sample_rate)
    if len(wav) < target:
        pad = target - len(wav)
        wav = np.pad(wav, (0, pad), mode="constant")
    else:
        start = random.randint(0, len(wav) - target)
        wav = wav[start:start + target]
    return torch.from_numpy(wav.copy())


# =============================================================================
# path resolution
# =============================================================================

@dataclass
class FileResolver:
    """Turns a csv row into video / audio paths."""
    root: Path
    audio_cache_dir: Path

    def video_path(self, row: pd.Series) -> str:
        basename: str = row["basename"]           # "0022_Fake" or "0852_Real"
        num, kind = basename.split("_", 1)
        if kind.lower() == "real":
            # real files carry source suffix we do not know, so glob
            candidates = list((self.root / "Real").glob(f"{num}_Real_*.mp4"))
            if not candidates:
                raise FileNotFoundError(f"no real video for {basename}")
            return str(candidates[0])
        elif kind.lower() == "fake":
            # fake: need a generator. csv doesn't encode it, so caller must.
            # We store generator on the row dict if iterating generators.
            gen = row.get("generator") or row.get("_generator")
            if gen is None:
                raise ValueError(
                    "fake row must carry a 'generator' column for path resolution"
                )
            return str(self.root / gen / f"{num}_Fake_{gen}.mp4")
        else:
            raise ValueError(f"unknown label kind in basename: {basename}")

    def audio_path(self, video_path: str) -> str:
        vp = Path(video_path)
        # mirror the tree inside audio_cache_dir
        rel = vp.relative_to(self.root)
        return str(self.audio_cache_dir / rel.with_suffix(".wav"))


# =============================================================================
# main dataset (FairTalking-Bench balanced main split)
# =============================================================================

class FairTalkingBenchDataset(Dataset):
    """
    Returns per sample:
        video:   (T, 3, H, W) float
        audio:   (S,) float
        label:   int in {0=real, 1=fake}
        meta:    dict with demographic info + generator + basename
    """

    def __init__(
        self,
        root: str,
        split_csv: str,
        audio_cache_dir: str,
        generators: Sequence[str] = GENERATORS,
        num_frames: int = 16,
        frame_stride: int = 2,
        frame_size: int = 224,
        audio_seconds: float = 2.56,
        audio_sample_rate: int = 16000,
        video_transform: Optional[Callable] = None,
        return_paired: bool = False,
        expand_fakes: str = "random",   # "random": pick 1 generator per fake row
                                         # "all":    explode into 8 rows (for eval)
    ) -> None:
        super().__init__()
        self.root = Path(root)
        self.resolver = FileResolver(
            root=self.root,
            audio_cache_dir=Path(audio_cache_dir),
        )
        self.generators = tuple(generators)
        self.num_frames = num_frames
        self.frame_stride = frame_stride
        self.frame_size = frame_size
        self.audio_seconds = audio_seconds
        self.audio_sample_rate = audio_sample_rate
        self.video_transform = video_transform
        self.return_paired = return_paired
        self.expand_fakes = expand_fakes

        df = pd.read_csv(self.root / split_csv)
        df = df[df["basename"].notna()].copy()
        df["_num"] = df["basename"].str.extract(r"^(\d+)_")[0]
        df["_kind"] = df["basename"].str.extract(r"_(Real|Fake)$")[0]

        if expand_fakes == "all":
            # explode each fake row into 8 generator copies
            reals = df[df["_kind"] == "Real"].copy()
            reals["_generator"] = None
            fakes = df[df["_kind"] == "Fake"]
            expanded = []
            for g in self.generators:
                tmp = fakes.copy()
                tmp["_generator"] = g
                expanded.append(tmp)
            df = pd.concat([reals] + expanded, ignore_index=True)

        self.df = df.reset_index(drop=True)

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

    def _resolve_row(self, row: pd.Series) -> Tuple[str, str]:
        row = row.copy()
        if row["_kind"] == "Fake":
            gen = row["_generator"] if "_generator" in row.index else None
            if gen is None:
                # try generators in random order, pick the first whose file exists
                cand = list(self.generators)
                random.shuffle(cand)
                for g in cand:
                    p = self.root / g / f"{row['_num']}_Fake_{g}.mp4"
                    if p.exists():
                        gen = g
                        break
                if gen is None:
                    raise FileNotFoundError(
                        f"no fake file found for basename={row['basename']} among any generator"
                    )
            row["_generator"] = gen
            row["generator"] = gen
        # Real rows: no generator, FileResolver handles that branch directly.
        vpath = self.resolver.video_path(row)
        apath = self.resolver.audio_path(vpath)
        return vpath, apath

    def _load_sample(self, vpath: str, apath: str) -> Tuple[torch.Tensor, torch.Tensor]:
        video = load_video_clip(
            vpath, self.num_frames, self.frame_stride, self.frame_size,
        )
        if self.video_transform is not None:
            video = self.video_transform(video)
        if os.path.exists(apath):
            audio = load_audio_clip(
                apath, self.audio_seconds, self.audio_sample_rate,
            )
        else:
            # silent fallback if audio extraction wasn't done yet
            warnings.warn(f"missing audio cache: {apath}; returning silence")
            audio = torch.zeros(int(self.audio_seconds * self.audio_sample_rate))
        return video, audio

    # ------------------------------------------------------------------
    def __getitem__(self, idx: int) -> Dict[str, Any]:
        row = self.df.iloc[idx]
        try:
            vpath, apath = self._resolve_row(row)
            video, audio = self._load_sample(vpath, apath)
        except Exception as e:
            # robust dataloader: skip broken samples
            warnings.warn(f"skipping bad sample idx={idx} basename={row['basename']}: {e}")
            # return random other idx
            return self.__getitem__((idx + 1) % len(self))

        label = int(row["Label"])

        gen_val = ""
        if row["_kind"] == "Fake" and "_generator" in row.index:
            gen_val = row["_generator"] or ""

        sample: Dict[str, Any] = {
            "video": video,
            "audio": audio,
            "label": label,
            "meta": {
                "basename": str(row["basename"]),
                "generator": str(gen_val),
                "gender": str(row.get("gender") or ""),
                "race4": str(row.get("race4") or ""),
                "age_group": str(row.get("age_group") or ""),
                "source": str(row.get("source") or ""),
                "num": str(row.get("_num") or ""),
            },
        }

        # --- optional: cross-generator paired companion (for CTA aux loss) ----
        if self.return_paired and row["_kind"] == "Fake" and gen_val:
            other_gens = [g for g in self.generators if g != gen_val]
            other = random.choice(other_gens)
            alt_row = row.copy()
            alt_row["_generator"] = other
            alt_row["generator"] = other
            try:
                avpath = self.resolver.video_path(alt_row)
                aapath = self.resolver.audio_path(avpath)
                alt_video, alt_audio = self._load_sample(avpath, aapath)
                sample["alt_video"] = alt_video
                sample["alt_audio"] = alt_audio
                sample["meta"]["alt_generator"] = other
            except Exception:
                pass

        return sample


# =============================================================================
# HDTF identity-paired subsets (Protocol 4)
# =============================================================================

class HDTFIdPairedDataset(Dataset):
    """
    Reads a csv produced by scripts/prepare_hdtf_splits.py. Expected columns:
        basename_num, identity_id, subset  (A|B|C)

    For each identity_id we build a tuple:
        { 'real': path_to_real_mp4,
          'fakes': { g: path_to_g_fake_mp4 for g in generators } }

    __getitem__ returns either a (real, fake) pair [sampled generator] or
    the full 9-tuple depending on mode.
    """

    def __init__(
        self,
        root: str,
        subset_csv: str,
        audio_cache_dir: str,
        generators: Sequence[str] = GENERATORS,
        num_frames: int = 16,
        frame_stride: int = 2,
        frame_size: int = 224,
        audio_seconds: float = 2.56,
        audio_sample_rate: int = 16000,
        mode: str = "pair",               # "pair" | "tuple"
        video_transform: Optional[Callable] = None,
    ) -> None:
        super().__init__()
        self.root = Path(root)
        self.resolver = FileResolver(
            root=self.root,
            audio_cache_dir=Path(audio_cache_dir),
        )
        self.generators = tuple(generators)
        self.num_frames = num_frames
        self.frame_stride = frame_stride
        self.frame_size = frame_size
        self.audio_seconds = audio_seconds
        self.audio_sample_rate = audio_sample_rate
        self.mode = mode
        self.video_transform = video_transform

        self.df = pd.read_csv(self.root / subset_csv)
        # Each row is one identity with its real basename_num.
        # fakes share the same basename_num across generators.

    def __len__(self) -> int:
        return len(self.df) if self.mode == "tuple" else len(self.df) * len(self.generators)

    def _load(self, path: str) -> Tuple[torch.Tensor, torch.Tensor]:
        video = load_video_clip(path, self.num_frames, self.frame_stride, self.frame_size)
        if self.video_transform is not None:
            video = self.video_transform(video)
        apath = self.resolver.audio_path(path)
        if os.path.exists(apath):
            audio = load_audio_clip(apath, self.audio_seconds, self.audio_sample_rate)
        else:
            audio = torch.zeros(int(self.audio_seconds * self.audio_sample_rate))
        return video, audio

    def _real_path(self, row: pd.Series) -> str:
        num = str(row["basename_num"]).zfill(4)
        candidates = list((self.root / "Real").glob(f"{num}_Real_*.mp4"))
        if not candidates:
            raise FileNotFoundError(f"missing real for id={row.get('identity_id')} num={num}")
        return str(candidates[0])

    def _fake_path(self, row: pd.Series, gen: str) -> str:
        num = str(row["basename_num"]).zfill(4)
        return str(self.root / gen / f"{num}_Fake_{gen}.mp4")

    def __getitem__(self, idx: int) -> Dict[str, Any]:
        if self.mode == "tuple":
            row = self.df.iloc[idx]
            real_v, real_a = self._load(self._real_path(row))
            fakes_v, fakes_a, gens = [], [], []
            for g in self.generators:
                fp = self._fake_path(row, g)
                try:
                    v, a = self._load(fp)
                    fakes_v.append(v); fakes_a.append(a); gens.append(g)
                except Exception as e:
                    warnings.warn(f"missing {fp}: {e}")
            return {
                "real_video": real_v,
                "real_audio": real_a,
                "fake_videos": torch.stack(fakes_v),
                "fake_audios": torch.stack(fakes_a),
                "generators": gens,
                "identity_id": str(row.get("identity_id", "")),
                "subset": str(row.get("subset", "")),
            }
        else:  # pair mode
            row_idx = idx // len(self.generators)
            gen_idx = idx % len(self.generators)
            row = self.df.iloc[row_idx]
            gen = self.generators[gen_idx]
            # alternate real/fake within a batch: even idx real, odd idx fake
            if idx % 2 == 0:
                vpath = self._real_path(row); label = 0
            else:
                vpath = self._fake_path(row, gen); label = 1
            v, a = self._load(vpath)
            return {
                "video": v, "audio": a, "label": label,
                "meta": {
                    "identity_id": str(row.get("identity_id", "")),
                    "subset": str(row.get("subset", "")),
                    "generator": gen if label == 1 else "",
                },
            }