# -*- coding: utf-8 -*-
"""Chronology-safe collaboration-authority calibration for Suite14."""
from __future__ import annotations
import math
import numpy as np
from sklearn.metrics import average_precision_score
from suite2_common import equal_budget_metrics


def _sigmoid(x):
    x=np.asarray(x,float);return 1.0/(1.0+np.exp(-np.clip(x,-40,40)))


def apply_authority_numpy(e0_logit,collab_delta,row_authority,scale):
    return _sigmoid(np.asarray(e0_logit,float)+float(scale)*np.asarray(row_authority,float)*np.asarray(collab_delta,float))


def _safe_ap(y,s):
    y=np.asarray(y,int);return float('nan') if np.unique(y).size<2 else float(average_precision_score(y,s))


def _one_block(y,e0_logit,collab_delta,row_authority,scale,beta=2.):
    y=np.asarray(y,int);e0=_sigmoid(e0_logit);cand=apply_authority_numpy(e0_logit,collab_delta,row_authority,scale)
    ap0=_safe_ap(y,e0);ap=_safe_ap(y,cand)
    f0=equal_budget_metrics(y,e0,.20,beta)['fbeta'] if np.unique(y).size>1 else np.nan
    f=equal_budget_metrics(y,cand,.20,beta)['fbeta'] if np.unique(y).size>1 else np.nan
    return {'ap':ap,'ap_e0':ap0,'delta_ap':ap-ap0,'f2':f,'f2_e0':f0,'delta_f2':f-f0}


def select_faculty_authority(y,e0_logit,collab_delta,row_authority,grid=(0,.25,.5,.75,1),beta=2.,blocks=None,f2_weight=.5,mean_weight=.25):
    """Select the smallest authority among tied chronology-safe validation scores.

    When blocks are supplied, selection optimizes temporal median gain and reports
    block-level win counts. Authority 0 is always a valid exact-E0 fallback.
    """
    y=np.asarray(y,int);e0_logit=np.asarray(e0_logit,float);collab_delta=np.asarray(collab_delta,float);row_authority=np.asarray(row_authority,float)
    if blocks is None:blocks=np.zeros(len(y),int)
    blocks=np.asarray(blocks)
    uniq=[b for b in sorted(np.unique(blocks)) if np.sum(blocks==b)>0 and np.unique(y[blocks==b]).size>1]
    if not uniq and np.unique(y).size>1:uniq=[None]
    candidates=[]
    for scale in sorted(set(float(x) for x in grid)):
        rows=[]
        for b in uniq:
            m=np.ones(len(y),bool) if b is None else blocks==b
            rows.append(_one_block(y[m],e0_logit[m],collab_delta[m],row_authority[m],scale,beta))
        if not rows:
            med_ap=mean_ap=med_f2=-np.inf;score=-np.inf;ap_wins=f2_wins=0
        else:
            da=np.asarray([r['delta_ap'] for r in rows],float);df=np.asarray([r['delta_f2'] for r in rows],float)
            med_ap=float(np.nanmedian(da));mean_ap=float(np.nanmean(da));med_f2=float(np.nanmedian(df));score=med_ap+float(f2_weight)*med_f2+float(mean_weight)*mean_ap;ap_wins=int(np.sum(da>0));f2_wins=int(np.sum(df>0))
        candidates.append({'authority':scale,'score':score,'delta_ap':med_ap,'mean_delta_ap':mean_ap,'delta_f2':med_f2,'ap_wins':ap_wins,'f2_wins':f2_wins,'blocks':len(rows),'block_rows':rows})
    # Prefer exact/smaller authority when scores are essentially tied.
    best=max(candidates,key=lambda r:(round(r['score'],10),-r['authority']))
    out={k:v for k,v in best.items() if k!='block_rows'};out['grid_rows']=candidates
    return out


def calibrate_authorities(y,e0_logit,collab_delta,row_authority,faculty_idx,faculty_names,blocks,grid=(0,.25,.5,.75,1),beta=2.,f2_weight=.5,mean_weight=.25):
    rows=[];faculty_idx=np.asarray(faculty_idx,int)
    for fi,name in enumerate(faculty_names):
        m=faculty_idx==fi
        if not np.any(m):continue
        r=select_faculty_authority(np.asarray(y)[m],np.asarray(e0_logit)[m],np.asarray(collab_delta)[m],np.asarray(row_authority)[m],grid,beta,np.asarray(blocks)[m],f2_weight,mean_weight);r['faculty']=name;rows.append(r)
    return rows


def broad_success_from_rows(rows,win_fraction=.60):
    valid=[r for r in rows if r.get('blocks',0)>0]
    if not valid:return False,{'faculties':0,'median_delta_ap':np.nan,'median_delta_f2':np.nan,'ap_wins':0}
    da=np.asarray([r['delta_ap'] for r in valid],float);df=np.asarray([r['delta_f2'] for r in valid],float)
    ap_wins=int(np.sum(da>0));need=int(math.ceil(float(win_fraction)*len(valid)))
    ok=bool(np.median(da)>0 and np.median(df)>=0 and ap_wins>=need)
    return ok,{'faculties':len(valid),'median_delta_ap':float(np.median(da)),'mean_delta_ap':float(np.mean(da)),'median_delta_f2':float(np.median(df)),'ap_wins':ap_wins,'required_ap_wins':need}


def deployment_authorities(rows,faculty_names,broad_success,local_min_ap=.01,local_min_f2=0.,local_min_win_fraction=.67):
    by={r['faculty']:r for r in rows};auth={name:0.0 for name in faculty_names};reasons={}
    if broad_success:
        for name in faculty_names:
            r=by.get(name)
            if not r:reasons[name]='no_calibration';continue
            cap=float(r.get('authority',0));cap_ap=float(r.get('confirm_delta_ap',r.get('delta_ap',0.)));cap_f2=float(r.get('confirm_delta_f2',r.get('delta_f2',0.)))
            if cap>0 and cap_ap>=0 and cap_f2>=-0.005:
                auth[name]=cap;reasons[name]='broad_success_selected'
            else:reasons[name]='broad_success_local_e0_guard'
        return auth,{'mode':'broad_success','reasons':reasons}
    for name in faculty_names:
        r=by.get(name)
        if not r:reasons[name]='no_calibration';continue
        blocks=max(int(r.get('blocks',0)),1);win_fraction=float(r.get('ap_wins',0))/blocks
        local_ap=float(r.get('confirm_delta_ap',r.get('delta_ap',-np.inf)));local_f2=float(r.get('confirm_delta_f2',r.get('delta_f2',-np.inf)))
        strong=(float(r.get('authority',0))>0 and local_ap>=float(local_min_ap) and local_f2>=float(local_min_f2) and win_fraction>=float(local_min_win_fraction))
        if strong:auth[name]=float(r['authority']);reasons[name]='strong_local_temporal_evidence'
        else:reasons[name]='fallback_e0'
    return auth,{'mode':'local_safe_fallback','reasons':reasons}
