# -*- coding: utf-8 -*-
"""Suite2 Experiment B: hybrid relational model as a fourth V2 expert.

Creates chronology-safe relational OOF predictions, then compares:
B1) original-V2-style balanced logistic stacking over 4 experts;
B2) nonlinear HGB competence stacker over the same 4 experts + support signals.
"""
from __future__ import annotations
import sys
from pathlib import Path as _BootstrapPath
_PARENT = str(_BootstrapPath(__file__).resolve().parents[1])
if _PARENT not in sys.path:
    sys.path.insert(0, _PARENT)
import argparse, copy
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from torch.utils.data import DataLoader, TensorDataset

import train_v3 as core
from exp_relational_fm import RelationalFactorizationModel, _fit_one, _predict, prepare_relational_ids, make_side_features, _weights
from suite2_common import (
    load_binary_fold, crossfit_committee, fit_production_committee,
    chronological_support_features, relational_competence_features,
    select_hgb_with_authority, fit_hgb_classifier, predict_positive, effective_weights,
    select_authority, blend_probability, safe_ap, safe_auc, score_metrics,
    equal_budget_metrics, save_csv, parse_folds, permutation_rows, print_metric_line,
)


def make_stack_features(tree_probabilities, relational_probability, support):
    p4=np.column_stack([np.asarray(tree_probabilities,float),np.asarray(relational_probability,float)])
    return relational_competence_features(p4,support)


def _device(spec):
    return torch.device('cuda' if torch.cuda.is_available() and spec != 'cpu' else 'cpu')


def _refit_relational(arrays,y,shape,hybrid,seed,epochs,lr,batch_size,device,student_dim,course_dim,section_dim):
    core.seed_all(seed)
    model=RelationalFactorizationModel(*shape,student_dim=student_dim,course_dim=course_dim,section_dim=section_dim,hybrid=hybrid).to(device)
    opt=torch.optim.AdamW(model.parameters(),lr=lr,weight_decay=1e-4);w=_weights(y)
    ds=TensorDataset(torch.from_numpy(arrays[0]),torch.from_numpy(arrays[1]),torch.from_numpy(arrays[2]),torch.from_numpy(arrays[3].astype('float32')),torch.from_numpy(y.astype('float32')),torch.from_numpy(w));loader=DataLoader(ds,batch_size=batch_size,shuffle=True)
    for _ in range(max(1,int(epochs))):
        model.train()
        for bs,bc,bx,bz,by,bw in loader:
            bs,bc,bx,bz,by,bw=[t.to(device) for t in [bs,bc,bx,bz,by,bw]];opt.zero_grad();z=model(bs,bc,bx,bz);loss=torch.nn.functional.binary_cross_entropy_with_logits(z,by,weight=bw);loss.backward();opt.step()
    return model


def fit_relational_predict(Xhist,yhist,hist_frame,Xtarget,target_frame,names,args,seed):
    """Train hybrid relational model using only history and predict target."""
    if len(yhist)<args.rel_min_train_rows or np.unique(yhist).size<2:
        return np.full(len(Xtarget),float(np.mean(yhist) if len(yhist) else .5)), {'epoch':0,'val_ap':np.nan,'val_auc':np.nan,'fallback':True}
    # Internal temporal validation on history only.
    groups,_=core.extract_temporal_groups(hist_frame);uniq=sorted(v for v in pd.unique(groups[np.isfinite(groups)]))
    trloc=None;valoc=None;vblock=None
    for b in reversed(uniq):
        va=np.where(groups==b)[0];tt=np.where(groups<b)[0]
        if len(va)>=args.rel_val_min_rows and yhist[va].sum()>=args.rel_val_min_failures and len(tt)>=args.rel_min_train_rows and np.unique(yhist[tt]).size==2:
            trloc,valoc,vblock=tt,va,b;break
    if trloc is None:
        # Deterministic stratified fallback without target labels.
        from sklearn.model_selection import train_test_split
        trloc,valoc=train_test_split(np.arange(len(yhist)),test_size=.15,stratify=yhist,random_state=seed);vblock='stratified_fallback'
    ids_h,ids_t,se,ce,xe=prepare_relational_ids(hist_frame,target_frame)
    side_sel_h,side_sel_t,_=make_side_features(Xhist,Xtarget,yhist,names,trloc,args.top_raw_features)
    arr_sel=(*ids_h,side_sel_h);shape=(se.size,ce.size,xe.size,side_sel_h.shape[1]);dev=_device(args.device)
    model,ep,(vap,vauc)=_fit_one(arr_sel,yhist,np.asarray(trloc),np.asarray(valoc),shape,True,seed,args.rel_epochs,args.rel_patience,args.rel_lr,args.rel_batch_size,dev,args.student_dim,args.course_dim,args.section_dim)
    # Fresh refit on all history, selector fitted on all historical labels.
    full=np.arange(len(yhist));side_h,side_t,_=make_side_features(Xhist,Xtarget,yhist,names,full,args.top_raw_features);arr_h=(*ids_h,side_h);arr_t=(*ids_t,side_t)
    final=_refit_relational(arr_h,yhist,shape,True,seed+991,ep,args.rel_lr,args.rel_batch_size,dev,args.student_dim,args.course_dim,args.section_dim)
    p=_predict(final,arr_t,dev,args.rel_predict_batch)
    return p, {'epoch':int(ep),'val_ap':float(vap),'val_auc':float(vauc),'validation_block':str(vblock),'fallback':False,'new_student_rate':float(np.mean(ids_t[0]==0)),'new_course_rate':float(np.mean(ids_t[1]==0))}


def relational_temporal_oof(X,y,frame,names,args,seed):
    groups,source=core.extract_temporal_groups(frame);out=np.full(len(y),np.nan);rows=[]
    if not np.isfinite(groups).any(): return out,rows
    for j,b in enumerate(sorted(v for v in pd.unique(groups[np.isfinite(groups)]))):
        tr=np.where(groups<b)[0];te=np.where(groups==b)[0]
        if len(tr)<args.rel_min_train_rows or len(te)==0 or np.unique(y[tr]).size<2: continue
        p,info=fit_relational_predict(X[tr],y[tr],frame.iloc[tr].reset_index(drop=True),X[te],frame.iloc[te].reset_index(drop=True),names,args,seed+j*101)
        out[te]=p
        rows.append({'block':float(b),'train_rows':len(tr),'test_rows':len(te),'failures':int(y[te].sum()),'prevalence':float(y[te].mean()),'relational_ap':safe_ap(y[te],p),'relational_auc':safe_auc(y[te],p),**info})
        print(f"  relational OOF block={b} train={len(tr):,} test={len(te):,} AP/AUC={safe_ap(y[te],p):.4f}/{safe_auc(y[te],p):.4f} cold student/course={info.get('new_student_rate',np.nan):.1%}/{info.get('new_course_rate',np.nan):.1%}")
    return out,rows


def _lr_model(seed):
    return Pipeline([('scaler',StandardScaler()),('classifier',LogisticRegression(class_weight='balanced',C=.5,max_iter=3000,solver='liblinear',random_state=seed))])


def run_fold(a,fold,outdir):
    d=load_binary_fold(a.splits_dir,a.faculty,fold)
    if d is None:return None
    Xtr,Xte,ytr,yte,tr,te,names=d
    print('\n'+'='*118);print(f'FOLD {fold} | historical={len(ytr):,} test={len(yte):,} fail={ytr.mean():.2%}->{yte.mean():.2%}')
    cf=crossfit_committee(Xtr,ytr,tr,seed=a.seed+fold*31,n_estimators=a.n_estimators,hist_max_iter=a.hist_max_iter,crossfit_folds=a.crossfit_folds,verbose=False)
    rel_oof,block_rows=relational_temporal_oof(Xtr,ytr,tr,names,a,a.seed+fold*10000)
    common=cf.covered_mask & np.isfinite(rel_oof);idx=np.where(common)[0]
    if len(idx)<a.min_meta_rows or ytr[idx].sum()<a.min_meta_failures: raise RuntimeError(f'Fold {fold}: insufficient common OOF rows {len(idx)}')
    yo=ytr[idx];po=cf.probabilities[idx];ro=rel_oof[idx];bo=cf.block_ids[idx];qo=core.committee_statistics(po)['committee_mean'];support_hist=chronological_support_features(tr).iloc[idx].reset_index(drop=True)
    Z,nm=make_stack_features(po,ro,support_hist)
    mt,mv,vinfo=core.choose_multiblock_validation(yo,bo,cf.mode,a.validation_min_rows,a.validation_min_failures,a.validation_min_blocks,a.seed+fold)
    print(f"[Stacker temporal selection] common OOF={len(idx):,} train={len(mt):,} val={len(mv):,} blocks={vinfo.get('validation_blocks')}")
    # B1 original-style LR stacker + committee authority safeguard.
    lr=_lr_model(a.seed+fold);lr.fit(Z[mt],yo[mt]);plr=lr.predict_proba(Z[mv])[:,1];lr_a,lr_arows=select_authority(yo[mv],qo[mv],plr,a.authority_grid)
    lr_final=_lr_model(a.seed+fold+99);lr_final.fit(Z,yo)
    # B2 nonlinear HGB stacker.
    hgb_sel=select_hgb_with_authority(Z[mt],yo[mt],Z[mv],yo[mv],qo[mv],seed=a.seed+fold*211,max_iter=a.stacker_max_iter,authority_grid=a.authority_grid,beta=a.effective_beta)
    wh,_=effective_weights(yo,a.effective_beta);hgb_final=fit_hgb_classifier(Z,yo,seed=a.seed+fold*223,sample_weight=wh,**hgb_sel['params'])
    # Production experts + relational fourth expert.
    _,pte,qte=fit_production_committee(Xtr,ytr,Xte,seed=a.seed+fold*17,n_estimators=a.n_estimators,hist_max_iter=a.hist_max_iter)
    rel_te,rel_info=fit_relational_predict(Xtr,ytr,tr,Xte,te,names,a,a.seed+fold*20000)
    support_te=chronological_support_features(tr,te);Zte,_=make_stack_features(pte,rel_te,support_te)
    plr_te=lr_final.predict_proba(Zte)[:,1];phgb_te=predict_positive(hgb_final,Zte)
    slr=blend_probability(qte,plr_te,lr_a['authority']);shgb=blend_probability(qte,phgb_te,hgb_sel['authority'])
    print('[Validation selection]');print(f"  LR stack4  authority={lr_a['authority']:.2f} AP/AUC={lr_a['ap']:.4f}/{lr_a['auc']:.4f}");print(f"  HGB stack4 authority={hgb_sel['authority']:.2f} AP/AUC={hgb_sel['validation']['ap']:.4f}/{hgb_sel['validation']['auc']:.4f}")
    print('[Temporal test]');print_metric_line('committee',yte,qte);print_metric_line('relational standalone',yte,rel_te,qte);print_metric_line('B1 LR stack4',yte,slr,qte);print_metric_line('B2 HGB stack4',yte,shgb,qte);print(f"  target cold student/course={rel_info.get('new_student_rate',np.nan):.1%}/{rel_info.get('new_course_rate',np.nan):.1%}")
    tag=f'{a.faculty}_fold_{fold}'
    regimes=np.asarray(['history0' if x==0 else ('history1_2' if x<=2 else 'history3plus') for x in support_te.history_semesters])
    pd.DataFrame({'actual':yte,'committee':qte,'relational':rel_te,'lr_stack4':slr,'hgb_stack4':shgb,'history_regime':regimes,**{c:support_te[c].to_numpy() for c in support_te.columns}}).to_csv(outdir/f'{tag}_scores.csv',index=False)
    save_csv([{'fold':fold,**r} for r in block_rows],outdir/f'{tag}_relational_oof_blocks.csv')
    save_csv([{'fold':fold,'stacker':'lr',**r} for r in lr_arows]+[{'fold':fold,'stacker':'hgb',**r} for r in hgb_sel['authority_rows']],outdir/f'{tag}_authority_grid.csv')
    coef=[]
    try:
        c=lr_final.named_steps['classifier'].coef_.reshape(-1);coef=[{'fold':fold,'feature':nm[i],'coefficient':float(c[i]),'abs_coefficient':abs(float(c[i]))} for i in np.argsort(-np.abs(c))[:30]]
    except Exception:pass
    save_csv(coef,outdir/f'{tag}_lr_coefficients.csv')
    imp=permutation_rows(hgb_sel['model'],Z[mv],yo[mv],nm,seed=a.seed+fold,top_k=30);save_csv([{'fold':fold,**r} for r in imp],outdir/f'{tag}_hgb_importance.csv')
    # regime diagnostics
    rr=[]
    for g in ['history0','history1_2','history3plus']:
        m=regimes==g
        if not m.any():continue
        for model,sc in [('committee',qte),('relational',rel_te),('lr_stack4',slr),('hgb_stack4',shgb)]: rr.append({'fold':fold,'regime':g,'model':model,'rows':int(m.sum()),'failures':int(yte[m].sum()),'prevalence':float(yte[m].mean()),'ap':safe_ap(yte[m],sc[m]),'auc':safe_auc(yte[m],sc[m])})
    save_csv(rr,outdir/f'{tag}_history_regimes.csv')
    return {'fold':fold,'y':yte,'committee':qte,'relational':rel_te,'lr_stack4':slr,'hgb_stack4':shgb}


def summary(split,recs):
    y=np.concatenate([r['y'] for r in recs]);rows=[]
    for nm in ['committee','relational','lr_stack4','hgb_stack4']:
        s=np.concatenate([r[nm] for r in recs]);rows.append({'split':split,'model':nm,**score_metrics(y,s),**{f'budget20_{k}':v for k,v in equal_budget_metrics(y,s,.20).items() if k in ['precision','recall','fbeta','flag_rate']}})
    return rows


def parse_args():
    p=argparse.ArgumentParser();p.add_argument('--splits_dir',required=True);p.add_argument('--faculty',default='khoa_cong_nghe_thong_tin');p.add_argument('--dev_folds',default='1,2,3,4,5');p.add_argument('--holdout_folds',default='6,7');p.add_argument('--models_dir',default='results/suite2/b_relational_stacker');p.add_argument('--seed',type=int,default=42);p.add_argument('--n_estimators',type=int,default=500);p.add_argument('--hist_max_iter',type=int,default=250);p.add_argument('--crossfit_folds',type=int,default=5);p.add_argument('--stacker_max_iter',type=int,default=250);p.add_argument('--validation_min_rows',type=int,default=5000);p.add_argument('--validation_min_failures',type=int,default=150);p.add_argument('--validation_min_blocks',type=int,default=2);p.add_argument('--effective_beta',type=float,default=.9999);p.add_argument('--authority_grid',type=lambda s:[float(x) for x in s.split(',')],default=[0,.25,.5,.75,1]);p.add_argument('--min_meta_rows',type=int,default=5000);p.add_argument('--min_meta_failures',type=int,default=100);p.add_argument('--top_raw_features',type=int,default=48);p.add_argument('--student_dim',type=int,default=16);p.add_argument('--course_dim',type=int,default=16);p.add_argument('--section_dim',type=int,default=8);p.add_argument('--rel_epochs',type=int,default=40);p.add_argument('--rel_patience',type=int,default=6);p.add_argument('--rel_lr',type=float,default=2e-3);p.add_argument('--rel_batch_size',type=int,default=1024);p.add_argument('--rel_predict_batch',type=int,default=4096);p.add_argument('--rel_min_train_rows',type=int,default=1200);p.add_argument('--rel_val_min_rows',type=int,default=300);p.add_argument('--rel_val_min_failures',type=int,default=15);p.add_argument('--device',choices=['auto','cpu'],default='auto');return p.parse_args()


def main():
    a=parse_args();out=Path(a.models_dir);out.mkdir(parents=True,exist_ok=True)
    print('='*118);print('SUITE2 EXPERIMENT B — RELATIONAL FOURTH EXPERT STACKING');print('Chronological hybrid relational OOF -> B1 V2-style LR stacker / B2 HGB competence stacker');print('='*118)
    dev=[r for f in parse_folds(a.dev_folds) if (r:=run_fold(a,f,out)) is not None];hold=[r for f in parse_folds(a.holdout_folds) if (r:=run_fold(a,f,out)) is not None]
    rows=[]
    if dev:rows+=summary('development',dev)
    if hold:rows+=summary('holdout',hold)
    save_csv(rows,out/f'{a.faculty}_summary.csv')
    for r in rows:print(f"{r['split'].upper():11s} {r['model']:16s} AP/AUC={r['ap']:.4f}/{r['auc']:.4f} F2@20%={r['budget20_fbeta']:.4f}")
if __name__=='__main__':main()
