# -*- coding: utf-8 -*-
from __future__ import annotations
import copy,random
import numpy as np
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset,DataLoader,WeightedRandomSampler
from sklearn.metrics import average_precision_score,roc_auc_score
from suite7_common import faculty_class_sampling_weights

class BundleDataset(Dataset):
    def __init__(self,bundle,indices):self.b=bundle;self.idx=np.asarray(indices,int)
    def __len__(self):return len(self.idx)
    def __getitem__(self,j):
        i=self.idx[j];b=self.b
        return {k:torch.as_tensor(getattr(b,k)[i]) for k in ['flat','e0_context','fusion_context','e1_context','e2_context','e3_context','e4_context','y','teacher','faculty_idx','student_seq','student_mask','course_target','course_neighbors','course_neighbor_mask','course_relation_type','relation_events','relation_mask','relation_type','component_events','component_mask','component_type']}

def collate(batch):
    out={}
    for k in batch[0]:out[k]=torch.stack([x[k] for x in batch])
    out['y']=out['y'].float();out['faculty_idx']=out['faculty_idx'].long();out['teacher']=out['teacher'].float()
    for k in ['student_mask','course_neighbor_mask','relation_mask','component_mask']:out[k]=out[k].bool()
    for k in ['course_relation_type','relation_type','component_type']:out[k]=out[k].long()
    for k in ['flat','e0_context','fusion_context','e1_context','e2_context','e3_context','e4_context','student_seq','course_target','course_neighbors','relation_events','component_events']:out[k]=out[k].float()
    return out

def loader(bundle,mask,batch_size,sampled,beta,seed,samples_per_epoch=0):
    idx=np.where(np.asarray(mask,bool))[0];ds=BundleDataset(bundle,idx)
    if not sampled:return DataLoader(ds,batch_size=batch_size,shuffle=False,num_workers=0,collate_fn=collate)
    w,_=faculty_class_sampling_weights(bundle.y[idx],bundle.faculty_idx[idx],bundle.faculty_names,beta)
    gen=torch.Generator();gen.manual_seed(int(seed));ns=len(idx) if int(samples_per_epoch)<=0 else min(max(1,int(samples_per_epoch)),max(len(idx),1)*4);sam=WeightedRandomSampler(torch.as_tensor(w,dtype=torch.double),ns,replacement=True,generator=gen)
    return DataLoader(ds,batch_size=batch_size,sampler=sam,num_workers=0,collate_fn=collate)

def to_model(batch,device):
    b={k:v.to(device) for k,v in batch.items()}
    return dict(flat=b['flat'],e0_context=b['e0_context'],fusion_context=b['fusion_context'],e1_context=b['e1_context'],e2_context=b['e2_context'],e3_context=b['e3_context'],e4_context=b['e4_context'],faculty=b['faculty_idx'],student_seq=b['student_seq'],student_mask=b['student_mask'],course_target=b['course_target'],course_neighbors=b['course_neighbors'],course_neighbor_mask=b['course_neighbor_mask'],course_relation_type=b['course_relation_type'],relation_events=b['relation_events'],relation_mask=b['relation_mask'],relation_type=b['relation_type'],component_events=b['component_events'],component_mask=b['component_mask'],component_type=b['component_type']),b

def soft_bce_logits(logits,target):return F.binary_cross_entropy_with_logits(logits,target,reduction='mean')

def phase_loss(out,y,teacher,phase,aux_lambda=.25,distill_lambda=.1):
    final=F.binary_cross_entropy_with_logits(out['final_logit'],y)
    per=F.binary_cross_entropy_with_logits(out['private_logits'],y[:,None].expand_as(out['private_logits']),reduction='none')
    av=out.get('base_availability',torch.ones_like(per,dtype=torch.bool)).float()
    private=(per*av).sum()/av.sum().clamp_min(1.0)
    dist=soft_bce_logits(out['teacher_logits'],teacher)
    if phase==0:return F.binary_cross_entropy_with_logits(out['private_logits'][:,0],y)+distill_lambda*dist,{'final':float(final.detach()),'private':float(private.detach()),'distill':float(dist.detach())}
    if phase==1:
        per14=F.binary_cross_entropy_with_logits(out['private_logits'][:,1:],y[:,None].expand(-1,4),reduction='none')
        av14=out['base_availability'][:,1:].float();p14=(per14*av14).sum()/av14.sum().clamp_min(1.0)
        return p14,{'final':float(final.detach()),'private':float(p14.detach()),'distill':float(dist.detach())}
    return final+aux_lambda*private+distill_lambda*dist,{'final':float(final.detach()),'private':float(private.detach()),'distill':float(dist.detach())}

def set_phase_trainable(model,phase):
    for p in model.parameters():p.requires_grad=False
    if phase==0:mods=[model.e0]
    elif phase==1:mods=[model.e1,model.e2,model.e3,model.e4,model.private_heads]
    elif phase==2:mods=[model.exchange,model.gate,model.value,model.final]
    else:mods=[model]
    for m in mods:
        for p in m.parameters():p.requires_grad=True

def set_phase_mode(model,phase):
    # Keep the parent in training mode so expert-dropout remains active during
    # fusion training, but freeze stochastic dropout inside encoders that are
    # not being optimized in the current phase.
    model.train()
    if phase==0:
        for m in [model.e1,model.e2,model.e3,model.e4,model.private_heads,model.exchange,model.gate,model.value,model.final]:m.eval()
        model.e0.train()
    elif phase==1:
        model.e0.eval();model.e1.train();model.e2.train();model.e3.train();model.e4.train();model.private_heads.train()
        for m in [model.exchange,model.gate,model.value,model.final]:m.eval()
    elif phase==2:
        for m in [model.e0,model.e1,model.e2,model.e3,model.e4,model.private_heads]:m.eval()
        for m in [model.exchange,model.gate,model.value,model.final]:m.train()
    else:
        model.train()

def predict(model,bundle,mask,batch_size,device,ablate=None):
    model.eval();scores=[];priv=[];teacher_pred=[];gate=[];tokens=[];collab=[];atts=[];avail=[];ys=[]
    old_e0=model.e0_dropout;old_ex=model.expert_dropout;model.e0_dropout=0.;model.expert_dropout=0.
    with torch.no_grad():
      for bt in loader(bundle,mask,batch_size,False,.9999,0):
        kw,b=to_model(bt,device);kw['force_expert_off']=ablate;o=model(**kw)
        scores.append(torch.sigmoid(o['final_logit']).cpu().numpy());priv.append(torch.sigmoid(o['private_logits']).cpu().numpy());teacher_pred.append(torch.sigmoid(o['teacher_logits']).cpu().numpy());gate.append(o['gate_weights'].cpu().numpy());tokens.append(o['expert_tokens'].cpu().numpy());collab.append(o['collaborative_tokens'].cpu().numpy());atts.append(o['attention'].cpu().numpy());avail.append(o['base_availability'].cpu().numpy());ys.append(b['y'].cpu().numpy())
    model.e0_dropout=old_e0;model.expert_dropout=old_ex
    return {'score':np.concatenate(scores),'private':np.concatenate(priv),'teacher_pred':np.concatenate(teacher_pred),'gate':np.concatenate(gate),'tokens':np.concatenate(tokens),'collab_tokens':np.concatenate(collab),'attention':np.concatenate(atts),'availability':np.concatenate(avail),'y':np.concatenate(ys).astype(int)}

def safe_ap(y,s):return float('nan') if np.unique(y).size<2 else float(average_precision_score(y,s))
def safe_auc(y,s):return float('nan') if np.unique(y).size<2 else float(roc_auc_score(y,s))

def train_phase(model,bundle,tr,val,phase,epochs,lr,wd,batch_size,beta,seed,device,aux_lambda,distill_lambda,patience=3,samples_per_epoch=0):
    set_phase_trainable(model,phase);params=[p for p in model.parameters() if p.requires_grad];opt=torch.optim.AdamW(params,lr=lr,weight_decay=wd)
    best=-np.inf;state=copy.deepcopy(model.state_dict());best_ep=1;bad=0;hist=[]
    for ep in range(1,int(epochs)+1):
        set_phase_mode(model,phase);tot=0.;n=0
        for bt in loader(bundle,tr,batch_size,True,beta,seed+phase*1000+ep,samples_per_epoch):
            kw,b=to_model(bt,device);opt.zero_grad(set_to_none=True);o=model(**kw);loss,parts=phase_loss(o,b['y'],b['teacher'],phase,aux_lambda,distill_lambda);loss.backward();torch.nn.utils.clip_grad_norm_(params,5.0);opt.step();tot+=float(loss.detach().cpu())*len(b['y']);n+=len(b['y'])
        pr=predict(model,bundle,val,batch_size*4,device);ap=safe_ap(pr['y'],pr['score']);p0=safe_ap(pr['y'],pr['private'][:,0]);score=ap if phase>=2 else (p0 if phase==0 else float(np.nanmean([safe_ap(pr['y'],pr['private'][:,k]) for k in range(1,5)])))
        hist.append({'phase':phase,'epoch':ep,'loss':tot/max(n,1),'val_score':score,'val_ap_final':ap,'val_ap_e0':p0})
        print(f'[PHASE{phase}] ep={ep:02d}/{epochs} loss={tot/max(n,1):.5f} val_score={score:.4f} finalAP={ap:.4f} E0AP={p0:.4f}')
        if score>best+1e-4:best=score;state=copy.deepcopy(model.state_dict());best_ep=ep;bad=0
        else:bad+=1
        if ep>=2 and bad>=patience:break
    model.load_state_dict(state);return best_ep,hist


def train_fixed_phase(model,bundle,mask,phase,epochs,lr,wd,batch_size,beta,seed,device,aux_lambda,distill_lambda,samples_per_epoch=0):
    set_phase_trainable(model,phase);params=[p for p in model.parameters() if p.requires_grad];opt=torch.optim.AdamW(params,lr=lr,weight_decay=wd)
    for ep in range(1,max(1,int(epochs))+1):
        set_phase_mode(model,phase);tot=0.;n=0
        for bt in loader(bundle,mask,batch_size,True,beta,seed+phase*1000+ep,samples_per_epoch):
            kw,b=to_model(bt,device);opt.zero_grad(set_to_none=True);o=model(**kw);loss,_=phase_loss(o,b['y'],b['teacher'],phase,aux_lambda,distill_lambda);loss.backward();torch.nn.utils.clip_grad_norm_(params,5.0);opt.step();tot+=float(loss.detach().cpu())*len(b['y']);n+=len(b['y'])
        if ep==1 or ep==int(epochs):print(f'[REFIT PHASE{phase}] ep={ep:02d}/{epochs} loss={tot/max(n,1):.5f}')
