"""Evaluate trained Stage 1 + Stage 2 checkpoints on configured validation sets."""

import argparse
from pathlib import Path

import torch

from .flowfm.checkpointing import load_state_dict, resolve_stage2_checkpoint
from .flowfm.config import load_config, resolve_subjects
from .flowfm.data_pipeline import make_data_loaders
from .flowfm.model_factory import (
    build_stage1_model,
    build_stage2_models,
    infer_feature_dims,
    infer_target_dim,
)
from .flowfm.stage1 import evaluate_stage1
from .flowfm.stage2 import evaluate_stage2


def build_models(
    cfg,
    sample_batch,
    subjects: list[int],
    checkpoint_dir: Path,
    stage2_ckpt_name: str | None,
    device: torch.device,
):
    """Construct Stage 1/2 models and load checkpoint weights."""
    feat_dims = infer_feature_dims(sample_batch)
    target_dim = infer_target_dim(sample_batch)

    stage1_model = build_stage1_model(
        cfg=cfg,
        feat_dims=feat_dims,
        subjects=subjects,
        device=device,
    )
    stage1_model.load_state_dict(load_state_dict(checkpoint_dir / "stage1_best.pt", device))
    stage1_model.eval()

    stage2_models = build_stage2_models(
        cfg=cfg,
        target_dim=target_dim,
        subjects=subjects,
        device=device,
    )
    stage2_ckpt = resolve_stage2_checkpoint(checkpoint_dir, stage2_ckpt_name)
    stage2_models.load_state_dict(load_state_dict(stage2_ckpt, device))
    stage2_models.eval()

    return stage1_model, stage2_models, stage2_ckpt


def main() -> None:
    parser = argparse.ArgumentParser(description="Evaluate two-stage checkpoints")
    parser.add_argument("--checkpoint-dir", type=str, required=True)
    parser.add_argument("--cfg-path", type=str, default=None)
    parser.add_argument("--stage2-ckpt", type=str, default=None)
    parser.add_argument("--device", type=str, default=None)
    parser.add_argument("--split", action="append", default=None)
    parser.add_argument("--n-timesteps", type=int, default=None)
    args = parser.parse_args()

    checkpoint_dir = Path(args.checkpoint_dir)
    cfg_path = args.cfg_path or str(checkpoint_dir / "config.yaml")

    cfg = load_config(cfg_path)
    if args.device is not None:
        cfg.device = args.device

    device = torch.device(cfg.device)
    subjects = resolve_subjects(cfg)
    n_timesteps = int(args.n_timesteps or cfg.stage2.get("n_timesteps", 25))

    print(f"Checkpoint dir: {checkpoint_dir}")
    print(f"Config: {cfg_path}")
    print(f"Device: {device}")
    print(f"Subjects: {subjects}")

    data_loaders = make_data_loaders(cfg)
    train_loader = data_loaders["train"]
    eval_loaders = {name: loader for name, loader in data_loaders.items() if name != "train"}

    if args.split:
        selected = set(args.split)
        eval_loaders = {name: loader for name, loader in eval_loaders.items() if name in selected}
        missing = selected - set(eval_loaders)
        if missing:
            raise ValueError(f"Requested split(s) not found: {sorted(missing)}")

    sample_batch = next(iter(train_loader))
    stage1_model, stage2_models, stage2_ckpt = build_models(
        cfg=cfg,
        sample_batch=sample_batch,
        subjects=subjects,
        checkpoint_dir=checkpoint_dir,
        stage2_ckpt_name=args.stage2_ckpt,
        device=device,
    )

    print(f"Loaded Stage 1 checkpoint: {checkpoint_dir / 'stage1_best.pt'}")
    print(f"Loaded Stage 2 checkpoint: {stage2_ckpt}")

    for split_name, loader in eval_loaders.items():
        print(f"\n=== Evaluating split: {split_name} ===")

        stage1_acc, _ = evaluate_stage1(
            epoch=0,
            model=stage1_model,
            val_loader=loader,
            device=device,
            subjects=subjects,
            ds_name=split_name,
        )

        stage2_acc, _ = evaluate_stage2(
            epoch=0,
            stage1_model=stage1_model,
            stage2_models=stage2_models,
            val_loader=loader,
            device=device,
            subjects=subjects,
            ds_name=split_name,
            n_timesteps=n_timesteps,
        )

        print(f"Summary [{split_name}] Stage1={stage1_acc:.4f} Stage2={stage2_acc:.4f}")


if __name__ == "__main__":
    main()