from __future__ import annotations

import math

import torch
import torch.nn as nn


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(),
    )


def safe_logit(p: torch.Tensor) -> torch.Tensor:
    p = p.clamp(1e-5, 1.0 - 1e-5)
    return torch.log(p) - torch.log1p(-p)


def committee_meta_features(probabilities: torch.Tensor) -> torch.Tensor:
    p = probabilities.clamp(1e-5, 1.0 - 1e-5)
    q = p.mean(1, keepdim=True)
    logits = safe_logit(p)
    std = p.std(1, keepdim=True, unbiased=False)
    spread = p.max(1, keepdim=True).values - p.min(1, keepdim=True).values
    entropy = -(q * torch.log(q) + (1.0 - q) * torch.log1p(-q))
    vote = (p >= .5).float().mean(1, keepdim=True)
    return torch.cat([p, logits, q, std, spread, entropy, vote], 1)


class SemesterTransformerEncoder(nn.Module):
    """Ordered previous-semester encoder with a target-course query."""
    def __init__(
        self,
        student_dim: int,
        course_dim: int,
        faculty_dim: int,
        d_model: int = 96,
        heads: int = 4,
        layers: int = 2,
        dropout: float = .10,
        max_semesters: int = 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
        positions = torch.arange(t, device=student_seq.device)
        x = self.student_proj(student_seq) + self.position(positions)[None, :, :]
        encoded = self.encoder(x, src_key_padding_mask=~student_mask)
        encoded = torch.nan_to_num(encoded)
        query = self.target_proj(torch.cat([target_course, faculty_embedding], 1))[:, None, :]
        attended, attn = self.cross_attention(
            query,
            encoded,
            encoded,
            key_padding_mask=~student_mask,
            need_weights=True,
            average_attn_weights=False,
        )
        has_history = student_mask.any(1)
        attended = torch.nan_to_num(attended[:, 0, :]) * 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 ResidualEnsembleHead(nn.Module):
    """Cheap ensemble whose zero initialization preserves the Committee exactly."""
    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.zeros(self.members, d_model))
        self.bias = nn.Parameter(torch.zeros(self.members))
        self.dropout = nn.Dropout(dropout)
        nn.init.normal_(self.shift, std=.005)

    def forward(self, h: torch.Tensor) -> torch.Tensor:
        z = h[:, None, :] * self.scale[None, :, :] + self.shift[None, :, :]
        z = self.dropout(z)
        raw = (z * self.weight[None, :, :]).sum(-1) + self.bias[None, :]
        return torch.tanh(raw)


class Suite21Model(nn.Module):
    """Committee-anchored temporal residual learner.

    The deployed score is always
        logit(q_committee) + alpha * bounded_residual
    so alpha=0 is an exact identity fallback.
    """
    VARIANTS = {"flat_residual", "temporal_residual", "guarded_temporal_residual"}

    def __init__(
        self,
        variant: str,
        flat_dim: int,
        student_dim: int,
        course_dim: int,
        committee_members: int,
        n_faculties: int,
        max_semesters: int,
        d_model: int = 96,
        heads: int = 4,
        layers: int = 2,
        faculty_dim: int = 16,
        ensemble_members: int = 8,
        dropout: float = .10,
        positive_cap: float = 1.50,
        negative_cap: float = 1.00,
        guard_power: float = 1.50,
    ):
        super().__init__()
        if variant not in self.VARIANTS:
            raise ValueError(f"Unknown variant: {variant}")
        self.variant = variant
        self.max_semesters = int(max_semesters)
        self.positive_cap = float(positive_cap)
        self.negative_cap = float(negative_cap)
        self.guard_power = float(guard_power)
        self.committee_meta_dim = 2 * int(committee_members) + 5

        self.faculty = nn.Embedding(n_faculties, faculty_dim)
        self.current = mlp(
            flat_dim + course_dim + faculty_dim + 1 + self.committee_meta_dim,
            2 * d_model,
            d_model,
            dropout,
        )

        if variant == "flat_residual":
            self.temporal = None
            residual_input_dim = d_model + self.committee_meta_dim
            gate_input_dim = residual_input_dim
        else:
            self.temporal = SemesterTransformerEncoder(
                student_dim, course_dim, faculty_dim, d_model, heads, layers, dropout, max_semesters
            )
            residual_input_dim = 4 * d_model + self.committee_meta_dim
            gate_input_dim = 2 * d_model + self.committee_meta_dim + 2

        self.residual_context = mlp(residual_input_dim, 2 * d_model, d_model, dropout)
        self.authority = nn.Sequential(
            nn.Linear(gate_input_dim, d_model),
            nn.GELU(),
            nn.Dropout(dropout),
            nn.Linear(d_model, 1),
        )
        nn.init.constant_(self.authority[-1].bias, -0.75)
        self.residual = ResidualEnsembleHead(d_model, ensemble_members, dropout=.05)
        self.temporal_aux = nn.Linear(d_model, 1) if self.temporal is not None else None

    def forward(
        self,
        flat,
        student_seq,
        student_mask,
        course_target,
        faculty_idx,
        semester_scalar,
        committee_probs,
    ):
        faculty_h = self.faculty(faculty_idx)
        meta = committee_meta_features(committee_probs)
        q = committee_probs.mean(1).clamp(1e-5, 1.0 - 1e-5)
        base_logit = safe_logit(q)
        current_h = self.current(
            torch.cat([flat, course_target, faculty_h, semester_scalar[:, None], meta], 1)
        )

        history_length = student_mask.sum(1).float()
        history_length_norm = history_length / max(float(self.max_semesters), 1.0)

        if self.temporal is None:
            temporal_h = torch.zeros_like(current_h)
            has_history = student_mask.any(1)
            attention = torch.zeros(len(flat), 1, student_seq.shape[1], device=flat.device)
            residual_h = self.residual_context(torch.cat([current_h, meta], 1))
            gate_input = torch.cat([current_h, meta], 1)
            authority = torch.sigmoid(self.authority(gate_input)).squeeze(1)
            temporal_aux_logit = torch.zeros(len(flat), device=flat.device)
        else:
            temporal_h, attention, has_history = self.temporal(
                student_seq, student_mask, course_target, faculty_h
            )
            interaction = current_h * temporal_h
            difference = torch.abs(current_h - temporal_h)
            residual_h = self.residual_context(
                torch.cat([current_h, temporal_h, interaction, difference, meta], 1)
            )
            gate_input = torch.cat(
                [
                    current_h,
                    temporal_h,
                    meta,
                    semester_scalar[:, None],
                    history_length_norm[:, None],
                ],
                1,
            )
            authority = torch.sigmoid(self.authority(gate_input)).squeeze(1) * has_history.float()
            temporal_aux_logit = self.temporal_aux(temporal_h).squeeze(1)

        signed = self.residual(residual_h)
        if self.variant == "guarded_temporal_residual":
            guard_scale = torch.pow((1.0 - q).clamp_min(.02), self.guard_power)
        else:
            guard_scale = torch.ones_like(q)
        # Smooth signed residual around zero. torch.where keeps a non-zero
        # derivative at the zero-initialized identity point, unlike a pair of
        # ReLUs which would deadlock the residual head at exactly zero.
        signed_bounded = torch.where(
            signed >= 0,
            self.positive_cap * signed,
            self.negative_cap * guard_scale[:, None] * signed,
        )
        correction_members = authority[:, None] * signed_bounded
        member_logits = base_logit[:, None] + correction_members
        member_probs = torch.sigmoid(member_logits)

        return {
            "base_probability": q,
            "base_logit": base_logit,
            "committee_meta": meta,
            "correction_members": correction_members,
            "proposal_probability": member_probs.mean(1),
            "proposal_uncertainty": member_probs.std(1, unbiased=False),
            "authority": authority,
            "guard_scale": guard_scale,
            "attention": attention,
            "has_history": has_history,
            "temporal_aux_logit": temporal_aux_logit,
            "current_h": current_h,
            "temporal_h": temporal_h,
            "residual_h": residual_h,
        }


def probabilities_at_alpha(base_logit: torch.Tensor, correction_members: torch.Tensor, alpha: float):
    logits = base_logit[:, None] + float(alpha) * correction_members
    probs = torch.sigmoid(logits)
    return probs.mean(1), probs.std(1, unbiased=False), logits
