"""Suite33 deterministic utilities, metrics and immutable experiment metadata."""
from __future__ import annotations
import hashlib, json, os, platform, sys, time
from pathlib import Path
from datetime import datetime, timezone
import numpy as np
import pandas as pd
from sklearn.metrics import average_precision_score, roc_auc_score, brier_score_loss, log_loss
from sklearn.ensemble import HistGradientBoostingClassifier

ARMS=('S0','S1','S2','S3','S4','P1')

def log(tag, **data):
    def fmt(v):
        if isinstance(v,(float,np.floating)):return f'{v:.6f}' if np.isfinite(v) else str(v)
        if isinstance(v,(dict,list,tuple)):return json.dumps(v,ensure_ascii=False,default=str,separators=(',',':'))
        return str(v)
    print('['+tag+'] '+' '.join(f'{k}={fmt(v)}' for k,v in data.items()),flush=True)

def seed(*parts):return int.from_bytes(hashlib.sha256('|'.join(map(str,parts)).encode()).digest()[:4],'little')
def sha(path):
    h=hashlib.sha256()
    with open(path,'rb') as f:
        for c in iter(lambda:f.read(2**20),b''):h.update(c)
    return h.hexdigest()
def save_json(path,thing):
    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
    tmp=path.with_suffix(path.suffix+'.tmp');tmp.write_text(json.dumps(thing,indent=2,default=str,ensure_ascii=False));tmp.replace(path)
def save_csv(path,data):
    path=Path(path);path.parent.mkdir(parents=True,exist_ok=True)
    pd.DataFrame(data).to_csv(path,index=False)

def binary_stats(y,chosen):
    y=np.asarray(y,dtype=bool);z=np.asarray(chosen,dtype=bool)
    tp=int(np.sum(y&z));fp=int(np.sum(~y&z));fn=int(np.sum(y&~z));tn=int(np.sum(~y&~z))
    prec=tp/max(1,tp+fp);rec=tp/max(1,tp+fn)
    return dict(tp=tp,fp=fp,fn=fn,tn=tn,precision=prec,recall=rec,f1=2*prec*rec/max(1e-12,prec+rec),f2=5*prec*rec/max(1e-12,4*prec+rec),flag_rate=float(np.mean(z)))

def metrics(y,p):
    y=np.asarray(y,int);p=np.asarray(p,float)
    if len(y)!=len(p) or not np.isfinite(p).all() or not np.isin(y,[0,1]).all():raise ValueError('Nonfinite predictions or invalid labels')
    p=np.clip(p,1e-8,1-1e-8);two=len(np.unique(y))==2
    z=dict(rows=len(y),failures=int(y.sum()),prevalence=float(y.mean()),ap=float(average_precision_score(y,p)) if two else np.nan,auc=float(roc_auc_score(y,p)) if two else np.nan,brier=float(brier_score_loss(y,p)),logloss=float(log_loss(y,p,labels=[0,1])),mean_p=float(p.mean()))
    ix=np.clip((p*10).astype(int),0,9);z['ece10']=float(sum((ix==j).mean()*abs(y[ix==j].mean()-p[ix==j].mean()) for j in range(10) if (ix==j).any()))
    for rate in (.1,.2):
        k=max(1,int(np.ceil(rate*len(p))));chosen=np.zeros(len(p),bool);chosen[np.argsort(-p,kind='stable')[:k]]=True
        st=binary_stats(y,chosen);z.update({f'{v}_at_{int(rate*100)}':st[v] for v in ('precision','recall','f1','f2')})
    return z

def freeze_threshold(y,p,beta):
    y=np.asarray(y);p=np.asarray(p)
    if len(np.unique(y))!=2:return np.nan
    # Fixed candidate ranks; only earlier-period labels used to select.
    qs=np.unique(np.r_[np.quantile(p,np.linspace(0,1,201)),0.,1.])
    def key(c):
        d=binary_stats(y,p>=c)
        return(d['f1' if beta==1 else 'f2'],d['recall'],-d['flag_rate'])
    return float(max(qs,key=key))

def make_model(seed_value=42,max_iter=100):
    return HistGradientBoostingClassifier(loss='log_loss',learning_rate=.06,max_iter=max_iter,max_leaf_nodes=15,min_samples_leaf=20,l2_regularization=1.,early_stopping=False,random_state=seed_value)

def train_predict(X,y,T,seed_value=42,max_iter=100):
    start=time.monotonic();unique=np.unique(y)
    if len(unique)==1:
        p=(np.sum(y)+.5)/(len(y)+1)
        return np.full(len(T),p,float),dict(seconds=time.monotonic()-start,iterations=0,in_sample_bce=np.nan,in_sample_ap=np.nan,prior_only=True)
    mdl=make_model(seed_value,max_iter);mdl.fit(X,y)
    tr=mdl.predict_proba(X)[:,1];pred=mdl.predict_proba(T)[:,1]
    from sklearn.metrics import log_loss
    return pred,dict(seconds=time.monotonic()-start,iterations=int(mdl.n_iter_),in_sample_bce=float(log_loss(y,np.clip(tr,1e-8,1-1e-8),labels=[0,1])),in_sample_ap=float(average_precision_score(y,tr)),prior_only=False)

def main_env():
    import sklearn
    return dict(python=sys.version.split()[0],numpy=np.__version__,pandas=pd.__version__,sklearn=sklearn.__version__,host=platform.node(),pid=os.getpid(),utc=datetime.now(timezone.utc).isoformat())
