"""TriFuse-AD: tri-planar CNN + slice-plane Transformer + gated metadata fusion.

Pipeline:
  27 slices (3 planes x 9) -> shared 2D CNN encoder (timm ConvNeXt-Tiny) -> 27 tokens
  + slice pos-emb + plane emb + [CLS] -> 2-layer Transformer encoder -> z_mri (CLS)
  metadata (7 feats) -> MLP -> z_tab
  GatedFusion(z_mri, z_tab) -> classifier -> 3 logits

Ablation knobs (set via constructor so A1-A5 reuse this class):
  use_transformer=False  -> mean-pool tokens instead of Transformer (A2)
  planes=("axial",)      -> single-plane / axial-only (A1)
  use_metadata=False     -> drop tabular branch entirely (A3)
  fusion="concat"        -> ConcatFusion instead of GatedFusion (A4)
"""
from __future__ import annotations

import timm
import torch
import torch.nn as nn

from .fusion import GatedFusion, ConcatFusion

PLANE_TO_IDX = {"axial": 0, "coronal": 1, "sagittal": 2}


class MetadataMLP(nn.Module):
    def __init__(self, in_dim: int, out_dim: int = 128, dropout: float = 0.3):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(in_dim, 64), nn.GELU(), nn.Dropout(dropout),
            nn.Linear(64, out_dim), nn.LayerNorm(out_dim),
        )
        self.out_dim = out_dim

    def forward(self, x):
        return self.net(x)


class TriFuseAD(nn.Module):
    def __init__(
        self,
        n_classes: int = 3,
        n_tab_features: int = 7,
        planes: tuple[str, ...] = ("axial", "coronal", "sagittal"),
        n_slices: int = 9,
        backbone: str = "convnext_tiny",
        embed_dim: int = 768,
        n_transformer_layers: int = 2,
        n_heads: int = 8,
        dropout: float = 0.3,
        use_transformer: bool = True,
        use_metadata: bool = True,
        fusion: str = "gated",
        pretrained: bool = True,
    ):
        super().__init__()
        self.planes = planes
        self.n_slices = n_slices
        self.n_tokens = len(planes) * n_slices
        self.use_transformer = use_transformer
        self.use_metadata = use_metadata

        # shared CNN encoder (num_classes=0 -> pooled feature vector)
        self.encoder = timm.create_model(
            backbone, pretrained=pretrained, num_classes=0, in_chans=3,
        )
        feat_dim = self.encoder.num_features
        self.proj = nn.Linear(feat_dim, embed_dim) if feat_dim != embed_dim else nn.Identity()

        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
        self.slice_pos = nn.Parameter(torch.zeros(1, n_slices, embed_dim))
        self.plane_emb = nn.Parameter(torch.zeros(1, len(planes), embed_dim))
        nn.init.trunc_normal_(self.cls_token, std=0.02)
        nn.init.trunc_normal_(self.slice_pos, std=0.02)
        nn.init.trunc_normal_(self.plane_emb, std=0.02)

        if use_transformer:
            layer = nn.TransformerEncoderLayer(
                d_model=embed_dim, nhead=n_heads, dim_feedforward=embed_dim * 4,
                dropout=dropout, batch_first=True, activation="gelu", norm_first=True,
            )
            self.transformer = nn.TransformerEncoder(layer, num_layers=n_transformer_layers)
        self.mri_norm = nn.LayerNorm(embed_dim)

        fused_dim = embed_dim
        if use_metadata:
            self.tab_mlp = MetadataMLP(n_tab_features, out_dim=128, dropout=dropout)
            fusion_cls = GatedFusion if fusion == "gated" else ConcatFusion
            self.fusion = fusion_cls(embed_dim, self.tab_mlp.out_dim, dropout=dropout)
            fused_dim = self.fusion.out_dim

        self.head = nn.Sequential(
            nn.Linear(fused_dim, 256), nn.GELU(), nn.Dropout(dropout),
            nn.Linear(256, n_classes),
        )

    def encode_mri(self, slices: torch.Tensor) -> torch.Tensor:
        """slices: (B, n_tokens, 3, H, W) -> z_mri (B, embed_dim)."""
        B, T, C, H, W = slices.shape
        feats = self.encoder(slices.reshape(B * T, C, H, W))       # (B*T, feat_dim)
        feats = self.proj(feats).reshape(B, T, -1)                 # (B, T, embed_dim)

        # add slice + plane positional embeddings (tokens ordered plane-major)
        pos = []
        for p_idx in range(len(self.planes)):
            pe = self.slice_pos + self.plane_emb[:, p_idx:p_idx + 1, :]  # (1, n_slices, D)
            pos.append(pe)
        pos = torch.cat(pos, dim=1)                                # (1, T, D)
        feats = feats + pos

        if self.use_transformer:
            cls = self.cls_token.expand(B, -1, -1)
            seq = torch.cat([cls, feats], dim=1)                   # (B, 1+T, D)
            seq = self.transformer(seq)
            z = seq[:, 0]                                          # CLS
        else:
            z = feats.mean(dim=1)                                  # mean-pool (A2)
        return self.mri_norm(z)

    def forward(self, slices: torch.Tensor, tab: torch.Tensor | None = None) -> torch.Tensor:
        z_mri = self.encode_mri(slices)
        if self.use_metadata:
            assert tab is not None, "metadata branch enabled but tab is None"
            z_tab = self.tab_mlp(tab)
            z = self.fusion(z_mri, z_tab)
        else:
            z = z_mri
        return self.head(z)