# -*- coding: utf-8 -*-
from __future__ import annotations
import copy
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
from suite2_common import equal_budget_metrics

class BundleDataset(Dataset):
    KEYS=['flat','e0_context','fusion_context','gate_context','e1_context','e2_context','e3_context','e4_context','y','teacher','mechanism_targets','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 __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];return {k:torch.as_tensor(getattr(self.b,k)[i]) for k in self.KEYS}
def collate(batch):
    out={k:torch.stack([x[k] for x in batch]) for k in batch[0]};out['y']=out['y'].float();out['teacher']=out['teacher'].float();out['mechanism_targets']=out['mechanism_targets'].float();out['faculty_idx']=out['faculty_idx'].long()
    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','gate_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()};kw=dict(flat=b['flat'],e0_context=b['e0_context'],fusion_context=b['fusion_context'],gate_context=b['gate_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'],committee_probs=b['teacher'],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']);return kw,b

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 _soft_bce(logits,target):return F.binary_cross_entropy_with_logits(logits,target,reduction='mean')

def phase_loss(out,y,teacher,mechanism_targets,phase,aux_lambda=.25,mechanism_lambda=.20,preserve_lambda=.5,recon_lambda=.1,direct_weights=(.5,.1,1.,.35)):
    final=F.binary_cross_entropy_with_logits(out['final_logit'],y);q=teacher.mean(1);preserve=F.binary_cross_entropy_with_logits(out['private_logits'][:,0],q);recon=_soft_bce(out['teacher_logits'],teacher)
    dw=torch.as_tensor([1.0,*direct_weights],dtype=y.dtype,device=y.device)[None,:];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*dw).sum()/(av*dw).sum().clamp_min(1.)
    mech_per=F.binary_cross_entropy_with_logits(out['mechanism_logits'],mechanism_targets,reduction='none');mav=av[:,1:];mechanism=(mech_per*mav).sum()/mav.sum().clamp_min(1.)
    if phase==0:return F.binary_cross_entropy_with_logits(out['private_logits'][:,0],y)+preserve_lambda*preserve+recon_lambda*recon,{'final':final,'private':private,'mechanism':mechanism,'preserve':preserve,'recon':recon}
    if phase==1:
        p14=(per[:,1:]*mav*torch.as_tensor(direct_weights,dtype=y.dtype,device=y.device)[None,:]).sum()/(mav*torch.as_tensor(direct_weights,dtype=y.dtype,device=y.device)[None,:]).sum().clamp_min(1.)
        return p14+mechanism_lambda*mechanism,{'final':final,'private':p14,'mechanism':mechanism,'preserve':preserve,'recon':recon}
    return final+aux_lambda*private+mechanism_lambda*mechanism+preserve_lambda*preserve+recon_lambda*recon,{'final':final,'private':private,'mechanism':mechanism,'preserve':preserve,'recon':recon}

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

def set_phase_mode(model,phase):
    model.train()
    if phase==0:
        for m in [model.e1,model.e2,model.e3,model.e4,model.private_heads,model.mechanism_heads,model.exchange,model.gate_fac,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();model.mechanism_heads.train();model.exchange.eval();model.gate.eval();model.value.eval();model.final.eval()
    elif phase==2:
        for m in [model.e0,model.e1,model.e2,model.e3,model.e4,model.private_heads,model.mechanism_heads]:m.eval()
        model.exchange.train();model.gate_fac.train();model.gate.train();model.value.train();model.final.train()

def build_optimizer(model,phase,lr,weight_decay,e0_lr_scale=.2):
    params=[(n,p) for n,p in model.named_parameters() if p.requires_grad]
    if phase==3:
        e0=[p for n,p in params if n.startswith('e0.')];other=[p for n,p in params if not n.startswith('e0.')];groups=[]
        if e0:groups.append({'params':e0,'lr':lr*float(e0_lr_scale)})
        if other:groups.append({'params':other,'lr':lr})
        return torch.optim.AdamW(groups,weight_decay=weight_decay)
    return torch.optim.AdamW([p for _,p in params],lr=lr,weight_decay=weight_decay)

def predict(model,bundle,mask,batch_size,device,ablate=None):
    model.eval();bag={k:[] for k in ['score','private','mechanism','teacher_pred','gate','tokens','collab_tokens','attention','availability','y','e0_delta','committee']};old0,oldx=model.e0_dropout,model.expert_dropout;model.e0_dropout=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);bag['score'].append(torch.sigmoid(o['final_logit']).cpu().numpy());bag['private'].append(torch.sigmoid(o['private_logits']).cpu().numpy());bag['mechanism'].append(torch.sigmoid(o['mechanism_logits']).cpu().numpy());bag['teacher_pred'].append(torch.sigmoid(o['teacher_logits']).cpu().numpy());bag['gate'].append(o['gate_weights'].cpu().numpy());bag['tokens'].append(o['expert_tokens'].cpu().numpy());bag['collab_tokens'].append(o['collaborative_tokens'].cpu().numpy());bag['attention'].append(o['attention'].cpu().numpy());bag['availability'].append(o['base_availability'].cpu().numpy());bag['y'].append(b['y'].cpu().numpy());bag['e0_delta'].append(o['e0_delta_logit'].cpu().numpy());bag['committee'].append(o['committee_probability'].cpu().numpy())
    model.e0_dropout,model.expert_dropout=old0,oldx
    for k in bag:bag[k]=np.concatenate(bag[k])
    bag['y']=bag['y'].astype(int);return bag

def robust_committee_selection_stats(y,candidate,committee,faculty_idx,faculty_names,f2_weight=.5,mean_weight=.25,beta=2.):
    rows=[];y=np.asarray(y,int);candidate=np.asarray(candidate,float);committee=np.asarray(committee,float);faculty_idx=np.asarray(faculty_idx,int)
    for fi,name in enumerate(faculty_names):
        m=faculty_idx==fi
        if not np.any(m) or np.unique(y[m]).size<2:continue
        apc=safe_ap(y[m],candidate[m]);apq=safe_ap(y[m],committee[m]);f2c=equal_budget_metrics(y[m],candidate[m],.20,beta)['fbeta'];f2q=equal_budget_metrics(y[m],committee[m],.20,beta)['fbeta'];rows.append((name,apc-apq,f2c-f2q))
    if not rows:return {'score':-np.inf,'faculties':0,'ap_wins':0,'f2_wins':0,'median_delta_ap':np.nan,'mean_delta_ap':np.nan,'median_delta_f2':np.nan,'worst_quartile_delta_ap':np.nan}
    da=np.asarray([r[1] for r in rows]);df=np.asarray([r[2] for r in rows]);med=float(np.median(da));mean=float(np.mean(da));mf2=float(np.median(df));return {'score':med+float(f2_weight)*mf2+float(mean_weight)*mean,'faculties':len(rows),'ap_wins':int((da>0).sum()),'f2_wins':int((df>0).sum()),'median_delta_ap':med,'mean_delta_ap':mean,'median_delta_f2':mf2,'mean_delta_f2':float(np.mean(df)),'worst_quartile_delta_ap':float(np.quantile(da,.25)),'rows':rows}

def mechanism_validation_stats(target,pred,faculty_idx,faculty_names):
    target=np.asarray(target,float);pred=np.clip(np.asarray(pred,float),1e-6,1-1e-6);faculty_idx=np.asarray(faculty_idx,int);loss=[]
    for fi,_ in enumerate(faculty_names):
        m=faculty_idx==fi
        if not np.any(m):continue
        b=-(target[m]*np.log(pred[m])+(1-target[m])*np.log(1-pred[m]));loss.append(float(np.mean(b)))
    med=float(np.median(loss)) if loss else np.inf;return {'score':-med,'median_bce':med,'mean_bce':float(np.mean(loss)) if loss else np.inf,'faculties':len(loss)}

def _stats_for_phase(pr,bundle,val_mask,phase,f2_weight,mean_weight,beta):
    idx=np.where(np.asarray(val_mask,bool))[0];y=bundle.y[idx];fac=bundle.faculty_idx[idx];q=bundle.teacher[idx].mean(1)
    if phase==1:return mechanism_validation_stats(bundle.mechanism_targets[idx],pr['mechanism'],fac,bundle.faculty_names)
    candidate=pr['private'][:,0] if phase==0 else pr['score'];return robust_committee_selection_stats(y,candidate,q,fac,bundle.faculty_names,f2_weight,mean_weight,beta)

def train_phase(model,bundle,tr,val,phase,epochs,lr,wd,batch_size,beta,seed,device,aux_lambda,mechanism_lambda,preserve_lambda,recon_lambda,direct_weights,e0_lr_scale=.2,selection_f2_weight=.5,selection_mean_weight=.25,patience=3,samples_per_epoch=0,predict_batch_size=None):
    set_phase_trainable(model,phase);opt=build_optimizer(model,phase,lr,wd,e0_lr_scale);predict_batch_size=int(predict_batch_size or batch_size*4);best=-np.inf;state=copy.deepcopy(model.state_dict());best_ep=0;bad=0;hist=[]
    allow_zero=phase in {0,3}
    if allow_zero:
        pr0=predict(model,bundle,val,predict_batch_size,device);st0=_stats_for_phase(pr0,bundle,val,phase,selection_f2_weight,selection_mean_weight,beta);best=float(st0['score']);state=copy.deepcopy(model.state_dict())
        row={'phase':phase,'epoch':0,'loss':np.nan,'val_score':best,**{f'val_{k}':v for k,v in st0.items() if np.isscalar(v) and k!='score'}};hist.append(row)
        if phase==0:print(f'[PHASE0 INIT] robust={best:+.5f} medΔAP={st0["median_delta_ap"]:+.4f} medΔF2={st0["median_delta_f2"]:+.4f} APwins={st0["ap_wins"]}/{st0["faculties"]} (E0 exactly Committee before optimization)')
        else:print(f'[PHASE3 INIT] robust={best:+.5f} medΔAP={st0["median_delta_ap"]:+.4f} medΔF2={st0["median_delta_f2"]:+.4f} APwins={st0["ap_wins"]}/{st0["faculties"]}')
    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,_=phase_loss(o,b['y'],b['teacher'],b['mechanism_targets'],phase,aux_lambda,mechanism_lambda,preserve_lambda,recon_lambda,direct_weights);loss.backward();params=[p for p in model.parameters() if p.requires_grad];torch.nn.utils.clip_grad_norm_(params,5.);opt.step();tot+=float(loss.detach().cpu())*len(b['y']);n+=len(b['y'])
        pr=predict(model,bundle,val,predict_batch_size,device);st=_stats_for_phase(pr,bundle,val,phase,selection_f2_weight,selection_mean_weight,beta);score=float(st['score']);row={'phase':phase,'epoch':ep,'loss':tot/max(n,1),'val_score':score,**{f'val_{k}':v for k,v in st.items() if np.isscalar(v) and k!='score'}};hist.append(row)
        if phase==1:print(f'[PHASE1] ep={ep:02d}/{epochs} loss={tot/max(n,1):.5f} robust={score:+.5f} mechanismBCE med/mean={st["median_bce"]:.4f}/{st["mean_bce"]:.4f}')
        else:print(f'[PHASE{phase}] ep={ep:02d}/{epochs} loss={tot/max(n,1):.5f} robust={score:+.5f} medΔAP={st["median_delta_ap"]:+.4f} meanΔAP={st["mean_delta_ap"]:+.4f} APwins={st["ap_wins"]}/{st["faculties"]} medΔF2={st["median_delta_f2"]:+.4f} F2wins={st["f2_wins"]}/{st["faculties"]} q25ΔAP={st["worst_quartile_delta_ap"]:+.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>=int(patience):break
    model.load_state_dict(state);return best_ep,pd_dataframe(hist)

def pd_dataframe(rows):
    import pandas as pd
    return pd.DataFrame(rows)

def train_fixed_phase(model,bundle,mask,phase,epochs,lr,wd,batch_size,beta,seed,device,aux_lambda,mechanism_lambda,preserve_lambda,recon_lambda,direct_weights,e0_lr_scale=.2,samples_per_epoch=0):
    if int(epochs)<=0:
        print(f'[REFIT PHASE{phase}] epochs=0 -> preserve incoming state');return
    set_phase_trainable(model,phase);opt=build_optimizer(model,phase,lr,wd,e0_lr_scale)
    for ep in range(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'],b['mechanism_targets'],phase,aux_lambda,mechanism_lambda,preserve_lambda,recon_lambda,direct_weights);loss.backward();torch.nn.utils.clip_grad_norm_([p for p in model.parameters() if p.requires_grad],5.);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}')
