"""Hierarchical, identity-free academic history encoders.

Events in a semester are a set. Sequence encoders see only the resulting
semester means and counts, so row order within a semester has no meaning.
"""

import math
from typing import Dict, Tuple

import torch
from torch import nn


class HistoryEncoder(nn.Module):
    def __init__(self, vocab_size, arch, dim=128, layers=2, heads=4, dropout=.1):
        super().__init__()
        if arch not in {"mlp", "gru", "transformer"}:
            raise ValueError("arch must be mlp, gru, or transformer")
        if vocab_size < 3 or dim < 1 or layers < 1:
            raise ValueError("vocab_size >= 3, dim >= 1, and layers >= 1 required")
        self.vocab_size, self.arch, self.dim = int(vocab_size), arch, int(dim)
        self.layers, self.heads, self.dropout = int(layers), int(heads), float(dropout)
        self.course_embedding = nn.Embedding(vocab_size, 32, padding_idx=0)
        self.grade_embedding = nn.Embedding(8, 16, padding_idx=0)
        # Numeric grade, credits, attempt; explicit mask/unknown indicators.
        self.event_mlp = nn.Sequential(
            nn.Linear(32 + 16 + 3 + 4, dim), nn.GELU(),
            nn.Dropout(dropout), nn.Linear(dim, dim), nn.LayerNorm(dim),
        )
        self.semester_mlp = nn.Sequential(nn.Linear(dim + 1, dim), nn.GELU(), nn.LayerNorm(dim))
        if arch == "mlp":
            self.history_mlp = nn.Sequential(
                nn.Linear(dim + 1, dim), nn.GELU(), nn.Dropout(dropout), nn.Linear(dim, dim),
            )
        elif arch == "gru":
            self.gap_embedding = nn.Sequential(nn.Linear(1, dim), nn.GELU(), nn.Linear(dim, dim))
            self.sequence = nn.GRU(dim, dim, num_layers=layers, batch_first=True,
                                   dropout=dropout if layers > 1 else 0.)
        else:
            if dim % heads:
                raise ValueError("transformer dim must be divisible by heads")
            self.gap_embedding = nn.Sequential(nn.Linear(1, dim), nn.GELU(), nn.Linear(dim, dim))
            layer = nn.TransformerEncoderLayer(
                dim, heads, dim_feedforward=dim * 4, dropout=dropout,
                activation="gelu", batch_first=True, norm_first=True,
            )
            self.sequence = nn.TransformerEncoder(layer, layers, enable_nested_tensor=False)
        self.empty_history = nn.Parameter(torch.empty(dim))
        nn.init.normal_(self.empty_history, std=.02)

    def _semester_mask(self, batch):
        return batch["semester_mask"].bool() & batch["event_mask"].bool().any(-1)

    def _positions(self, length, device, dtype):
        position = torch.arange(length, device=device, dtype=dtype).unsqueeze(1)
        scale = torch.exp(torch.arange(0, self.dim, 2, device=device, dtype=dtype)
                          * (-math.log(10000.) / self.dim))
        angles = position * scale
        output = torch.zeros(length, self.dim, device=device, dtype=dtype)
        output[:, 0::2] = torch.sin(angles)
        output[:, 1::2] = torch.cos(angles[:, :self.dim // 2])
        return output

    def encode_events(self, batch: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:
        """Return local event vectors and *causal* semester context vectors.

        Same-semester visible peers are allowed in historical denoising.
        No context at semester s consumes any semester after s.
        """
        observed = batch["event_mask"].bool()
        sem_mask = self._semester_mask(batch)
        observed = observed & sem_mask.unsqueeze(-1)
        course = torch.where(observed, batch["course"].long(), 0)
        grade = torch.where(observed, batch["grade_band"].long(), 0)
        numeric = torch.where(observed.unsqueeze(-1), batch["numeric"].float(), 0.)
        indicators = torch.stack((course == 2, grade == 2, course == 1, grade == 1), -1).float()
        local = self.event_mlp(torch.cat((self.course_embedding(course), self.grade_embedding(grade),
                                         numeric, indicators), dim=-1))
        local = torch.where(observed.unsqueeze(-1), local, 0.)
        counts = observed.sum(-1).to(local.dtype)
        means = local.sum(-2) / counts.clamp_min(1).unsqueeze(-1)
        semester = self.semester_mlp(torch.cat((means, counts.log1p().unsqueeze(-1)), -1))
        semester = torch.where(sem_mask.unsqueeze(-1), semester, 0.)
        n, length = sem_mask.shape
        if length == 0:
            return local, semester
        if self.arch == "mlp":
            prefix_count = sem_mask.cumsum(1).to(semester.dtype)
            prefix_mean = semester.cumsum(1) / prefix_count.clamp_min(1).unsqueeze(-1)
            context = self.history_mlp(torch.cat((prefix_mean, prefix_count.log1p().unsqueeze(-1)), -1))
        elif self.arch == "gru":
            gaps = torch.where(sem_mask, batch["gaps"].float(), 0.)
            sequence = semester + self.gap_embedding(gaps.clamp_min(0).log1p().unsqueeze(-1))
            context, _ = self.sequence(torch.where(sem_mask.unsqueeze(-1), sequence, 0.))
        else:
            gaps = torch.where(sem_mask, batch["gaps"].float(), 0.)
            # Log gaps retain elapsed calendar distance without unbounded inputs.
            sequence = (semester + self._positions(length, semester.device, semester.dtype)
                        + self.gap_embedding(gaps.clamp_min(0).log1p().unsqueeze(-1)))
            sequence = torch.where(sem_mask.unsqueeze(-1), sequence, 0.)
            padding = ~sem_mask.clone()
            # PyTorch attention needs a visible key even for an all-padding row.
            # The corresponding output is suppressed below and replaced by the
            # learned empty vector in forward(). No real row attends to it.
            padding[~sem_mask.any(1), 0] = False
            causal = torch.ones(length, length, device=semester.device, dtype=torch.bool).triu(1)
            context = self.sequence(sequence, mask=causal, src_key_padding_mask=padding)
        context = torch.where(sem_mask.unsqueeze(-1), context, 0.)
        return local, context

    def forward(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor:
        _, context = self.encode_events(batch)
        sem_mask = self._semester_mask(batch)
        n, length = sem_mask.shape
        empty = self.empty_history.unsqueeze(0).expand(n, -1)
        if length == 0:
            return empty
        positions = torch.arange(length, device=context.device).expand(n, -1)
        last = torch.where(sem_mask, positions, -1).amax(1).clamp_min(0)
        history = context[torch.arange(n, device=context.device), last]
        return torch.where(sem_mask.any(1).unsqueeze(-1), history, empty)


class MaskedEventModel(nn.Module):
    """Decode masked events from their local vector and causal semester context."""

    def __init__(self, encoder):
        super().__init__()
        self.encoder = encoder
        self.decoder = nn.Sequential(nn.Linear(encoder.dim * 2, encoder.dim), nn.GELU())
        self.grade_head = nn.Linear(encoder.dim, 5)
        self.course_head = nn.Linear(encoder.dim, max(encoder.vocab_size - 3, 1))

    def forward(self, batch, grade_mask=None, course_mask=None):
        local, context = self.encoder.encode_events(batch)
        context = context.unsqueeze(-2).expand_as(local)
        if grade_mask is not None or course_mask is not None:
            # Heads scale with selected targets, especially important for the
            # course softmax. Never allocate [B,S,C,V] in SSL training.
            output = {}
            for name, mask, head, classes in (("grade", grade_mask, self.grade_head, 5),
                                               ("course", course_mask, self.course_head, self.course_head.out_features)):
                if mask is None or not mask.any():
                    output[name] = local.new_empty((0, classes))
                else:
                    representation = self.decoder(torch.cat((local[mask], context[mask]), -1))
                    output[name] = head(representation)
            return output
        representation = self.decoder(torch.cat((local, context), -1))
        return {"grade": self.grade_head(representation), "course": self.course_head(representation)}


class NeuralRiskModel(nn.Module):
    def __init__(self, input_dim, encoder=None, mode="none", hidden_dim=128, dropout=.1):
        super().__init__()
        self.encoder, self.mode = encoder, mode
        if mode == "frozen" and encoder is not None:
            encoder.requires_grad_(False)
            encoder.eval()
        width = input_dim + (encoder.dim if encoder is not None else 0)
        self.head = nn.Sequential(nn.Linear(width, hidden_dim), nn.GELU(), nn.Dropout(dropout),
                                  nn.Linear(hidden_dim, 1))

    def train(self, mode=True):
        super().train(mode)
        if self.mode == "frozen" and self.encoder is not None:
            self.encoder.eval()
        return self

    def forward(self, x, batch=None):
        if self.encoder is not None:
            if batch is None:
                raise ValueError("history batch required for encoder model")
            if self.mode == "frozen":
                with torch.no_grad():
                    history = self.encoder(batch)
            else:
                history = self.encoder(batch)
            x = torch.cat((x, history), -1)
        return self.head(x).squeeze(-1)
