# -*- coding: utf-8 -*-
from __future__ import annotations
import numpy as np
import pandas as pd

import train_v3 as core
from suite2_common import safe_ap, safe_auc, score_metrics, equal_budget_metrics, window_indices_before_block


def quantile_align_to_reference(source, reference):
    s=np.asarray(source,float).reshape(-1); r=np.asarray(reference,float).reshape(-1)
    if len(s)!=len(r): raise ValueError('source/reference length mismatch')
    if len(s)==0:return s.copy()
    order=np.argsort(s,kind='mergesort'); ss=s[order]; sr=np.sort(r)
    out_sorted=np.empty_like(ss,dtype=float)
    start=0
    while start < len(ss):
        end=start+1
        while end < len(ss) and ss[end] == ss[start]:
            end += 1
        out_sorted[start:end] = float(np.mean(sr[start:end]))
        start=end
    out=np.empty_like(s,dtype=float); out[order]=out_sorted
    return np.clip(out,1e-7,1-1e-7)


def blockwise_quantile_align(source, reference, blocks):
    s=np.asarray(source,float); r=np.asarray(reference,float); b=np.asarray(blocks)
    if not(len(s)==len(r)==len(b)): raise ValueError('length mismatch')
    out=np.empty_like(s,dtype=float)
    for v in pd.unique(b):
        m=(b==v)
        out[m]=quantile_align_to_reference(s[m],r[m])
    return out


def fusion_grid(weight_values=(0,.25,.5,.75,1), rel_values=(0,.1,.2,.3,.4)):
    rows=[]
    for wa in weight_values:
        for wr in weight_values:
            if wa+wr>1+1e-12:continue
            for ar in rel_values:
                rows.append({'w_a1':float(wa),'w_recent':float(wr),'rel_alpha':float(ar),'w_committee':float(1-wa-wr)})
    return rows


def apply_composite(q,a1,recent,relational,rich_mask,w_a1,w_recent,rel_alpha):
    q=np.asarray(q,float);a1=np.asarray(a1,float);recent=np.asarray(recent,float);rel=np.asarray(relational,float);rich=np.asarray(rich_mask,bool)
    wc=1-float(w_a1)-float(w_recent)
    if wc < -1e-10:raise ValueError('non-convex weights')
    base=wc*q+float(w_a1)*a1+float(w_recent)*recent
    final=base.copy()
    if float(rel_alpha)>0 and rich.any():final[rich]=(1-float(rel_alpha))*base[rich]+float(rel_alpha)*rel[rich]
    return np.clip(base,1e-7,1-1e-7),np.clip(final,1e-7,1-1e-7)


def select_robust_weights(y,blocks,q,a1,recent,relational,rich_mask,weight_values=(0,.25,.5,.75,1),rel_values=(0,.1,.2,.3,.4),min_median_delta_ap=.001,min_win_rate=.6,worst_delta_ap=-.005):
    y=np.asarray(y,int);blocks=np.asarray(blocks);q=np.asarray(q,float)
    rows=[]; candidates=[]
    for g in fusion_grid(weight_values,rel_values):
        _,s=apply_composite(q,a1,recent,relational,rich_mask,g['w_a1'],g['w_recent'],g['rel_alpha'])
        deltas=[];ad=[]
        for b in pd.unique(blocks):
            m=blocks==b
            if m.sum()<2 or np.unique(y[m]).size<2:continue
            d=safe_ap(y[m],s[m])-safe_ap(y[m],q[m]); da=safe_auc(y[m],s[m])-safe_auc(y[m],q[m])
            deltas.append(d);ad.append(da)
        if not deltas:continue
        med=float(np.nanmedian(deltas));mean=float(np.nanmean(deltas));worst=float(np.nanmin(deltas));win=float(np.mean(np.asarray(deltas)>0));auc_med=float(np.nanmedian(ad))
        eligible=(med>=min_median_delta_ap and win>=min_win_rate and worst>=worst_delta_ap)
        rec={**g,'median_delta_ap':med,'mean_delta_ap':mean,'worst_delta_ap':worst,'win_rate':win,'median_delta_auc':auc_med,'eligible':bool(eligible)}
        rows.append(rec);candidates.append((rec,s))
    committee={'w_a1':0.,'w_recent':0.,'rel_alpha':0.,'w_committee':1.,'median_delta_ap':0.,'mean_delta_ap':0.,'worst_delta_ap':0.,'win_rate':0.,'median_delta_auc':0.,'eligible':True,'reason':'committee_fallback_no_robust_uplift'}
    eligible=[r for r,_ in candidates if r['eligible'] and (r['w_a1']>0 or r['w_recent']>0 or r['rel_alpha']>0)]
    if not eligible:return committee,rows
    best=max(eligible,key=lambda r:(r['median_delta_ap'],r['mean_delta_ap'],r['win_rate'],r['median_delta_auc'],-(r['w_a1']+r['w_recent']+r['rel_alpha'])))
    best=dict(best);best['reason']='robust_prequential_uplift';return best,rows


def score_distribution(x):
    a=np.asarray(x,float)
    if len(a)==0:return {'mean':np.nan,'std':np.nan,'q10':np.nan,'q50':np.nan,'q90':np.nan}
    return {'mean':float(np.mean(a)),'std':float(np.std(a)),'q10':float(np.quantile(a,.1)),'q50':float(np.quantile(a,.5)),'q90':float(np.quantile(a,.9))}


def spearman_rank_corr(a,b):
    a=pd.Series(np.asarray(a,float));b=pd.Series(np.asarray(b,float))
    return float(a.corr(b,method='spearman')) if len(a)>1 else np.nan


def evaluate_fixed_threshold(y,score,threshold,beta=2.):
    y=np.asarray(y,int);s=np.asarray(score,float);pred=(s>=float(threshold)).astype(int)
    return core.report(y,s,pred,beta)
