# -*- coding: utf-8 -*-
from __future__ import annotations
import math
import torch
import torch.nn as nn
import torch.nn.functional as F

POOL_NAMES=('same_student','same_course','structural','state')


class ResBlock(nn.Module):
    def __init__(self,d,dropout=.1,mult=2):
        super().__init__();h=int(d*mult);self.norm=nn.LayerNorm(d);self.net=nn.Sequential(nn.Linear(d,h),nn.GELU(),nn.Dropout(dropout),nn.Linear(h,d),nn.Dropout(dropout))
    def forward(self,x):return x+self.net(self.norm(x))


class StructureAwareChronologicalRetrieval(nn.Module):
    """Standalone TabR-inspired retrieval model.

    A = ``mlp``  : current-state neural baseline, no retrieval.
    B = ``tabr`` : chronology-safe learned kNN/TabR retrieval from the state pool.
    C = ``sacr`` : PRIMARY. Multi-view retrieval over same-student, same-course,
                   structurally-related and state-neighbour pools.

    Core TabR mechanics are retained: a shared encoder creates query/candidate keys,
    candidates are re-ranked by learned squared-L2 similarity, historical labels are
    embedded into values, T(k_q-k_c) is added to each value, and the retrieved context
    is added to the query representation before the final predictor.
    """
    def __init__(self,n_features,n_faculties,variant='sacr',d_main=128,key_dim=64,faculty_dim=8,encoder_blocks=2,predictor_blocks=2,dropout=.10,context_dropout=.10,context_size=24,pool_context=8):
        super().__init__();self.variant=str(variant);self.d_main=int(d_main);self.key_dim=int(key_dim);self.context_size=int(context_size);self.pool_context=int(pool_context)
        self.faculty_emb=nn.Embedding(int(n_faculties),int(faculty_dim));self.input=nn.Linear(int(n_features)+int(faculty_dim)+1,d_main);self.encoder=nn.ModuleList([ResBlock(d_main,dropout) for _ in range(int(encoder_blocks))]);self.key_norm=nn.LayerNorm(d_main);self.K=nn.Linear(d_main,key_dim)
        self.label_encoder=nn.Embedding(2,d_main);self.T=nn.Sequential(nn.Linear(key_dim,2*d_main),nn.GELU(),nn.Dropout(dropout),nn.Linear(2*d_main,d_main,bias=False))
        self.rel_emb=nn.Embedding(14,16)
        meta_in=4+1+3+16 # pool flags, same faculty, log-recency/exp-recency/coarse distance, relation embedding
        self.meta_value=nn.Sequential(nn.Linear(meta_in,64),nn.GELU(),nn.Linear(64,d_main,bias=False));self.meta_bias=nn.Linear(meta_in,1,bias=False);nn.init.zeros_(self.meta_bias.weight);nn.init.zeros_(self.meta_value[-1].weight)
        self.pool_bias=nn.Parameter(torch.zeros(4));self.pool_gate=nn.Linear(d_main+4,4);nn.init.zeros_(self.pool_gate.weight);nn.init.zeros_(self.pool_gate.bias)
        self.context_dropout=nn.Dropout(context_dropout);self.predictor=nn.ModuleList([ResBlock(d_main,dropout) for _ in range(int(predictor_blocks))]);self.head=nn.Sequential(nn.LayerNorm(d_main),nn.GELU(),nn.Linear(d_main,1))
        nn.init.uniform_(self.label_encoder.weight,-1.,1.)

    def _encode(self,current,faculty,semz):
        f=self.faculty_emb(faculty.long());x=torch.cat([current.float(),f,semz.float().unsqueeze(-1)],-1);x=self.input(x)
        for b in self.encoder:x=b(x)
        k=self.K(self.key_norm(x));return x,k

    @staticmethod
    def _masked_topk_context(sim,mask,values,k):
        B,P=sim.shape;k=min(int(k),P)
        masked=sim.masked_fill(~mask,-1e9);topv,topi=torch.topk(masked,k=k,dim=-1);valid=torch.gather(mask,1,topi)
        safe=topv.masked_fill(~valid,-1e9);allbad=~valid.any(1)
        if torch.any(allbad):safe=safe.clone();safe[allbad]=0.
        w=F.softmax(safe,dim=-1);w=torch.where(valid,w,torch.zeros_like(w));w=torch.where(allbad[:,None],torch.zeros_like(w),w)
        gather=topi.unsqueeze(-1).expand(-1,-1,values.shape[-1]);vv=torch.gather(values,1,gather);ctx=(w.unsqueeze(-1)*vv).sum(1)
        fullw=torch.zeros_like(sim);fullw.scatter_(1,topi,w);return ctx,fullw,~allbad

    def _meta(self,b):
        rec=torch.clamp(b['recency'].float(),min=0.);num=torch.cat([b['pool_flags'].float(),b['same_faculty'].float().unsqueeze(-1),(torch.log1p(rec)/3.).unsqueeze(-1),torch.exp(-rec/3.).unsqueeze(-1),(torch.log1p(torch.clamp(b['coarse_distance'].float(),min=0.))/2.).unsqueeze(-1)],-1);r=self.rel_emb(b['relation_code'].long().clamp(0,13));return torch.cat([num,r],-1)

    def forward(self,b,return_aux=False,ablate=None,context_override=None):
        abl=set(ablate or []);x,k=self._encode(b['current'],b['faculty_idx'],b['semester_z'])
        P=b['candidate_x'].shape[1]
        if self.variant=='mlp' or 'no_retrieval' in abl:
            ctx=torch.zeros_like(x);att=torch.zeros((len(x),P),device=x.device);pg=torch.zeros((len(x),4),device=x.device);avail=torch.zeros_like(pg)
        else:
            B,P,D=b['candidate_x'].shape;cx=b['candidate_x'].reshape(B*P,D);cf=b['candidate_faculty'].reshape(-1);cs=b['candidate_semester_z'].reshape(-1);ch,ck=self._encode(cx,cf,cs);ch=ch.reshape(B,P,-1);ck=ck.reshape(B,P,-1)
            sim=-(k[:,None,:]-ck).square().sum(-1)/math.sqrt(float(self.key_dim));mask=b['candidate_mask'].bool();meta=self._meta(b)
            label=self.label_encoder(b['candidate_y'].long().clamp(0,1));
            if 'no_labels' in abl:label=torch.zeros_like(label)
            values=label+self.T(k[:,None,:]-ck)
            if self.variant=='sacr' and 'no_relation_meta' not in abl:
                values=values+self.meta_value(meta);sim=sim+self.meta_bias(meta).squeeze(-1)
            if self.variant=='tabr':
                pmask=mask&b['pool_flags'][...,3].bool();ctx,att,valid=self._masked_topk_context(sim,pmask,values,context_override or self.context_size);pg=torch.zeros((B,4),device=x.device);pg[:,3]=valid.float();avail=pg.clone()
            else:
                contexts=[];weights=[];valids=[];counts=[];kpool=int(context_override or self.pool_context)
                disabled={'no_student_pool':0,'no_same_course_pool':1,'no_structural_pool':2,'no_state_pool':3}
                for p in range(4):
                    pm=mask&b['pool_flags'][...,p].bool()
                    if any(a in abl and disabled[a]==p for a in disabled):pm=torch.zeros_like(pm)
                    c,w,v=self._masked_topk_context(sim+self.pool_bias[p],pm,values,kpool);contexts.append(c);weights.append(w);valids.append(v);counts.append(pm.sum(1).float())
                contexts=torch.stack(contexts,1);weights=torch.stack(weights,1);avail=torch.stack(valids,1).float();cnt=torch.stack(counts,1);gate_logits=self.pool_gate(torch.cat([x,torch.log1p(cnt)/3.],-1));gate_logits=gate_logits.masked_fill(~avail.bool(),-1e9);none=~avail.bool().any(1)
                if 'fixed_pool_gates' in abl:gate_logits=torch.zeros_like(gate_logits).masked_fill(~avail.bool(),-1e9)
                if torch.any(none):gate_logits=gate_logits.clone();gate_logits[none]=0.
                pg=F.softmax(gate_logits,dim=-1);pg=torch.where(avail.bool(),pg,torch.zeros_like(pg));pg=torch.where(none[:,None],torch.zeros_like(pg),pg);ctx=(pg.unsqueeze(-1)*contexts).sum(1);att=(pg[:,:,None]*weights).sum(1)
            ctx=self.context_dropout(ctx)
        z=x+ctx
        for block in self.predictor:z=block(z)
        out=self.head(z).squeeze(-1)
        if not return_aux:return out
        return out,{'context':ctx,'candidate_attention':att,'pool_gate':pg,'pool_available':avail}
