"""
Validación externa de los datasets sintéticos de DignityAI contra datos reales anotados por personas.

A. Reconocimiento externo: un modelo entrenado con comentarios reales anotados por humanos
   (piuba-bigdata/beto-contextualized-hate-speech, UBA) clasifica muestras de nuestros textos.
B. Línea base del mismo modelo en su propio test real (para saber qué tan sensible es).
C. Evaluación externa de SinOdio v3 en HateCheck-ES (casos funcionales escritos por expertos).
D. Transferencia: ¿un clasificador entrenado con nuestros datos detecta odio real?
   ¿y agregar nuestros datos a datos reales ayuda o estorba?
"""
import json, glob, sys, time
import numpy as np, pandas as pd, torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import f1_score, precision_score, recall_score, accuracy_score

RNG = 42
DEV = "mps" if torch.backends.mps.is_available() else "cpu"
OUT = {}
def log(*a): print(time.strftime("%H:%M:%S"), *a, flush=True)

# ---------- datos propios
def own():
    r = pd.read_parquet("racismo/v1.1/completo.parquet")
    c = pd.read_parquet("clasismo/v1.1/completo.parquet")
    m = pd.concat([pd.read_parquet(f) for f in glob.glob("data/machismodetect__*.parquet")])
    m = pd.concat([
        m[["texto_machista", "nivel", "pais"]].rename(columns={"texto_machista": "texto", "nivel": "categoria"}).assign(etiqueta=1),
        m[["texto_inclusivo", "nivel", "pais"]].rename(columns={"texto_inclusivo": "texto", "nivel": "categoria"}).assign(etiqueta=0),
    ]).drop_duplicates("texto")
    s = pd.concat([pd.read_parquet(f) for f in glob.glob("data/sinodio_latam__*.parquet")])
    s = s.rename(columns={"text": "texto", "label": "etiqueta", "scenario": "categoria", "country": "pais"}).drop_duplicates("texto")
    return {"racismo": r, "clasismo": c, "machismo": m, "sinodio": s}

def sample(df, n_pos=1500, n_neg=1000):
    p = df[df.etiqueta == 1]; n = df[df.etiqueta == 0]
    return pd.concat([p.sample(min(n_pos, len(p)), random_state=RNG), n.sample(min(n_neg, len(n)), random_state=RNG)])

# ---------- modelos
def load(rid):
    tok = AutoTokenizer.from_pretrained(rid)
    mod = AutoModelForSequenceClassification.from_pretrained(rid).to(DEV).eval()
    return tok, mod

@torch.no_grad()
def logits(tok, mod, texts, ctx=None, bs=64):
    out = []
    for i in range(0, len(texts), bs):
        a = list(texts[i:i + bs])
        b = list(ctx[i:i + bs]) if ctx is not None else None
        enc = tok(a, b, truncation=True, max_length=128, padding=True, return_tensors="pt").to(DEV)
        out.append(mod(**enc).logits.float().cpu())
    return torch.cat(out)

UBA_GROUPS = ["WOMEN", "LGBTI", "RACISM", "CLASS", "POLITICS", "DISABLED", "APPEARANCE", "CRIMINAL"]
TARGET = {"racismo": "RACISM", "clasismo": "CLASS", "machismo": "WOMEN", "sinodio": None}

def main():
    data = own()
    tok, mod = load("piuba-bigdata/beto-contextualized-hate-speech")
    id2l = [mod.config.id2label[i] for i in range(len(mod.config.id2label))]
    log("UBA labels", id2l)
    gi = [id2l.index(g) for g in UBA_GROUPS]

    # B. Línea base UBA en su test real (con contexto, como fue entrenado)
    real = pd.read_parquet("data/piuba_real__test.parquet")
    rs = pd.concat([real[real[g] == 1].sample(min(400, int((real[g] == 1).sum())), random_state=RNG) for g in ["RACISM", "CLASS", "WOMEN"]]
                   + [real[real.HATEFUL == 0].sample(1000, random_state=RNG)]).drop_duplicates("id")
    for use_ctx in [True, False]:
        lg = logits(tok, mod, rs.text.tolist(), rs.context_tweet.fillna("").tolist() if use_ctx else None)
        pr = (torch.sigmoid(lg) > 0.5).numpy()
        res = {g: round(float(pr[(rs[g] == 1).values, id2l.index(g)].mean()), 3) for g in ["RACISM", "CLASS", "WOMEN"]}
        res["falsas_alarmas_no_odio"] = round(float(pr[(rs.HATEFUL == 0).values][:, gi].any(1).mean()), 3)
        OUT[f"uba_en_real_{'con' if use_ctx else 'sin'}_contexto"] = res
        log("UBA real", use_ctx, res)

    # A. UBA sobre nuestros textos (sin contexto)
    sin_tok, sin_mod = load("antonn-dromundo/SinOdio-BETO-HateSpeech-Detector-v3")
    sid2l = {int(k): v for k, v in sin_mod.config.id2label.items()}
    log("SinOdio labels", sid2l)
    hate_idx = 1
    for name, df in data.items():
        s = sample(df)
        pr = (torch.sigmoid(logits(tok, mod, s.texto.tolist())) > 0.5).numpy()
        sp = torch.softmax(logits(sin_tok, sin_mod, s.texto.tolist()), -1)[:, hate_idx].numpy() > 0.5
        pos, neg = (s.etiqueta == 1).values, (s.etiqueta == 0).values
        r = {
            "n_discriminatorios": int(pos.sum()), "n_contraste": int(neg.sum()),
            "uba_detecta_odio_en_discriminatorios": round(float(pr[pos][:, gi].any(1).mean()), 3),
            "uba_falsas_alarmas_en_contraste": round(float(pr[neg][:, gi].any(1).mean()), 3),
            "sinodio_detecta_odio_en_discriminatorios": round(float(sp[pos].mean()), 3),
            "sinodio_falsas_alarmas_en_contraste": round(float(sp[neg].mean()), 3),
        }
        if TARGET[name]:
            r[f"uba_etiqueta_{TARGET[name]}_en_discriminatorios"] = round(float(pr[pos, id2l.index(TARGET[name])].mean()), 3)
        s = s.assign(uba_odio=pr[:, gi].any(1), sinodio_odio=sp)
        r["uba_por_categoria"] = s[pos].groupby("categoria").uba_odio.mean().round(3).to_dict()
        r["uba_etiquetas_mas_asignadas"] = dict(pd.Series([id2l[j] for row in pr[pos] for j in np.where(row)[0]]).value_counts().head(5))
        OUT[f"externo_{name}"] = r
        log(name, json.dumps(r, ensure_ascii=False, default=int))

    # C. SinOdio v3 y UBA en HateCheck-ES
    hc = pd.read_parquet("data/hatecheck_es__test.parquet")
    y = (hc.label_gold == "hateful").astype(int).values
    sp = (torch.softmax(logits(sin_tok, sin_mod, hc.test_case.tolist()), -1)[:, hate_idx].numpy() > 0.5).astype(int)
    up = (torch.sigmoid(logits(tok, mod, hc.test_case.tolist())) > 0.5).numpy()[:, gi].any(1).astype(int)
    hcr = {}
    for nm, p in [("sinodio_v3", sp), ("uba_beto", up)]:
        f = hc.assign(ok=(p == y))
        hcr[nm] = {"exactitud": round(accuracy_score(y, p), 3), "f1_macro": round(f1_score(y, p, average="macro"), 3),
                   "recall_odio": round(recall_score(y, p), 3), "precision_odio": round(precision_score(y, p), 3),
                   "peores_funcionalidades": f.groupby("functionality").ok.mean().sort_values().head(6).round(3).to_dict()}
    OUT["hatecheck_es"] = hcr
    log("hatecheck", json.dumps(hcr, ensure_ascii=False))

    # D. Transferencia sintético -> real (TF-IDF + LR)
    tr_real = pd.read_parquet("data/piuba_real__train.parquet"); te_real = real
    tr_neg = tr_real[tr_real.HATEFUL == 0].sample(8000, random_state=RNG)
    trans = {}
    for name in ["racismo", "clasismo", "machismo"]:
        g = TARGET[name]
        te = pd.concat([te_real[te_real[g] == 1], te_real[te_real.HATEFUL == 0].sample(3000, random_state=RNG)])
        yte = (te[g] == 1).astype(int).values
        syn = data[name][["texto", "etiqueta"]]
        rp = tr_real[tr_real[g] == 1]
        sets = {
            "solo_sintetico": (syn.texto, syn.etiqueta),
            "solo_real": (pd.concat([rp.text, tr_neg.text]), np.r_[np.ones(len(rp)), np.zeros(len(tr_neg))]),
        }
        sets["real_mas_sintetico"] = (pd.concat([sets["solo_real"][0], syn.texto]), np.r_[sets["solo_real"][1], syn.etiqueta])
        rr = {"n_test_positivos": int(yte.sum()), "n_test_negativos": int((1 - yte).sum())}
        for k, (X, Y) in sets.items():
            v = TfidfVectorizer(ngram_range=(1, 2), min_df=2, sublinear_tf=True, max_features=200000)
            m = LogisticRegression(max_iter=3000, class_weight="balanced").fit(v.fit_transform(X), Y)
            p = m.predict(v.transform(te.text))
            rr[k] = {"f1": round(f1_score(yte, p), 3), "recall": round(recall_score(yte, p), 3), "precision": round(precision_score(yte, p, zero_division=0), 3)}
        trans[name] = rr
        log("transfer", name, rr)
    OUT["transferencia_a_real_uba"] = trans
    json.dump(OUT, open("resultados_validacion.json", "w"), ensure_ascii=False, indent=2, default=int)
    log("LISTO")

if __name__ == "__main__":
    main()