import numpy as np
from pathlib import Path
from omegaconf import DictConfig, OmegaConf
from torch.utils.data import DataLoader

from .data import (
    Algonauts2025Dataset,
    load_algonauts2025_friends_fmri,
    load_algonauts2025_movie10_fmri,
    load_sharded_features,
    episode_filter,
)

DEFAULT_DATA_DIR = Path("/raid/lttung05/fmri_encoder/data")
SUBJECTS = (1, 2, 3, 5)
OOD_MOVIES = ["chaplin", "mononoke", "passepartout", "planetearth", "pulpfiction", "wot"]

def pool_features(features: dict[str, np.ndarray]) -> dict[str, np.ndarray]:
    pooled = {}
    for key, feat in features.items():
        assert feat.ndim in {2, 3}
        if feat.ndim == 3:
            feat = feat.mean(axis=1)
        pooled[key] = feat
    return pooled

def load_features(cfg: DictConfig, model: str, layer: str) -> dict[str, np.ndarray]:
    data_dir = Path(cfg.datasets_root or DEFAULT_DATA_DIR)
    friends_features = load_sharded_features(
        data_dir / "features", model=model, layer=layer, series="friends"
    )
    movie10_features = load_sharded_features(
        data_dir / "features", model=model, layer=layer, series="movie10"
    )
    features = {**friends_features, **movie10_features}
    return features

def load_all_features(cfg, datasets_root: Path) -> list[dict[str, np.ndarray]]:
    all_features = []
    for feat_name in cfg.include_features:
        model, layer = feat_name.split("/")
        feat_cfg = cfg.features[model]
        model_name = feat_cfg.model
        layer_name = feat_cfg.layers[layer]
        print(f"  Loading {feat_name} ({model_name}/{layer_name})")

        features_dir = datasets_root / "features"

        # Load friends (all seasons including s7)
        friends_features = load_sharded_features(
            features_dir, model=model_name, layer=layer_name, series="friends"
        )
        # Load ood movies
        ood_features = load_sharded_features(
            features_dir, model=model_name, layer=layer_name, series="ood"
        )
        features = {**friends_features, **ood_features}

        if cfg.stage1.model.global_pool == "avg":
            features = pool_features(features)

        all_features.append(features)

    return all_features

def make_data_loaders(cfg: DictConfig) -> dict[str, DataLoader]:
    print("loading fmri data")

    data_dir = Path(cfg.datasets_root or DEFAULT_DATA_DIR)
    subjects = cfg.get("subjects", SUBJECTS)

    friends_fmri = load_algonauts2025_friends_fmri(
        data_dir / "algonauts_2025.competitors", subjects=subjects
    )
    movie10_fmri = load_algonauts2025_movie10_fmri(
        data_dir / "algonauts_2025.competitors", subjects=subjects
    )
    all_fmri = {**friends_fmri, **movie10_fmri}
    all_episodes = list(all_fmri)

    all_features = []
    for feat_name in cfg.include_features:
        model, layer = feat_name.split("/")
        feat_cfg = cfg.features[model]
        model_name = feat_cfg.model
        layer_name = feat_cfg.layers[layer]
        print(f"loading features {feat_name} ({model_name}/{layer_name})")
        features = load_features(cfg, model_name, layer_name)

        if cfg.stage1.model.global_pool == "avg":
            features = pool_features(features)

        all_features.append(features)

    data_loaders = {}

    for ds_name, ds_cfg in cfg.datasets.items():
        print(f"loading dataset: {ds_name}\n\n{OmegaConf.to_yaml(ds_cfg)}")

        ds_cfg = ds_cfg.copy()
        filter_cfg = ds_cfg.pop("filter")
        filter_fn = episode_filter(**filter_cfg)
        ds_episodes = list(filter(filter_fn, all_episodes))

        dataset = Algonauts2025Dataset(
            episode_list=ds_episodes,
            fmri_data=all_fmri,
            feat_data=all_features,
            **ds_cfg,
        )

        batch_size = cfg.batch_size if ds_name == "train" else 1
        loader = DataLoader(dataset, batch_size=batch_size)

        data_loaders[ds_name] = loader

    return data_loaders

def make_test_loader(cfg, all_features, fmri_num_samples, test_set_name):
    all_episodes = list(all_features[0])

    if test_set_name == "friends-s7":
        filter_fn = episode_filter(seasons=[7], movies=[])
    elif test_set_name == "ood":
        filter_fn = episode_filter(seasons=[], movies=OOD_MOVIES)
    else:
        raise ValueError(f"Unknown test set: {test_set_name}")

    ds_episodes = sorted(filter(filter_fn, all_episodes))
    print(f"  Episodes ({len(ds_episodes)}): {ds_episodes}")

    expected_episodes = set()
    for sub_samples in fmri_num_samples.values():
        expected_episodes.update(sub_samples.keys())

    ds_episodes = [ep for ep in ds_episodes if ep in expected_episodes]

    feature_episodes = set(all_episodes)
    for ep in expected_episodes:
        if ep not in ds_episodes and ep in feature_episodes:
            ds_episodes.append(ep)
    ds_episodes = sorted(ds_episodes)

    episode_num_samples = {}
    for ep in ds_episodes:
        max_samples = max(
            fmri_num_samples[sub].get(ep, 0) for sub in fmri_num_samples
        )
        if max_samples == 0:
            print(f"  Warning: no fmri_num_samples for episode {ep}, skipping")
            continue
        episode_num_samples[ep] = max_samples

    ds_episodes = [ep for ep in ds_episodes if ep in episode_num_samples]

    missing = expected_episodes - set(ds_episodes)
    if missing:
        raise ValueError(
            f"Missing episodes in features: {missing}. "
            f"Cannot produce complete submission."
        )

    dataset = Algonauts2025Dataset(
        episode_list=ds_episodes,
        feat_data=all_features,
        fmri_num_samples=episode_num_samples,
        sample_length=None,
        shuffle=False,
    )

    loader = DataLoader(dataset, batch_size=1)
    return loader