"""Transformer baselines.

- ViT2D: ViT-B/16 (timm, pretrained) over 2.5D multi-slice input. Slices are
  encoded independently by the shared ViT and mean-pooled, then classified.
  Supports 2-stage fine-tuning via freeze_backbone().
- SwinT3D: MONAI SwinUNETR encoder (Swin-Tiny-scale) over a 3D crop, GAP + head.
"""
from __future__ import annotations

import timm
import torch
import torch.nn as nn


class ViT2D(nn.Module):
    """ViT-B/16 over N 2D slices, mean-pooled embeddings -> classifier.

    Input: (B, N, 3, 224, 224) or (B, 3, 224, 224). Shared backbone across slices.
    """

    def __init__(self, n_classes: int = 3, pretrained: bool = True):
        super().__init__()
        self.backbone = timm.create_model(
            "vit_base_patch16_224", pretrained=pretrained, num_classes=0,
        )
        self.embed_dim = self.backbone.num_features  # 768
        self.head = nn.Linear(self.embed_dim, n_classes)

    def freeze_backbone(self, freeze: bool = True):
        for p in self.backbone.parameters():
            p.requires_grad = not freeze

    def unfreeze_last_blocks(self, n_blocks: int = 2):
        self.freeze_backbone(True)
        for blk in self.backbone.blocks[-n_blocks:]:
            for p in blk.parameters():
                p.requires_grad = True
        for p in self.backbone.norm.parameters():
            p.requires_grad = True

    def forward(self, x: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
        if x.dim() == 4:
            x = x.unsqueeze(1)  # (B,1,3,224,224)
        b, n = x.shape[:2]
        x = x.flatten(0, 1)                     # (B*N,3,224,224)
        feats = self.backbone(x)                # (B*N,768)
        feats = feats.view(b, n, -1).mean(1)    # mean-pool slices
        return self.head(feats)


class SwinT3D(nn.Module):
    """3D Swin transformer encoder (Swin-Tiny scale) via MONAI, GAP + linear head."""

    def __init__(self, n_classes: int = 3, in_channels: int = 1, img_size=(96, 112, 112)):
        super().__init__()
        from monai.networks.nets.swin_unetr import SwinTransformer
        from monai.utils import ensure_tuple_rep

        patch = ensure_tuple_rep(2, 3)
        window = ensure_tuple_rep(7, 3)
        self.swin = SwinTransformer(
            in_chans=in_channels,
            embed_dim=48,
            window_size=window,
            patch_size=patch,
            depths=(2, 2, 2, 2),
            num_heads=(3, 6, 12, 24),
            spatial_dims=3,
        )
        self.norm = nn.LayerNorm(48 * 16)
        self.head = nn.Linear(48 * 16, n_classes)

    def forward(self, vol: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
        feats = self.swin(vol)[-1]              # deepest stage (B, 8C, d, h, w)
        pooled = feats.flatten(2).mean(-1)      # GAP -> (B, 8C)
        return self.head(self.norm(pooled))