src/data/fairtalking_dataset.py

"""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 json
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",
)

# Some generator directories use a different casing for the *file-name* suffix
# than the directory name itself (Linux FS is case-sensitive). Only Joyvasa is
# affected today: dir="Joyvasa" but files are named "XXXX_Fake_JoyVASA.mp4".
GEN_FILE_SUFFIX_ALIAS: Dict[str, str] = {
    "Joyvasa": "JoyVASA",
}


def _fake_filename(num: str, gen: str) -> str:
    """Return '<num>_Fake_<suffix>.mp4' where <suffix> honors the alias table."""
    return f"{num}_Fake_{GEN_FILE_SUFFIX_ALIAS.get(gen, gen)}.mp4"

# =============================================================================
# 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 / _fake_filename(num, gen))
        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 / _fake_filename(str(row['_num']), g)
                    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 / _fake_filename(num, gen))

    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 "",
                },
            }

# =============================================================================
# TalkingHeadBench test dataset (fake + optional real)
# =============================================================================

# Mapping of THB real-subset name -> relative directory under <real_root>
# where the .mp4 files can actually be found on disk.
THB_REAL_SUBDIRS: Dict[str, str] = {
    "FaceForensics++": "FaceForensics++/original_sequences/youtube/c23/videos",
    "CelebV-HQ": "CelebV-HQ",
    "VoxCeleb2": "VoxCeleb2",
    "HDTF": "HDTF",
}


class TalkingHeadBenchFakeTestDataset(Dataset):
    """
    Dataset for TalkingHeadBench test videos.

    By default this loads only fake videos from ``<root>/fake/<gen>/test``.
    If ``real_root`` + ``real_split_json`` are also provided, real videos from
    the given ``real_subsets`` (e.g. FaceForensics++) under the ``real_split_name``
    split (default: ``Test``) are added with label=0, so that meaningful AUC
    can be computed.

    Returns per sample:
        video:   (T, 3, H, W) float
        audio:   (S,) float
        label:   int (0 = real, 1 = fake)
        meta:    dict with generator info and basename
    """

    def __init__(
        self,
        root: 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,
        real_root: Optional[str] = None,
        real_split_json: Optional[str] = None,
        real_subsets: Optional[Sequence[str]] = None,
        real_split_name: str = "Test",
        real_audio_cache_dir: Optional[str] = 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.video_transform = video_transform

        # Optional real-video configuration
        self.real_root = Path(real_root) if real_root else None
        self.real_split_json = Path(real_split_json) if real_split_json else None
        self.real_subsets = tuple(real_subsets) if real_subsets else ()
        self.real_split_name = real_split_name
        self.real_audio_cache_dir = (
            Path(real_audio_cache_dir) if real_audio_cache_dir else None
        )

        # Build dataset by scanning fake/test directories (+ optional real)
        self.samples = self._build_samples()

    def _build_samples(self) -> List[Dict[str, Any]]:
        """Scan <root>/fake/<generator>/test/ directories to build the sample list.

        Expected TalkingHeadBench file naming:
            <image_num>--<driving_signal>--<generator>.mp4
        where fields are separated by the literal string "--".

        If real-video configuration is provided, also append real samples
        (label=0) from the requested split / subsets of the THB real dataset.
        """
        samples: List[Dict[str, Any]] = []

        # ---- fake videos --------------------------------------------------
        for generator in self.generators:
            test_dir = self.root / "fake" / generator / "test"

            if not test_dir.exists():
                warnings.warn(f"Test directory not found for {generator}: {test_dir}")
                continue

            mp4_files = sorted(test_dir.glob("*.mp4"))

            for mp4_path in mp4_files:
                basename = mp4_path.stem  # e.g. "00683--xqtbz-pVp2g_1--AniPortraitAudio"

                # Split on the "--" separator used by THB.
                parts = basename.split("--")
                if len(parts) >= 3:
                    num = parts[0]
                    driving = "--".join(parts[1:-1])  # keep middle field intact
                else:
                    # Unexpected format: keep the whole stem as num so we do not silently drop it.
                    num = basename
                    driving = ""

                samples.append({
                    "video_path": str(mp4_path),
                    "audio_path": self.resolver.audio_path(str(mp4_path)),
                    "label": 1,
                    "generator": generator,
                    "basename": basename,
                    "num": num,
                    "driving": driving,
                })

        if not samples:
            warnings.warn(f"No fake test samples found in {self.root}/fake/*/test/")

        # ---- real videos (optional) --------------------------------------
        real_samples = self._build_real_samples()
        samples.extend(real_samples)

        return samples

    def _build_real_samples(self) -> List[Dict[str, Any]]:
        """Load real-video samples from the THB real split JSON if configured."""
        real_samples: List[Dict[str, Any]] = []
        if self.real_root is None or self.real_split_json is None or not self.real_subsets:
            return real_samples

        if not self.real_split_json.exists():
            warnings.warn(f"Real split json not found: {self.real_split_json}")
            return real_samples

        try:
            with open(self.real_split_json, "r") as f:
                split_map = json.load(f)
        except Exception as e:
            warnings.warn(f"Failed to load real split json {self.real_split_json}: {e}")
            return real_samples

        subsets_dict = split_map.get(self.real_split_name, {})
        if not subsets_dict:
            warnings.warn(
                f"Split '{self.real_split_name}' not found in {self.real_split_json}"
            )
            return real_samples

        audio_cache = self.real_audio_cache_dir or (self.real_root / "_audio")

        for subset in self.real_subsets:
            filenames = subsets_dict.get(subset)
            if not filenames:
                warnings.warn(
                    f"Real subset '{subset}' missing in split '{self.real_split_name}'"
                )
                continue

            rel_dir = THB_REAL_SUBDIRS.get(subset, subset)
            subset_dir = self.real_root / rel_dir
            if not subset_dir.exists():
                warnings.warn(f"Real subset dir not found: {subset_dir}")
                continue

            n_found = 0
            for fname in filenames:
                mp4_path = subset_dir / fname
                if not mp4_path.exists():
                    # Silently skip missing files so partial downloads still work.
                    continue
                basename = mp4_path.stem
                audio_path = audio_cache / subset / (basename + ".wav")
                real_samples.append({
                    "video_path": str(mp4_path),
                    "audio_path": str(audio_path),
                    "label": 0,
                    "generator": f"real/{subset}",
                    "basename": basename,
                    "num": basename,
                    "driving": "",
                })
                n_found += 1

            warnings.warn(
                f"[THB real] {subset}: matched {n_found}/{len(filenames)} files under {subset_dir}"
            )

        return real_samples

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

    def _load_sample(self, vpath: str, apath: str) -> Tuple[torch.Tensor, torch.Tensor]:
        """Load video and audio samples."""
        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]:
        sample = self.samples[idx]
        
        try:
            video, audio = self._load_sample(sample["video_path"], sample["audio_path"])
        except Exception as e:
            # robust dataloader: skip broken samples
            warnings.warn(f"skipping bad sample idx={idx} basename={sample['basename']}: {e}")
            # return random other idx
            return self.__getitem__((idx + 1) % len(self))

        return {
            "video": video,
            "audio": audio,
            "label": int(sample.get("label", 1)),
            "meta": {
                "basename": sample["basename"],
                "generator": sample["generator"],
                "num": sample["num"],
                "driving": sample.get("driving", ""),
                "video_path": sample["video_path"],
            },
        }