"""
Training script for 2-stage fMRI encoding with Flow Matching.
Stage 1: Train MultiSubjectConvLinearEncoder (Mean Anchor)
Stage 2: Train Conditional Flow Matching (Neural Vector Field) per subject.
"""

import argparse
import sys
from pathlib import Path
from typing import Dict, Any, Optional

import numpy as np
import torch
import torch.nn as nn
from omegaconf import DictConfig, OmegaConf
from timm.utils import random_seed

from .visualize import plot_loss_curve
from .data import (
    Algonauts2025Dataset,
    load_algonauts2025_friends_fmri,
    load_algonauts2025_movie10_fmri,
    load_sharded_features,
    episode_filter,
)
from .stage1.medarc_architecture import MultiSubjectConvLinearEncoder
from .stage2.CFM import CFM
from .metric import pearsonr_score

from .loaders import SUBJECTS, make_data_loaders, load_all_features
from .loops import train_one_epoch_jointly
from .evaluate import evaluate_stage1, evaluate_stage2

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--cfg-path", type=str, default="config.yml")
    args = parser.parse_args()

    cfg = OmegaConf.load(args.cfg_path)
    print("Config loaded:\n", OmegaConf.to_yaml(cfg))

    out_dir = Path(cfg.out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    OmegaConf.save(cfg, out_dir / "config.yaml")

    random_seed(cfg.seed)
    device = torch.device(cfg.device)

    data_loaders = make_data_loaders(cfg)
    train_loader = data_loaders["train"]
    val_loaders = data_loaders.copy()
    val_loaders.pop("train")

    print("Creating Stage 1 Model (Encoder)...")

    sample_batch = next(iter(train_loader))
    feat_dims = [f.shape[-1] for f in sample_batch["features"]]
    print(feat_dims)

    subjects_list = cfg.get("subjects", SUBJECTS)

    stage1_model = MultiSubjectConvLinearEncoder(
        num_subjects=len(subjects_list),
        feat_dims=feat_dims,
        **cfg.stage1.model,
    ).to(device)

    optimizer1 = torch.optim.AdamW(
        stage1_model.parameters(),
        lr=cfg.stage1.lr,
        weight_decay=cfg.stage1.weight_decay,
    )

    print("Creating Stage 2 Models (Flow Matching)...")
    stage2_models = nn.ModuleDict()
    optimizers2 = {}

    target_dim = sample_batch["fmri"].shape[-1]

    cfm_params = cfg.stage2.cfm
    decoder_params = cfg.stage2.decoder

    for sub in subjects_list:
        sub_key = str(sub)
        cfm_model = CFM(
            feat_dim=target_dim,
            cfm_params=cfm_params,
            decoder_params=decoder_params,
            embed_dim=cfg.stage1.model.embed_dim,
        ).to(device)

        stage2_models[sub_key] = cfm_model
        optimizers2[sub_key] = torch.optim.AdamW(
            cfm_model.parameters(),
            lr=cfg.stage2.lr,
            weight_decay=cfg.stage2.weight_decay,
        )

    print("--- Starting Joint Training (Stage 1 & Stage 2) ---")
    best_score_s1 = -1.0
    joint_train_losses = []
    joint_val_accs = []

    for epoch in range(cfg.epochs):
        train_loss = train_one_epoch_jointly(
            epoch=epoch,
            stage1_model=stage1_model,
            stage2_models=stage2_models,
            train_loader=train_loader,
            stage1_optimizer=optimizer1,
            stage2_optimizers=optimizers2,
            device=device,
            subjects=subjects_list,
        )
        joint_train_losses.append(train_loss)

        val_acc = None
        for name, loader in val_loaders.items():
            acc, _ = evaluate_stage1(
                epoch=epoch,
                model=stage1_model,
                val_loader=loader,
                device=device,
                subjects=subjects_list,
                ds_name=name,
            )
            if name == cfg.val_set_name:
                val_acc = acc

        joint_val_accs.append(val_acc if val_acc is not None else 0.0)

        if val_acc is not None and val_acc > best_score_s1:
            best_score_s1 = val_acc
            torch.save(stage1_model.state_dict(), out_dir / "stage1_best.pt")
            print("Saved best Stage 1 model.")

        if epoch % 5 == 0 or epoch == cfg.epochs - 1:
            ckpt_path = out_dir / f"stage2_epoch_{epoch}.pt"
            torch.save(stage2_models.state_dict(), ckpt_path)
            print(f"Saved Stage 2 checkpoint to {ckpt_path}")

    plot_loss_curve(
        joint_train_losses,
        joint_val_accs,
        out_dir,
        filename="joint_loss_curve.png",
        prefix="Joint",
    )

    print(f"Joint Training Complete. Best model at Pearson's r {best_score_s1}")

    stage1_model.load_state_dict(torch.load(out_dir / "stage1_best.pt"))
    stage1_model.eval()

    print("Evaluating final Stage 2 model...")
    for name, loader in val_loaders.items():
        evaluate_stage2(
            epoch=cfg.epochs,
            stage1_model=stage1_model,
            stage2_models=stage2_models,
            val_loader=loader,
            device=device,
            subjects=subjects_list,
            ds_name=name,
            n_timesteps=cfg.stage2.get("n_timesteps", 25),
        )

    print("Done! All training complete.")

if __name__ == "__main__":
    main()