# -*- coding: utf-8 -*-
from __future__ import annotations
from pathlib import Path
import numpy as np
import pandas as pd
import train_v3 as core
from suite2_common import safe_ap,safe_auc


def drift_rate_for_fold(fold,warning_ratio,prevalences,development_fallback):
    prev=float(prevalences.get(int(fold)-1,development_fallback))
    return float(np.clip(float(warning_ratio)*prev,1e-4,.99))


def metric_row(y,s,beta=2.0,pred=None):
    y=np.asarray(y,int);s=np.asarray(s,float)
    if pred is None:pred=core.warn_by_rate(s,.20)
    m=core.report(y,s,pred,beta)
    return {'ap':safe_ap(y,s),'auc':safe_auc(y,s),**m}


def print_confusion(title,m):
    print(f'\n  Confusion matrix — {title}')
    print('  ------------------------------------------------------------------')
    print('  Actual / Predicted            Normal >=5      Failure <5')
    print('  ------------------------------------------------------------------')
    print(f'  Normal >=5                    {m["tn"]:10,d}      {m["fp"]:10,d}')
    print(f'  Failure <5                    {m["fn"]:10,d}      {m["tp"]:10,d}')
    print('  ------------------------------------------------------------------')
    spec=m['tn']/max(m['tn']+m['fp'],1);rec=m['recall']
    print(f'  Normal correctly rejected: {spec:.2%}')
    print(f'  Failures successfully detected: {rec:.2%}')


def tune_faculty_policy(records,faculty,model,dev_folds,beta=2.0,min_precision=.15,max_warning_ratio=2.5,min_flags=5):
    use=[r for r in records if r['faculty']==faculty and r['fold'] in dev_folds and model in r['scores']]
    y=np.concatenate([r['y'] for r in use]);s=np.concatenate([r['scores'][model] for r in use])
    return core.tune_threshold(y,s,None,None,beta,min_precision,max_warning_ratio,min_flags,False)


def evaluate_faculty(records,faculty,model,dev_folds,holdout_folds,beta=2.0,min_precision=.15,max_warning_ratio=2.5,min_flags=5,verbose=True):
    pol=tune_faculty_policy(records,faculty,model,dev_folds,beta,min_precision,max_warning_ratio,min_flags)
    prev={r['fold']:float(np.mean(r['y'])) for r in records if r['faculty']==faculty}
    devrows=[r for r in records if r['faculty']==faculty and r['fold'] in dev_folds]
    fallback=float(np.mean(np.concatenate([r['y'] for r in devrows])))
    out=[]
    if verbose:
        print(f'\n### HOLDOUT (test) [faculty={faculty}, model={model}, beta={beta:g}]')
        print('  fold    test   base% |      AP     AUC |     P@t     R@t    F1@t    Fβ@t   rate@t |     P@r     R@r    F1@r    Fβ@r   rate@r')
    pool={'y':[],'s':[],'pf':[],'pd':[]}
    for r in sorted([x for x in records if x['faculty']==faculty and x['fold'] in holdout_folds],key=lambda x:x['fold']):
        y=np.asarray(r['y'],int);s=np.asarray(r['scores'][model],float)
        rate=drift_rate_for_fold(r['fold'],pol.warning_ratio,prev,fallback)
        pf=core.apply_decision_rule(s,pol.threshold);pdri=core.warn_by_rate(s,rate)
        mf=core.report(y,s,pf,beta);md=core.report(y,s,pdri,beta);ap=safe_ap(y,s);auc=safe_auc(y,s)
        if verbose:
            print(f'{r["fold"]:6d} {len(y):7d} {np.mean(y):7.2%} | {ap:7.4f} {auc:7.4f} | {mf["precision"]:7.4f} {mf["recall"]:7.4f} {mf["f1"]:7.4f} {mf["fbeta"]:7.4f} {mf["flag_rate"]:8.2%} | {md["precision"]:7.4f} {md["recall"]:7.4f} {md["f1"]:7.4f} {md["fbeta"]:7.4f} {md["flag_rate"]:8.2%}')
            print_confusion(f'fold {r["fold"]} — fixed development threshold {pol.threshold:.6f}',mf)
            print_confusion(f'fold {r["fold"]} — drift-aware rate {rate:.3%}',md)
        out += [
            {'faculty':faculty,'model':model,'fold':r['fold'],'split':'holdout','policy':'fixed','threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'ap':ap,'auc':auc,**mf},
            {'faculty':faculty,'model':model,'fold':r['fold'],'split':'holdout','policy':'drift','threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'ap':ap,'auc':auc,**md},
        ]
        for k,v in [('y',y),('s',s),('pf',pf),('pd',pdri)]:pool[k].append(v)
    if pool['y']:
        y=np.concatenate(pool['y']);s=np.concatenate(pool['s']);pf=np.concatenate(pool['pf']);pdri=np.concatenate(pool['pd'])
        mf=core.report(y,s,pf,beta);md=core.report(y,s,pdri,beta);ap=safe_ap(y,s);auc=safe_auc(y,s)
        if verbose:
            print('-'*132)
            print(f'POOLED {len(y):7d} {np.mean(y):7.2%} | {ap:7.4f} {auc:7.4f} | {mf["precision"]:7.4f} {mf["recall"]:7.4f} {mf["f1"]:7.4f} {mf["fbeta"]:7.4f} {mf["flag_rate"]:8.2%} | {md["precision"]:7.4f} {md["recall"]:7.4f} {md["f1"]:7.4f} {md["fbeta"]:7.4f} {md["flag_rate"]:8.2%}')
            print_confusion('POOLED — fixed development threshold',mf);print_confusion('POOLED — drift-aware warning policy',md)
        out += [
            {'faculty':faculty,'model':model,'fold':'POOLED','split':'holdout','policy':'fixed','threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'ap':ap,'auc':auc,**mf},
            {'faculty':faculty,'model':model,'fold':'POOLED','split':'holdout','policy':'drift','threshold':pol.threshold,'warning_ratio':pol.warning_ratio,'ap':ap,'auc':auc,**md},
        ]
    return pol,out


def macro_holdout_summary(warning_df,model,policy='drift'):
    d=warning_df[(warning_df.model==model)&(warning_df.policy==policy)&(warning_df.fold.astype(str)=='POOLED')].copy()
    if d.empty:return {}
    return {f'macro_mean_{k}':float(d[k].mean()) for k in ['ap','auc','precision','recall','f1','fbeta','flag_rate']}


def merge_reference_comparison(our_pooled,reference_csv):
    if not reference_csv:return our_pooled
    ref=pd.read_csv(reference_csv)
    return our_pooled.merge(ref,on='faculty',how='left',suffixes=('','_reference'))
