# -*- coding: utf-8 -*-
"""Suite2 Experiment D: multi-window temporal strong-specialist ensemble.

Trains the same strong HGB meta model on all history and recent 6/4/2 temporal
blocks. Historical prequential transitions determine whether to trust the
committee, an equal window mean, or a regularized logistic stack across windows.
"""
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
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

import train_v3 as core
from suite2_common import (
    load_binary_fold,crossfit_committee,fit_production_committee,
    chronological_support_features,v2_meta_features,support_matrix,window_indices_before_block,
    fit_hgb_classifier,predict_positive,effective_weights,select_authority,blend_probability,
    safe_ap,safe_auc,score_metrics,equal_budget_metrics,save_csv,parse_folds,print_metric_line,
)

def window_specs(): return [('all',None),('last6',6),('last4',4),('last2',2)]

def build_features(X,p,support,names):
    meta,mn=v2_meta_features(p);sup,sn=support_matrix(support);return np.column_stack([core.clean_X(X),meta,sup]),list(names)+mn+sn

def _fit_window(Z,y,idx,a,seed):
    if len(idx)<a.min_window_rows or y[idx].sum()<a.min_window_failures or np.unique(y[idx]).size<2:return None
    w,_=effective_weights(y[idx],a.effective_beta)
    return fit_hgb_classifier(Z[idx],y[idx],seed=seed,max_iter=a.window_max_iter,max_leaf_nodes=a.window_leaf_nodes,min_samples_leaf=a.window_min_leaf,learning_rate=a.window_lr,l2_regularization=a.window_l2,sample_weight=w)

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

def _stack_features(matrix):
    return v2_meta_features(np.asarray(matrix,float))[0]

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} | multi-window temporal ensemble | historical={len(ytr):,} test={len(yte):,}')
    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);idx=np.where(cf.covered_mask)[0];Xo=Xtr[idx];yo=ytr[idx];po=cf.probabilities[idx];bo=np.asarray(pd.to_numeric(pd.Series(cf.block_ids[idx]),errors='coerce'),float);qo=core.committee_statistics(po)['committee_mean'];sup_o=chronological_support_features(tr).iloc[idx].reset_index(drop=True);Z,nm=build_features(Xo,po,sup_o,names)
    blocks=sorted(v for v in pd.unique(bo[np.isfinite(bo)]));valid=[]
    for b in blocks:
        m=bo==b
        if m.sum()>=a.transition_min_rows and yo[m].sum()>=a.transition_min_failures: valid.append(float(b))
    transition_blocks=valid[-a.prequential_blocks:]
    trans_rows=[];all_y=[];all_q=[];all_pred=[];all_block=[]
    for bi,b in enumerate(transition_blocks):
        va=np.where(bo==b)[0];preds=[];win_ap={}
        for wi,(name,k) in enumerate(window_specs()):
            ti=window_indices_before_block(bo,b,k);model=_fit_window(Z,yo,ti,a,a.seed+fold*10000+bi*100+wi)
            p=qo[va].copy() if model is None else predict_positive(model,Z[va]);preds.append(p);win_ap[name]=safe_ap(yo[va],p)
            trans_rows.append({'fold':fold,'block':b,'window':name,'train_rows':len(ti),'train_failures':int(yo[ti].sum()),'rows':len(va),'failures':int(yo[va].sum()),'ap':safe_ap(yo[va],p),'auc':safe_auc(yo[va],p),'delta_ap':safe_ap(yo[va],p)-safe_ap(yo[va],qo[va])})
        mat=np.column_stack([qo[va]]+preds);all_y.append(yo[va]);all_q.append(qo[va]);all_pred.append(mat);all_block.append(np.full(len(va),b))
        print(f"  transition block={b} committee AP={safe_ap(yo[va],qo[va]):.4f} | "+' '.join(f'{k}={v:.4f}' for k,v in win_ap.items()))
    if len(transition_blocks)<2:
        selected='committee';authority=0.;lr_final=None;selection_rows=[{'candidate':'committee','authority':0.,'ap':np.nan,'auc':np.nan}]
    else:
        Y=np.concatenate(all_y);Q=np.concatenate(all_q);P=np.vstack(all_pred);B=np.concatenate(all_block);last=transition_blocks[-1];trm=B<last;vam=B==last
        # Candidate 1: equal average of four window specialists (columns 1:).
        equal=P[:,1:].mean(axis=1);eq_best,eq_rows=select_authority(Y[vam],Q[vam],equal[vam],a.authority_grid)
        # Candidate 2: logistic temporal window stacker, trained only on earlier transitions.
        lr=_lr(a.seed+fold);lr.fit(_stack_features(P[trm]),Y[trm]);plr=lr.predict_proba(_stack_features(P[vam]))[:,1];lr_best,lr_rows=select_authority(Y[vam],Q[vam],plr,a.authority_grid)
        candidates=[('committee',{'authority':0.,'ap':safe_ap(Y[vam],Q[vam]),'auc':safe_auc(Y[vam],Q[vam]),'best_f2':score_metrics(Y[vam],Q[vam])['best_f2']}),('equal_window_mean',eq_best),('logistic_window_stack',lr_best)]
        selected,best=max(candidates,key=lambda x:(np.nan_to_num(x[1]['ap'],nan=-1),np.nan_to_num(x[1]['auc'],nan=-1),np.nan_to_num(x[1].get('best_f2',-1),nan=-1),0 if x[0]=='committee' else -1))
        authority=float(best['authority']);selection_rows=[]
        for nm,br in candidates:selection_rows.append({'candidate':nm,**br,'validation_block':last})
        lr_final=None
        if selected=='logistic_window_stack': lr_final=_lr(a.seed+fold+77);lr_final.fit(_stack_features(P),Y)
        print(f"[Temporal selector] validation block={last} selected={selected} authority={authority:.2f} AP/AUC={best['ap']:.4f}/{best['auc']:.4f}")
    # Production window models trained on the most recent eligible OOF blocks.
    _,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);sup_te=chronological_support_features(tr,te);Zt,_=build_features(Xte,pte,sup_te,names)
    latest=max(blocks) if blocks else np.nan;prod=[];prod_rows=[]
    for wi,(name,k) in enumerate(window_specs()):
        if k is None:ti=np.arange(len(yo))
        else:
            elig=sorted(v for v in blocks)[-k:];ti=np.where(np.isin(bo,elig))[0]
        model=_fit_window(Z,yo,ti,a,a.seed+fold*20000+wi);p=qte.copy() if model is None else predict_positive(model,Zt);prod.append(p);prod_rows.append({'fold':fold,'window':name,'train_rows':len(ti),'train_failures':int(yo[ti].sum()),'test_ap':safe_ap(yte,p),'test_auc':safe_auc(yte,p),'delta_ap':safe_ap(yte,p)-safe_ap(yte,qte)})
    PM=np.column_stack([qte]+prod)
    if selected=='committee':final=qte.copy()
    elif selected=='equal_window_mean':final=blend_probability(qte,PM[:,1:].mean(axis=1),authority)
    else:final=blend_probability(qte,lr_final.predict_proba(_stack_features(PM))[:,1],authority)
    print('[Temporal test]');print_metric_line('committee',yte,qte)
    for name,p in zip([x[0] for x in window_specs()],prod):print_metric_line(f'window {name}',yte,p,qte)
    print_metric_line(f'D selected={selected}',yte,final,qte)
    tag=f'{a.faculty}_fold_{fold}';pd.DataFrame({'actual':yte,'committee':qte,'multiwindow':final,**{f'window_{name}':p for (name,_),p in zip(window_specs(),prod)}}).to_csv(outdir/f'{tag}_scores.csv',index=False);save_csv(trans_rows,outdir/f'{tag}_prequential_transitions.csv');save_csv(selection_rows,outdir/f'{tag}_selection.csv');save_csv(prod_rows,outdir/f'{tag}_window_test_metrics.csv')
    coef=[]
    if selected=='logistic_window_stack' and lr_final is not None:
        c=lr_final.named_steps['classifier'].coef_.reshape(-1);coef=[{'fold':fold,'feature_index':i,'coefficient':float(v),'abs_coefficient':abs(float(v))} for i,v in enumerate(c)]
    save_csv(coef,outdir/f'{tag}_stacker_coefficients.csv')
    return {'fold':fold,'y':yte,'committee':qte,'multiwindow':final,**{f'window_{name}':p for (name,_),p in zip(window_specs(),prod)}}

def summary(split,recs):
    y=np.concatenate([r['y'] for r in recs]);rows=[]
    for nm in ['committee','multiwindow']+[f'window_{n}' for n,_ in window_specs()]:
        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/d_multiwindow');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('--window_max_iter',type=int,default=250);p.add_argument('--window_leaf_nodes',type=int,default=31);p.add_argument('--window_min_leaf',type=int,default=20);p.add_argument('--window_lr',type=float,default=.05);p.add_argument('--window_l2',type=float,default=1.0);p.add_argument('--effective_beta',type=float,default=.9999);p.add_argument('--prequential_blocks',type=int,default=5);p.add_argument('--transition_min_rows',type=int,default=300);p.add_argument('--transition_min_failures',type=int,default=15);p.add_argument('--min_window_rows',type=int,default=1200);p.add_argument('--min_window_failures',type=int,default=30);p.add_argument('--authority_grid',type=lambda s:[float(x) for x in s.split(',')],default=[0,.25,.5,.75,1]);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 D — MULTI-WINDOW TEMPORAL HGB ENSEMBLE');print('Strong HGB meta learners: all history / last6 / last4 / last2; prequential selector with committee fallback');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']:18s} AP/AUC={r['ap']:.4f}/{r['auc']:.4f} F2@20%={r['budget20_fbeta']:.4f}")
if __name__=='__main__':main()
