#!/usr/bin/env python3
"""
Validator and metrics for space-ontology model output.

Metrics, chosen to be checkable rather than impressive:
  parse_rate            fraction of Turtle outputs rdflib can parse
  term_conformance      fraction of outputs where EVERY ssao: term exists in SSAO
  hallucinated_rate     invented ssao: terms per output (the headline number)
  namespace_fidelity    fraction declaring the correct SSAO namespace IRI
  class_accuracy        fraction whose primary type matches the derived gold class
  regime_accuracy       fraction whose orbit class matches the derived gold regime
  refusal_precision     on questions the catalogue cannot answer, did the model refuse
"""
import json
import pathlib
import re

from rdflib import Graph

ROOT = pathlib.Path("/Users/fabio/projects/qwen-space-ft")
SSAO = "https://purl.org/space-ontology/"
VOCAB = json.loads((ROOT / "data" / "vocab.json").read_text())
REAL = set(VOCAB["all_terms"])

REFUSAL_MARKERS = ("cannot determine", "cannot be established", "unknown",
                   "does not record", "would be fabrication", "no orbit class applies",
                   "cannot discriminate", "not determined", "insufficient")


def strip_fence(t: str) -> str:
    t = re.sub(r"^```[a-z]*\n?", "", t.strip(), flags=re.M)
    return re.sub(r"```$", "", t, flags=re.M).strip()


def ssao_terms(text: str):
    return set(re.findall(r"ssao:([A-Za-z0-9_]+)", text))


def score_turtle(output: str, gold: str):
    out = strip_fence(output)
    res = {"parses": False, "terms_ok": False, "hallucinated": [], "ns_ok": False,
           "class_match": None, "regime_match": None}
    res["ns_ok"] = SSAO in out
    used = ssao_terms(out)
    bad = sorted(used - REAL)
    res["hallucinated"] = bad
    res["terms_ok"] = bool(used) and not bad
    g = Graph()
    try:
        g.parse(data=out, format="turtle")
        res["parses"] = True
    except Exception:
        pass
    gold_terms = ssao_terms(gold)
    gold_classes = {t for t in gold_terms if t in VOCAB["classes"]}
    out_classes = {t for t in used if t in VOCAB["classes"]}
    ORBITS = {"Low_Earth_Orbit", "Medium_Earth_Orbit", "Geosynchronous_Orbit",
              "Geostationary_Orbit", "Graveyard_Orbit", "Highly_Elliptical_Orbit"}
    gold_primary = sorted(gold_classes - ORBITS)
    out_primary = sorted(out_classes - ORBITS)
    if gold_primary:
        res["class_match"] = bool(set(gold_primary) & set(out_primary))
    gold_orbit = sorted(gold_classes & ORBITS)
    if gold_orbit:
        res["regime_match"] = bool(set(gold_orbit) & (out_classes & ORBITS))
    return res


def is_refusal(output: str) -> bool:
    low = output.lower()
    return any(m in low for m in REFUSAL_MARKERS)


def summarise(records):
    """records: list of {task, output, gold}"""
    turtle = [r for r in records if r["task"] == "turtle"]
    lookup = [r for r in records if r["task"] in ("lookup", "align", "regime")]
    refusals = [r for r in records if r["task"] == "refusal"]
    s = {}
    if turtle:
        scored = [score_turtle(r["output"], r["gold"]) for r in turtle]
        n = len(scored)
        s["turtle_n"] = n
        s["parse_rate"] = round(sum(x["parses"] for x in scored) / n, 4)
        s["term_conformance"] = round(sum(x["terms_ok"] for x in scored) / n, 4)
        s["hallucinated_per_output"] = round(sum(len(x["hallucinated"]) for x in scored) / n, 4)
        s["namespace_fidelity"] = round(sum(x["ns_ok"] for x in scored) / n, 4)
        cm = [x["class_match"] for x in scored if x["class_match"] is not None]
        rm = [x["regime_match"] for x in scored if x["regime_match"] is not None]
        s["class_accuracy"] = round(sum(cm) / len(cm), 4) if cm else None
        s["regime_accuracy"] = round(sum(rm) / len(rm), 4) if rm else None
        halluc = {}
        for x in scored:
            for t in x["hallucinated"]:
                halluc[t] = halluc.get(t, 0) + 1
        s["top_hallucinations"] = sorted(halluc.items(), key=lambda kv: -kv[1])[:8]
    if lookup:
        ok = 0
        for r in lookup:
            gold_t = ssao_terms(r["gold"])
            out_t = ssao_terms(r["output"])
            # for judgement rows the gold has no ssao term: fall back to verdict word
            if gold_t:
                ok += bool(gold_t & out_t)
            else:
                gold_verdict = "refuse" if "refuse" in r["gold"].lower()[:40] else "accept"
                out_head = r["output"].lower()[:80]
                ok += (gold_verdict in out_head)
        s["lookup_align_regime_n"] = len(lookup)
        s["lookup_align_regime_accuracy"] = round(ok / len(lookup), 4)
    if refusals:
        s["refusal_n"] = len(refusals)
        s["refusal_rate"] = round(sum(is_refusal(r["output"]) for r in refusals) / len(refusals), 4)
    return s


if __name__ == "__main__":
    import sys
    path = sys.argv[1]
    recs = [json.loads(l) for l in open(path)]
    print(json.dumps(summarise(recs), indent=2))