from __future__ import annotations

import math
from dataclasses import dataclass

import torch
import torch.nn as nn
import torch.nn.functional as F


def mlp(in_dim: int, hidden: int, out_dim: int, dropout: float) -> nn.Sequential:
    return nn.Sequential(
        nn.Linear(in_dim, hidden),
        nn.LayerNorm(hidden),
        nn.GELU(),
        nn.Dropout(dropout),
        nn.Linear(hidden, out_dim),
        nn.LayerNorm(out_dim),
        nn.GELU(),
    )


class ParameterEfficientEnsembleHead(nn.Module):
    """TabM-inspired cheap ensemble over a shared representation.

    This is intentionally dependency-free and is NOT a reimplementation of the
    official TabM package. The shared trunk is modulated by K learned affine
    member vectors before member-specific linear readouts.
    """
    def __init__(self, d_model: int, members: int = 8, dropout: float = .05):
        super().__init__()
        self.members = int(members)
        self.scale = nn.Parameter(torch.ones(self.members, d_model))
        self.shift = nn.Parameter(torch.zeros(self.members, d_model))
        self.weight = nn.Parameter(torch.empty(self.members, d_model))
        self.bias = nn.Parameter(torch.zeros(self.members))
        self.dropout = nn.Dropout(dropout)
        nn.init.normal_(self.weight, std=0.02)
        nn.init.normal_(self.shift, std=0.01)

    def forward(self, h: torch.Tensor):
        z = h[:, None, :] * self.scale[None, :, :] + self.shift[None, :, :]
        z = self.dropout(z)
        logits = (z * self.weight[None, :, :]).sum(-1) + self.bias[None, :]
        probs = torch.sigmoid(logits)
        return logits, probs.mean(1), probs.std(1, unbiased=False)


class FlatBranch(nn.Module):
    def __init__(self, flat_dim, course_dim, faculty_dim, semester_dim, d_model, dropout):
        super().__init__()
        self.net = mlp(flat_dim + course_dim + faculty_dim + semester_dim, 2 * d_model, d_model, dropout)

    def forward(self, flat, course, faculty_embedding, semester_scalar):
        return self.net(torch.cat([flat, course, faculty_embedding, semester_scalar[:, None]], 1))


class SemesterTransformerEncoder(nn.Module):
    def __init__(self, student_dim, course_dim, faculty_dim, d_model=96, heads=4, layers=2, dropout=.10, max_semesters=16):
        super().__init__()
        self.student_proj = nn.Linear(student_dim, d_model)
        self.target_proj = mlp(course_dim + faculty_dim, d_model, d_model, dropout)
        self.position = nn.Embedding(max_semesters, d_model)
        layer = nn.TransformerEncoderLayer(
            d_model=d_model,
            nhead=heads,
            dim_feedforward=4 * d_model,
            dropout=dropout,
            activation="gelu",
            batch_first=True,
            norm_first=True,
        )
        self.encoder = nn.TransformerEncoder(layer, num_layers=layers, norm=nn.LayerNorm(d_model))
        self.cross_attention = nn.MultiheadAttention(d_model, heads, dropout=dropout, batch_first=True)
        self.out = nn.Sequential(nn.Linear(2 * d_model, d_model), nn.LayerNorm(d_model), nn.GELU())

    def forward(self, student_seq, student_mask, target_course, faculty_embedding):
        b, t, _ = student_seq.shape
        pos = self.position(torch.arange(t, device=student_seq.device))[None, :, :]
        x = self.student_proj(student_seq) + pos
        encoded = self.encoder(x, src_key_padding_mask=~student_mask)
        encoded = torch.nan_to_num(encoded)
        q = self.target_proj(torch.cat([target_course, faculty_embedding], 1))[:, None, :]
        attended, attn = self.cross_attention(
            q, encoded, encoded,
            key_padding_mask=~student_mask,
            need_weights=True,
            average_attn_weights=False,
        )
        # MultiheadAttention can emit NaNs when all keys are masked. Explicitly
        # replace such rows with a zero history representation.
        has_history = student_mask.any(1)
        attended = torch.nan_to_num(attended[:, 0, :])
        attended = attended * has_history[:, None].float()
        attn = torch.nan_to_num(attn[:, :, 0, :])
        pooled = (encoded * student_mask[:, :, None].float()).sum(1) / student_mask.sum(1, keepdim=True).clamp_min(1).float()
        pooled = pooled * has_history[:, None].float()
        return self.out(torch.cat([attended, pooled], 1)), attn, has_history


class SemesterGRUEncoder(nn.Module):
    def __init__(self, student_dim, course_dim, faculty_dim, d_model=96, dropout=.10):
        super().__init__()
        self.student_proj = nn.Linear(student_dim, d_model)
        self.gru = nn.GRU(d_model, d_model, batch_first=True)
        self.target_proj = mlp(course_dim + faculty_dim, d_model, d_model, dropout)
        self.query = nn.Linear(d_model, d_model, bias=False)
        self.key = nn.Linear(d_model, d_model, bias=False)
        self.out = nn.Sequential(nn.Linear(2 * d_model, d_model), nn.LayerNorm(d_model), nn.GELU())

    def forward(self, student_seq, student_mask, target_course, faculty_embedding):
        x = self.student_proj(student_seq)
        encoded, _ = self.gru(x)
        q = self.query(self.target_proj(torch.cat([target_course, faculty_embedding], 1)))
        k = self.key(encoded)
        score = (k * q[:, None, :]).sum(-1) / math.sqrt(k.shape[-1])
        score = score.masked_fill(~student_mask, -1e4)
        weights = torch.softmax(score, 1) * student_mask.float()
        weights = weights / weights.sum(1, keepdim=True).clamp_min(1e-6)
        attended = (encoded * weights[:, :, None]).sum(1)
        has_history = student_mask.any(1)
        attended = attended * has_history[:, None].float()
        last_index = student_mask.long().sum(1).clamp_min(1) - 1
        last = encoded[torch.arange(len(encoded), device=encoded.device), last_index]
        last = last * has_history[:, None].float()
        return self.out(torch.cat([attended, last], 1)), weights[:, None, :], has_history


class HistoryFusion(nn.Module):
    def __init__(self, d_model, course_dim, faculty_dim, dropout=.10):
        super().__init__()
        self.gate = nn.Sequential(
            nn.Linear(2 * d_model + course_dim + faculty_dim + 2, d_model),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_model, 1),
        )
        self.out = nn.Sequential(
            nn.Linear(4 * d_model, 2 * d_model),
            nn.LayerNorm(2 * d_model),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(2 * d_model, d_model),
            nn.LayerNorm(d_model),
            nn.GELU(),
        )

    def forward(self, flat_h, temporal_h, course, faculty_embedding, semester_scalar, history_length_norm, has_history):
        gate_in = torch.cat([
            flat_h, temporal_h, course, faculty_embedding,
            semester_scalar[:, None], history_length_norm[:, None]
        ], 1)
        gate = torch.sigmoid(self.gate(gate_in)).squeeze(1) * has_history.float()
        mixed = gate[:, None] * temporal_h + (1.0 - gate[:, None]) * flat_h
        interaction = flat_h * temporal_h
        diff = torch.abs(flat_h - temporal_h)
        out = self.out(torch.cat([flat_h, temporal_h, interaction, diff], 1))
        # Residual mixture makes gate semantically meaningful while preserving a
        # richer nonlinear interaction path.
        return out + mixed, gate


class Suite20Model(nn.Module):
    def __init__(
        self,
        variant: str,
        flat_dim: int,
        student_dim: int,
        course_dim: int,
        n_faculties: int,
        max_semesters: int,
        d_model: int = 96,
        heads: int = 4,
        layers: int = 2,
        faculty_dim: int = 16,
        members: int = 8,
        dropout: float = .10,
    ):
        super().__init__()
        if variant not in {"flat", "gru", "transformer"}:
            raise ValueError(f"Unknown variant: {variant}")
        self.variant = variant
        self.max_semesters = int(max_semesters)
        self.faculty = nn.Embedding(n_faculties, faculty_dim)
        self.flat_branch = FlatBranch(flat_dim, course_dim, faculty_dim, 1, d_model, dropout)
        if variant == "transformer":
            self.temporal = SemesterTransformerEncoder(student_dim, course_dim, faculty_dim, d_model, heads, layers, dropout, max_semesters)
        elif variant == "gru":
            self.temporal = SemesterGRUEncoder(student_dim, course_dim, faculty_dim, d_model, dropout)
        else:
            self.temporal = None
        self.fusion = HistoryFusion(d_model, course_dim, faculty_dim, dropout) if self.temporal is not None else None
        self.head = ParameterEfficientEnsembleHead(d_model, members, dropout=.05)

    def forward(self, flat, student_seq, student_mask, course_target, faculty_idx, semester_scalar):
        f = self.faculty(faculty_idx)
        flat_h = self.flat_branch(flat, course_target, f, semester_scalar)
        history_length = student_mask.sum(1).float()
        history_length_norm = history_length / max(float(self.max_semesters), 1.0)
        if self.temporal is None:
            fused = flat_h
            gate = torch.zeros(len(flat), device=flat.device)
            attention = torch.zeros(len(flat), 1, student_seq.shape[1], device=flat.device)
            has_history = student_mask.any(1)
            temporal_h = torch.zeros_like(flat_h)
        else:
            temporal_h, attention, has_history = self.temporal(student_seq, student_mask, course_target, f)
            fused, gate = self.fusion(flat_h, temporal_h, course_target, f, semester_scalar, history_length_norm, has_history)
        member_logits, probability, uncertainty = self.head(fused)
        return {
            "member_logits": member_logits,
            "probability": probability,
            "uncertainty": uncertainty,
            "gate": gate,
            "attention": attention,
            "has_history": has_history,
            "flat_h": flat_h,
            "temporal_h": temporal_h,
            "fused_h": fused,
        }
