"""
Data loading for grn_dense4.

Uses SparseRawDeltaCache to get dense (B, G_sub, G_sub) delta attention,
then computes per-row statistics [mean, std, max, min] → (B, G_sub, 4)
in the DataLoader worker to minimize CPU→GPU transfer.
"""

import sys
import os

import torch
from torch.utils.data import Dataset

_SCDFM_ROOT = os.path.normpath(
    os.path.join(os.path.dirname(__file__), "..", "..", "..", "..", "transfer", "code", "scDFM")
)

_cached_classes = {}


def get_data_classes():
    """Lazily import scDFM data classes with proper module isolation."""
    if _cached_classes:
        return (
            _cached_classes["Data"],
            _cached_classes["PerturbationDataset"],
            _cached_classes["TrainSampler"],
            _cached_classes["TestDataset"],
        )

    saved = {}
    for key in list(sys.modules.keys()):
        if key == "src" or key.startswith("src."):
            saved[key] = sys.modules.pop(key)

    for d in ["src", "src/data_process", "src/utils", "src/tokenizer"]:
        init_path = os.path.join(_SCDFM_ROOT, d, "__init__.py")
        if not os.path.exists(init_path):
            os.makedirs(os.path.dirname(init_path), exist_ok=True)
            with open(init_path, "w") as f:
                f.write("# Auto-created by CCFM\n")

    sys.path.insert(0, _SCDFM_ROOT)
    try:
        from src.data_process.data import Data, PerturbationDataset, TrainSampler, TestDataset
        _cached_classes["Data"] = Data
        _cached_classes["PerturbationDataset"] = PerturbationDataset
        _cached_classes["TrainSampler"] = TrainSampler
        _cached_classes["TestDataset"] = TestDataset
    finally:
        for key in list(sys.modules.keys()):
            if (key == "src" or key.startswith("src.")) and not key.startswith("scdfm_"):
                del sys.modules[key]
        for key, mod in saved.items():
            sys.modules[key] = mod
        if _SCDFM_ROOT in sys.path:
            sys.path.remove(_SCDFM_ROOT)

    return Data, PerturbationDataset, TrainSampler, TestDataset


class GRNDatasetWrapper(Dataset):
    """
    Wraps scDFM PerturbationDataset to produce per-row statistics from dense delta.

    Worker computes: dense delta (B, G_sub, G_sub) → [mean, std, max, min] → (B, G_sub, 4)
    Only the 4-dim stats are sent to GPU, not the full G_sub×G_sub matrix.
    """

    def __init__(self, base_dataset, sparse_cache, gene_ids_cpu, infer_top_gene):
        self.base = base_dataset
        self.sparse_cache = sparse_cache
        self.gene_ids = gene_ids_cpu
        self.infer_top_gene = infer_top_gene

    def __len__(self):
        return len(self.base)

    def __getitem__(self, idx):
        batch = self.base[idx]

        # 1. Random gene subset
        G_full = batch["src_cell_data"].shape[-1]
        input_gene_ids = torch.randperm(G_full)[:self.infer_top_gene]

        # 2. Dense delta from sparse cache (in worker process)
        src_names = batch["src_cell_id"]
        tgt_names = batch["tgt_cell_id"]
        if src_names and isinstance(src_names[0], (tuple, list)):
            src_names = [n[0] for n in src_names]
            tgt_names = [n[0] for n in tgt_names]
        z_dense = self.sparse_cache.lookup_delta(
            src_names, tgt_names, input_gene_ids, device=torch.device("cpu")
        )  # (B, G_sub, G_sub)

        # 3. Per-row statistics: (B, G_sub, G_sub) → (B, G_sub, 4)
        z_stats = torch.stack([
            z_dense.mean(dim=-1),              # mean of each gene's attention changes
            z_dense.std(dim=-1),               # spread of attention changes
            z_dense.max(dim=-1).values,        # strongest positive change
            z_dense.min(dim=-1).values,        # strongest negative change
        ], dim=-1)  # (B, G_sub, 4)

        # 4. Subset expression data
        return {
            "src_cell_data": batch["src_cell_data"][:, input_gene_ids],
            "tgt_cell_data": batch["tgt_cell_data"][:, input_gene_ids],
            "condition_id": batch["condition_id"],
            "z_stats": z_stats,                                            # (B, G_sub, 4)
            "gene_ids_sub": self.gene_ids[input_gene_ids],
            "input_gene_ids": input_gene_ids,
        }