"""Validate every model config actually builds + runs a forward pass at IMG_SIZE=128
with ImageNet weights -- for BOTH strategy 2 (plain SMP) and strategy 3 (refinement stack).

Run this on the GPU box BEFORE launching the full matrix:
    python validate_models.py

For each model it reports:
  * whether strategy 2 builds/forwards (and at which encoder_depth: tries 5, falls back to 4)
  * the encoder's out_channels (what the strategy-3 projection consumes)
  * whether strategy 3 (PixelDRLMG_WithDecoder) builds/forwards
Anything marked FAIL must be fixed (or the model swapped) before you burn compute.
"""
from __future__ import annotations

import importlib.util
import json
import pathlib
import sys
import traceback

import torch
import segmentation_models_pytorch as smp

REPO = pathlib.Path(__file__).resolve().parent
IMG = 128
BATCH = 2
MANIFEST = json.loads((REPO / "params" / "models_manifest.json").read_text(encoding="utf-8"))


def load_runner():
    """Import the simplified runner module (module-level only; main() is guarded)."""
    path = REPO / "foldsrunner_simplified_after_ablation.py"
    spec = importlib.util.spec_from_file_location("foldsrunner_simplified_after_ablation", path)
    mod = importlib.util.module_from_spec(spec)
    sys.modules[spec.name] = mod  # register BEFORE exec so @dataclass can resolve its module
    spec.loader.exec_module(mod)
    return mod


def short(exc: BaseException) -> str:
    return f"{type(exc).__name__}: {str(exc)[:180]}"


def main() -> int:
    runner = load_runner()
    x = torch.randn(BATCH, 3, IMG, IMG)
    results = []

    for key, cfg in MANIFEST.items():
        arch, enc, proj = cfg["arch"], cfg["encoder"], cfg["proj_dim"]
        row = {"model": key, "arch": arch, "encoder": enc, "proj_dim": proj,
               "depth": None, "out_channels": None, "s2": "FAIL", "s3": "FAIL"}

        # ---- strategy 2: plain SMP model -------------------------------------
        for depth in (5, 4):
            try:
                m2 = smp.create_model(arch=arch, encoder_name=enc, encoder_weights="imagenet",
                                      encoder_depth=depth, in_channels=3, classes=1)
                m2.eval()
                with torch.no_grad():
                    y = m2(x)
                row["depth"] = depth
                row["out_channels"] = list(m2.encoder.out_channels)
                row["s2"] = f"OK  out={tuple(y.shape)}"
                del m2
                break
            except Exception as exc:  # noqa: BLE001
                row["s2"] = f"FAIL(depth={depth}) {short(exc)}"

        # ---- strategy 3: refinement stack ------------------------------------
        if row["depth"] is not None:
            try:
                m3 = runner.PixelDRLMG_WithDecoder(
                    arch=arch, encoder_name=enc, encoder_weights="imagenet",
                    encoder_depth=row["depth"], proj_dim=proj, dropout_p=0.0,
                )
                m3.eval()
                with torch.no_grad():
                    ctx = m3.prepare_refinement_context(x)
                    state = m3.forward_refinement_state(
                        ctx["base_features"], ctx["decoder_prob"].detach(), ctx["decoder_prob"],
                        ctx["mc_variance"], ctx["pred_entropy"],
                        encoder_features=ctx.get("encoder_features"),
                    )
                    policy, _ = m3.forward_from_state(state)
                row["s3"] = f"OK  state={tuple(state.shape)} policy={tuple(policy.shape)}"
                del m3
            except Exception as exc:  # noqa: BLE001
                row["s3"] = f"FAIL {short(exc)}"
                traceback.print_exc()

        results.append(row)

    # ---- report --------------------------------------------------------------
    print("\n" + "=" * 110)
    print(f"MODEL VALIDATION @ {IMG}x{IMG}, ImageNet weights")
    print("=" * 110)
    for r in results:
        ok = r["s2"].startswith("OK") and r["s3"].startswith("OK")
        print(f"\n[{'PASS' if ok else 'FAIL'}] {r['model']}   arch={r['arch']}  encoder={r['encoder']}")
        print(f"        encoder_depth : {r['depth']}")
        print(f"        out_channels  : {r['out_channels']}")
        print(f"        strategy 2    : {r['s2']}")
        print(f"        strategy 3    : {r['s3']}")

    failed = [r["model"] for r in results if not (r["s2"].startswith("OK") and r["s3"].startswith("OK"))]
    depth4 = [r["model"] for r in results if r["depth"] == 4]
    print("\n" + "=" * 110)
    if depth4:
        print(f"NOTE: these need SMP_ENCODER_DEPTH = 4 (not 5): {depth4}")
        print("      -> add  -e 's/^SMP_ENCODER_DEPTH = .*/SMP_ENCODER_DEPTH = 4/'  to that model's command.")
    if failed:
        print(f"FAILED: {failed}  -- fix/swap these before running the matrix.")
        return 1
    print("ALL MODELS PASS.")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())