"""LightningDataModule for FairTalking-Bench."""
from __future__ import annotations

from typing import Any, Dict, Optional

import pytorch_lightning as pl
import torch
from torch.utils.data import ConcatDataset, DataLoader

from .fairtalking_dataset import FairTalkingBenchDataset, HDTFIdPairedDataset, TalkingHeadBenchFakeTestDataset
from .ffpp_dataset import FFPPTestDataset
from .hdtf_paired_dataset import HDTFPairedTestDataset
from .hdtf_paired_train_dataset import HDTFPairedTrainDataset
from .mmdf_dataset import MMDFTestDataset
from .transforms import build_video_transform


def _collate_drop_none(batch):
    """Custom collate that:

      1. Drops `None` items (datasets return None for irretrievable samples).
      2. Only collates a key if EVERY item in the surviving batch has it.
         This matters for optional cross-generator companion fields
         (`alt_video` / `alt_audio` / `meta.alt_generator`) which datasets
         attach only to *some* samples (fakes that found a paired alt).
         CTA's training_step already gates on `"alt_video" in batch`, so
         dropping the key when even one sample lacks it is safe and matches
         the existing contract.

    Without this guard, batches that contain a mix of "with-alt" and
    "without-alt" samples (e.g. when concatenating ours+HDTF train data)
    raise `KeyError: 'alt_video'` inside torch.stack — exactly the failure
    you saw at training step 0.
    """
    batch = [b for b in batch if b is not None]
    if not batch:
        return None
    # Use the intersection of keys across the whole batch, not just batch[0].
    common_keys = set(batch[0].keys())
    for b in batch[1:]:
        common_keys &= set(b.keys())

    out: Dict[str, Any] = {}
    for k in common_keys:
        if k == "meta":
            out[k] = [b[k] for b in batch]
        elif isinstance(batch[0][k], torch.Tensor):
            out[k] = torch.stack([b[k] for b in batch], dim=0)
        elif isinstance(batch[0][k], (int, float)):
            out[k] = torch.tensor([b[k] for b in batch])
        else:
            out[k] = [b[k] for b in batch]
    return out


class FairTalkingDataModule(pl.LightningDataModule):
    def __init__(self, data_cfg, aug_cfg_train=None, aug_cfg_eval=None, return_paired: bool = False):
        super().__init__()
        self.cfg = data_cfg
        self.train_transform = build_video_transform(aug_cfg_train or data_cfg.aug, training=True)
        self.eval_transform = build_video_transform(aug_cfg_eval or data_cfg.aug, training=False)
        self.return_paired = return_paired

    # ------------------------------------------------------------------
    def _make_main(self, csv_name: str, training: bool, expand_fakes: str = "random"):
        return FairTalkingBenchDataset(
            root=self.cfg.root,
            split_csv=csv_name,
            audio_cache_dir=self.cfg.audio_cache_dir,
            generators=list(self.cfg.generators),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            video_transform=self.train_transform if training else self.eval_transform,
            return_paired=self.return_paired and training,
            expand_fakes=expand_fakes,
        )

    def _make_extra_hdtf_train(self):
        """Build the supplementary HDTF-paired training dataset.

        Activated when `cfg.extra_train_hdtf_paired` is true. Returns a
        Dataset that yields the SAME sample dict shape as
        FairTalkingBenchDataset, so the two can be ConcatDataset-merged
        into one training loader without changing collate logic.
        """
        # Generators available under <root>/<gen>/. Defaults match the 7
        # generators present in /apdcephfs_gy5/.../HDTF-paird (no SadTalk).
        gens = getattr(self.cfg, "extra_train_hdtf_generators", None)
        if gens is None:
            gens = ("AniPortrait", "Ditto", "EDTalk", "Float", "Hallo", "Joyvasa", "Sonic")
        return HDTFPairedTrainDataset(
            root=self.cfg.extra_train_hdtf_root,
            generators=list(gens),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            audio_cache_dir=getattr(self.cfg, "extra_train_hdtf_audio_cache_dir", None),
            video_transform=self.train_transform,
            return_paired=self.return_paired,
            include_real=bool(getattr(self.cfg, "extra_train_hdtf_include_real", True)),
            real_subdir=getattr(self.cfg, "extra_train_hdtf_real_subdir", "Real"),
        )

    def _make_thb_fake_test(self):
        """Create TalkingHeadBench test dataset (fake + optional real)."""
        # THB uses a different set of generator directory names than FairTalking.
        # Prefer cfg.thb_generators when provided; otherwise fall back to cfg.generators.
        gens = getattr(self.cfg, "thb_generators", None) or self.cfg.generators

        # Optional THB real-video config. When provided, real videos from the
        # requested split+subsets are added (label=0), enabling test/auc.
        real_subsets = getattr(self.cfg, "thb_real_subsets", None)
        real_subsets = list(real_subsets) if real_subsets else None

        return TalkingHeadBenchFakeTestDataset(
            root=self.cfg.thb_root if hasattr(self.cfg, 'thb_root') else self.cfg.root,
            audio_cache_dir=self.cfg.thb_audio_cache_dir if hasattr(self.cfg, 'thb_audio_cache_dir') else self.cfg.audio_cache_dir,
            generators=list(gens),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            video_transform=self.eval_transform,
            real_root=getattr(self.cfg, "thb_real_root", None),
            real_split_json=getattr(self.cfg, "thb_real_split_json", None),
            real_subsets=real_subsets,
            real_split_name=getattr(self.cfg, "thb_real_split_name", "Test"),
            real_audio_cache_dir=getattr(self.cfg, "thb_real_audio_cache_dir", None),
        )

    def _make_ffpp_test(self):
        """Create standalone FaceForensics++ test dataset."""
        gens = getattr(self.cfg, "ffpp_generators", None) or self.cfg.generators
        return FFPPTestDataset(
            root=self.cfg.root,
            generators=list(gens),
            compression=getattr(self.cfg, "ffpp_compression", "c23"),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            include_real=bool(getattr(self.cfg, "ffpp_include_real", True)),
            real_rel_dir=getattr(self.cfg, "ffpp_real_rel_dir", None),
            real_root=getattr(self.cfg, "ffpp_real_root", None),
            max_fake_per_generator=getattr(self.cfg, "ffpp_max_fake_per_generator", None),
            max_real=getattr(self.cfg, "ffpp_max_real", None),
            audio_cache_dir=getattr(self.cfg, "audio_cache_dir", None),
            video_transform=self.eval_transform,
        )

    def _make_hdtf_paired_test(self):
        """Create standalone HDTF-paired test dataset."""
        gens = getattr(self.cfg, "hdtf_paired_generators", None) or self.cfg.generators
        root = getattr(self.cfg, "hdtf_paired_root", self.cfg.root)
        return HDTFPairedTestDataset(
            root=root,
            generators=list(gens),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            include_real=bool(getattr(self.cfg, "hdtf_paired_include_real", True)),
            real_dir=getattr(self.cfg, "hdtf_paired_real_dir", None),
            audio_cache_dir=getattr(self.cfg, "hdtf_paired_audio_cache_dir", None),
            video_transform=self.eval_transform,
        )

    def _make_mmdf_test(self):
        """Create standalone MMDF test dataset.

        Reads:
          <mmdf_root>/test/fake/<gen>/*.mp4    (label=1)
          <mmdf_root>/test/real/<gen>/*.mp4    (label=0, paired by basename)
        Real path is hard-coded relative to mmdf_root inside MMDFTestDataset
        — yaml does not need to (and cannot) override it.
        """
        gens = getattr(self.cfg, "mmdf_generators", None) or ("aniportrait", "hunyuan", "megactor-s")
        return MMDFTestDataset(
            root=getattr(self.cfg, "mmdf_root", self.cfg.root),
            generators=list(gens),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            include_real=bool(getattr(self.cfg, "mmdf_include_real", True)),
            audio_cache_dir=getattr(self.cfg, "mmdf_audio_cache_dir", None),
            max_fake_per_generator=getattr(self.cfg, "mmdf_max_fake_per_generator", None),
            max_real_per_generator=getattr(self.cfg, "mmdf_max_real_per_generator", None),
            video_transform=self.eval_transform,
        )

    def _make_mmdf_test(self):
        """Create standalone MMDF test dataset.

        Reads:
          <mmdf_root>/test/fake/<gen>/*.mp4    (label=1)
          <mmdf_root>/test/real/<gen>/*.mp4    (label=0, paired by basename)
        Real path is hard-coded relative to mmdf_root inside MMDFTestDataset
        — yaml does not need to (and cannot) override it.
        """
        gens = getattr(self.cfg, "mmdf_generators", None) or ("aniportrait", "hunyuan", "megactor-s")
        return MMDFTestDataset(
            root=getattr(self.cfg, "mmdf_root", self.cfg.root),
            generators=list(gens),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            include_real=bool(getattr(self.cfg, "mmdf_include_real", True)),
            audio_cache_dir=getattr(self.cfg, "mmdf_audio_cache_dir", None),
            max_fake_per_generator=getattr(self.cfg, "mmdf_max_fake_per_generator", None),
            max_real_per_generator=getattr(self.cfg, "mmdf_max_real_per_generator", None),
            video_transform=self.eval_transform,
        )

    def _is_test_only_cfg(self) -> bool:
        """Return True when this data config is a pure test set (no train/val)."""
        return (
            bool(getattr(self.cfg, "use_ffpp_test", False))
            or bool(getattr(self.cfg, "use_hdtf_paired_test", False))
            or bool(getattr(self.cfg, "use_mmdf_test", False))
            or getattr(self.cfg, "train_csv", None) in (None, "null")
        )

    def setup(self, stage: Optional[str] = None):
        if stage in (None, "fit") and not self._is_test_only_cfg():
            base_train = self._make_main(self.cfg.train_csv, training=True)
            # Optional supplementary training data merged via ConcatDataset.
            # Only HDTF-paired is wired here today; add more branches as needed.
            extras = []
            if bool(getattr(self.cfg, "extra_train_hdtf_paired", False)):
                extras.append(self._make_extra_hdtf_train())
            if extras:
                self.train_ds = ConcatDataset([base_train] + extras)
                # Friendly summary on rank 0.
                try:
                    sizes = ", ".join(
                        f"{type(d).__name__}={len(d)}" for d in [base_train] + extras
                    )
                    print(f"[datamodule] train ConcatDataset sizes: {sizes}; total={len(self.train_ds)}")
                except Exception:
                    pass
            else:
                self.train_ds = base_train
            # Val intentionally NOT touched — always uses the base val.csv.
            self.val_ds = self._make_main(self.cfg.val_csv, training=False, expand_fakes="random")
        if stage in (None, "test"):
            # Standalone FF++ test set
            if getattr(self.cfg, "use_ffpp_test", False):
                self.test_ds = self._make_ffpp_test()
            # Standalone HDTF-paired test set
            elif getattr(self.cfg, "use_hdtf_paired_test", False):
                self.test_ds = self._make_hdtf_paired_test()
            # Standalone MMDF test set
            elif getattr(self.cfg, "use_mmdf_test", False):
                self.test_ds = self._make_mmdf_test()
            # TalkingHeadBench fake test set
            elif getattr(self.cfg, "use_thb_test", False):
                self.test_ds = self._make_thb_fake_test()
            else:
                self.test_ds = self._make_main(self.cfg.test_csv, training=False, expand_fakes="all")

    # ------------------------------------------------------------------
    def _loader(self, ds, shuffle: bool):
        nw = int(self.cfg.num_workers)
        kwargs = dict(
            batch_size=self.cfg.batch_size,
            shuffle=shuffle,
            num_workers=nw,
            pin_memory=self.cfg.pin_memory,
            collate_fn=_collate_drop_none,
            drop_last=shuffle,
        )
        if nw > 0:
            kwargs["persistent_workers"] = self.cfg.persistent_workers
            kwargs["prefetch_factor"] = self.cfg.prefetch_factor
        return DataLoader(ds, **kwargs)

    def train_dataloader(self): return self._loader(self.train_ds, shuffle=True)
    def val_dataloader(self):   return self._loader(self.val_ds,   shuffle=False)
    def test_dataloader(self):  return self._loader(self.test_ds,  shuffle=False)

    def thb_fake_test_loader(self):
        """Build a DataLoader specifically for TalkingHeadBench fake test set."""
        ds = self._make_thb_fake_test()
        return self._loader(ds, shuffle=False)

    # ------------------------------------------------------------------
    def hdtf_loader(self, subset: str, mode: str = "pair"):
        """Build a DataLoader for Protocol 4 (HDTF id-paired)."""
        csv_map = {
            "A": self.cfg.hdtf_subset_a_csv,
            "B": self.cfg.hdtf_subset_b_csv,
            "C": self.cfg.hdtf_subset_c_csv,
        }
        ds = HDTFIdPairedDataset(
            root=self.cfg.root,
            subset_csv=csv_map[subset],
            audio_cache_dir=self.cfg.audio_cache_dir,
            generators=list(self.cfg.generators),
            num_frames=self.cfg.num_frames,
            frame_stride=self.cfg.frame_stride,
            frame_size=self.cfg.frame_size,
            audio_seconds=self.cfg.audio_seconds,
            audio_sample_rate=self.cfg.audio_sample_rate,
            mode=mode,
            video_transform=self.eval_transform,
        )
        return DataLoader(
            ds,
            batch_size=1 if mode == "tuple" else self.cfg.batch_size,
            shuffle=False,
            num_workers=int(self.cfg.num_workers),
            pin_memory=self.cfg.pin_memory,
            collate_fn=_collate_drop_none,
        )