# -*- coding: utf-8 -*-
"""Shared, leakage-safe utilities for Suite19 representation auditing."""
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable
import hashlib, importlib, json, os, platform, random, sys

import numpy as np
from sklearn.metrics import average_precision_score, roc_auc_score

EPS=1e-8
SCHEMA_VERSION=5


def safe_ap(y,score)->float:
    y=np.asarray(y,int).reshape(-1);s=np.asarray(score,float).reshape(-1)
    return float('nan') if len(y)==0 or np.unique(y).size<2 else float(average_precision_score(y,s))

def safe_auc(y,score)->float:
    y=np.asarray(y,int).reshape(-1);s=np.asarray(score,float).reshape(-1)
    return float('nan') if len(y)==0 or np.unique(y).size<2 else float(roc_auc_score(y,s))

def sigmoid(x):
    x=np.asarray(x,float);return 1/(1+np.exp(-np.clip(x,-35,35)))

def logit(p):
    p=np.clip(np.asarray(p,float),1e-6,1-1e-6);return np.log(p/(1-p))

def warn_by_rate(score,rate):
    s=np.asarray(score,float);out=np.zeros(len(s),np.int8);k=max(0,min(len(s),int(round(len(s)*float(rate)))))
    if k: out[np.argsort(-s,kind='mergesort')[:k]]=1
    return out

def fbeta_at_rate(y,score,rate=.20,beta=2.)->dict[str,float]:
    y=np.asarray(y,int);p=warn_by_rate(score,rate);tp=int(np.sum((p==1)&(y==1)));fp=int(np.sum((p==1)&(y==0)));fn=int(np.sum((p==0)&(y==1)));tn=int(np.sum((p==0)&(y==0)))
    pr=tp/max(tp+fp,1);re=tp/max(tp+fn,1);f1=2*pr*re/max(pr+re,EPS);b2=float(beta)**2;fb=(1+b2)*pr*re/max(b2*pr+re,EPS)
    return {'precision':float(pr),'recall':float(re),'f1':float(f1),'fbeta':float(fb),'flag_rate':float(p.mean()) if len(p) else np.nan,'tp':tp,'fp':fp,'fn':fn,'tn':tn}

def metric_dict(y,score,beta=2.)->dict[str,float]:
    out={'ap':safe_ap(y,score),'auc':safe_auc(y,score)}
    for rate in (.10,.15,.20,.25,.30):
        tag=int(round(100*rate));m=fbeta_at_rate(y,score,rate,beta)
        for k,v in m.items():out[f'{k}_at_{tag}']=v
    return out

@dataclass
class PrefixPreprocessor:
    """Median imputation + z-scaling fitted on a historical prefix only."""
    clip_z:float=12.
    median_:np.ndarray|None=None
    mean_:np.ndarray|None=None
    scale_:np.ndarray|None=None
    n_features_in_:int=0
    train_nonfinite_rate_:float=0.
    train_clipped_rate_:float=0.
    def fit(self,X):
        X=np.asarray(X,float)
        if X.ndim!=2 or len(X)==0:raise ValueError('PrefixPreprocessor requires non-empty 2-D X')
        self.train_nonfinite_rate_=float((~np.isfinite(X)).mean())
        finite=np.where(np.isfinite(X),X,np.nan)
        with np.errstate(all='ignore'):med=np.nanmedian(finite,axis=0)
        med=np.where(np.isfinite(med),med,0.);Xi=np.where(np.isfinite(X),X,med);mean=Xi.mean(0);scale=Xi.std(0);scale=np.where(scale<1e-6,1.,scale)
        raw=(Xi-mean)/scale;self.train_clipped_rate_=float((np.abs(raw)>self.clip_z).mean())
        self.median_=med.astype(np.float32);self.mean_=mean.astype(np.float32);self.scale_=scale.astype(np.float32);self.n_features_in_=X.shape[1];return self
    def transform(self,X):
        if self.median_ is None:raise RuntimeError('PrefixPreprocessor not fitted')
        X=np.asarray(X,float)
        if X.ndim!=2 or X.shape[1]!=self.n_features_in_:raise ValueError('query feature dimension mismatch')
        Xi=np.where(np.isfinite(X),X,self.median_);z=(Xi-self.mean_)/self.scale_;return np.clip(np.nan_to_num(z,nan=0.,posinf=self.clip_z,neginf=-self.clip_z),-self.clip_z,self.clip_z).astype(np.float32)
    def fit_transform(self,X):return self.fit(X).transform(X)
    def transform_diagnostics(self,X):
        X=np.asarray(X,float);non=float((~np.isfinite(X)).mean());Xi=np.where(np.isfinite(X),X,self.median_);raw=(Xi-self.mean_)/self.scale_
        return {'rows':int(len(X)),'nonfinite_rate':non,'clipped_rate':float((np.abs(raw)>self.clip_z).mean())}
    def metadata(self):return {'clip_z':float(self.clip_z),'n_features':int(self.n_features_in_),'train_nonfinite_rate':self.train_nonfinite_rate_,'train_clipped_rate':self.train_clipped_rate_}


def _stable_bytes(a,max_values=8192):
    a=np.asarray(a);h=hashlib.sha256();h.update(str(a.shape).encode());h.update(str(a.dtype).encode());flat=a.reshape(-1)
    if len(flat)>max_values:flat=flat[np.linspace(0,len(flat)-1,max_values).astype(int)]
    h.update(np.ascontiguousarray(flat).tobytes());return h.digest()

def matrix_fingerprint(X):return hashlib.sha256(_stable_bytes(np.asarray(X))).hexdigest()

def file_fingerprint(path,chunk=1<<20):
    p=Path(path);h=hashlib.sha256();h.update(str(p.resolve()).encode());h.update(str(p.stat().st_size).encode());h.update(str(p.stat().st_mtime_ns).encode())
    with p.open('rb') as f:
        h.update(f.read(chunk))
        if p.stat().st_size>chunk:
            f.seek(max(0,p.stat().st_size-chunk));h.update(f.read(chunk))
    return h.hexdigest()

def cache_signature(implementation,feature_names,y,blocks,config,seed,matrix_fp,source_fingerprints=None):
    payload={'implementation':str(implementation),'feature_names':list(feature_names),'y_sha':hashlib.sha256(_stable_bytes(np.asarray(y))).hexdigest(),'blocks_sha':hashlib.sha256(_stable_bytes(np.asarray(blocks))).hexdigest(),'config':config,'seed':int(seed),'matrix_fp':str(matrix_fp),'source_fingerprints':source_fingerprints or {},'schema_version':SCHEMA_VERSION}
    return hashlib.sha256(json.dumps(payload,sort_keys=True,default=str,separators=(',',':')).encode()).hexdigest()

def parse_csv_ints(v):return [int(x.strip()) for x in v.split(',') if x.strip()] if isinstance(v,str) else [int(x) for x in v]
def parse_csv_floats(v):return [float(x.strip()) for x in v.split(',') if x.strip()] if isinstance(v,str) else [float(x) for x in v]
def parse_csv_strings(v):return [x.strip() for x in v.split(',') if x.strip()] if isinstance(v,str) else [str(x) for x in v]

def seed_everything(seed):
    random.seed(int(seed));np.random.seed(int(seed))
    try:
        import torch;torch.manual_seed(int(seed));
        if torch.cuda.is_available():torch.cuda.manual_seed_all(int(seed))
    except Exception:pass

def resolve_device(device='auto'):
    if device!='auto':return device
    try:
        import torch;return 'cuda' if torch.cuda.is_available() else 'cpu'
    except Exception:return 'cpu'

def resolve_suite17_dir(start=None):
    here=Path(start).resolve() if start else Path(__file__).resolve().parent;root=here.parent;entry='train_suite17_robust_forward_specialist_boosting.py';c=[]
    if os.environ.get('SUITE17_CODE_DIR'):c.append(Path(os.environ['SUITE17_CODE_DIR']).expanduser())
    c += [here,root,root/'suite17',root/'Suite17',Path.cwd(),Path.cwd().parent]
    for base in [root,Path.cwd(),Path.cwd().parent]:
        if base.exists():c += [p for p in sorted(base.iterdir()) if p.is_dir() and p.name.lower().startswith('suite17')]
    seen=set()
    for d in c:
        try:d=d.resolve()
        except Exception:continue
        if str(d) in seen:continue
        seen.add(str(d))
        if (d/entry).exists() and (d/'suite17_pipeline.py').exists():return d
    raise FileNotFoundError('Could not resolve Suite17 code directory. Put suite19 beside suite17 or set SUITE17_CODE_DIR.')

def import_suite17(start=None):
    d=resolve_suite17_dir(start)
    if str(d) not in sys.path:sys.path.insert(0,str(d))
    names=['suite17_pipeline','suite17_temporal','suite17_training','suite17_hgb','suite17_reporting']
    out={n:importlib.import_module(n) for n in names};out['dir']=d
    try:out['suite7_eval']=importlib.import_module('suite7_eval')
    except Exception:pass
    return out

def package_versions():
    import importlib.metadata as md
    out={'python':platform.python_version(),'platform':platform.platform()}
    for p in ['numpy','pandas','scikit-learn','scipy','torch','joblib','psutil','tabm','rfm']:
        try:out[p]=md.version(p)
        except Exception:out[p]='not-installed'
    return out

def atomic_json_dump(obj,path):
    p=Path(path);p.parent.mkdir(parents=True,exist_ok=True);tmp=p.with_suffix(p.suffix+'.tmp');tmp.write_text(json.dumps(obj,indent=2,default=lambda x:x.item() if hasattr(x,'item') else str(x)));tmp.replace(p)

def print_table(title,rows,cols=None,max_rows=None):
    import pandas as pd
    df=rows if isinstance(rows,pd.DataFrame) else pd.DataFrame(rows)
    if cols is not None:df=df[[c for c in cols if c in df.columns]]
    if max_rows is not None:df=df.head(int(max_rows))
    print('\n'+title);print('-'*min(180,max(80,len(title)+4)));print(df.to_string(index=False,float_format=lambda x:f'{x:.4f}') if len(df) else '<empty>')

def runtime_snapshot():
    out={}
    try:
        import psutil;pr=psutil.Process(os.getpid());out['rss_mb']=pr.memory_info().rss/1024**2;out['available_ram_mb']=psutil.virtual_memory().available/1024**2
    except Exception:out['rss_mb']=out['available_ram_mb']=np.nan
    try:
        import torch;out['gpu_allocated_mb']=torch.cuda.memory_allocated()/1024**2 if torch.cuda.is_available() else 0.;out['gpu_peak_mb']=torch.cuda.max_memory_allocated()/1024**2 if torch.cuda.is_available() else 0.
    except Exception:out['gpu_allocated_mb']=out['gpu_peak_mb']=np.nan
    return out
