"""Conformance gate: diagnostic conformance rows vs an explicit expected-failures list.

Semantics (strict xfail):

- a behaviour that fails and is not listed is a REGRESSION (blocks);

- a listed behaviour that fails at a *different* set of legs than recorded is

  also a regression (the failure changed shape, e.g. rejection -> corruption);

- a listed behaviour that now passes is FIXED: the verdict is not a regression,

  but the list is stale and ``publish_gate`` refuses until it is updated;

- harness errors, reader-unmeasured legs, and required behaviours with no row

  make the result UNMEASURED; capability/gated skips are recorded, not failed.

Only the subject named by the list (Oak) is gated; Git rows are the reference

arm and are reported, never gating.

"""

from __future__ import annotations

import json

from pathlib import Path

import re

ROOT = Path(__file__).resolve().parents[2]

EXPECTED_FAILURES = ROOT / "config" / "conformance_expected_failures.json"

TICKET = re.compile(r"^(fb-\d+|proposed:[a-z0-9-]+)$")

CAPABILITY_SKIP_PREFIXES = ("filesystem capability unavailable", "gated:", "gated behaviour")

def load_expected(path: Path = EXPECTED_FAILURES) -> dict:

    data = json.loads(Path(path).read_text())

    if data.get("schema_version") != 1 or not isinstance(data.get("entries"), list):

        raise ValueError("conformance expected-failures: unsupported schema")

    entries = {}

    for entry in data["entries"]:

        behaviour = entry.get("behaviour")

        if not behaviour or behaviour in entries:

            raise ValueError(f"conformance expected-failures: bad or duplicate behaviour {behaviour!r}")

        if not TICKET.match(str(entry.get("ticket", ""))):

            raise ValueError(f"conformance expected-failures: {behaviour} needs a ticket (fb-N or proposed:slug)")

        if not isinstance(entry.get("failed_legs"), list) or not entry["failed_legs"]:

            raise ValueError(f"conformance expected-failures: {behaviour} needs failed_legs")

        entries[behaviour] = entry

    return {"subject": data.get("subject", "oak"), "entries": entries}

def row_failed_legs(row: dict) -> list:

    if "failed_legs" in row:

        return sorted(row["failed_legs"])

    # Legacy v1 scenarios have no legs: a failure is the whole behaviour.

    return ["behaviour"] if row.get("returncode") == 1 else []

def evaluate(rows: list, expected: dict, required=None) -> dict:

    subject = expected["subject"]

    entries = expected["entries"]

    result = {"subject": subject, "passed": [], "expected_failures": [], "fixed": [], "regressions": [],

              "unmeasured": [], "skipped": [], "git_reference_failures": [], "differential_differs": []}

    seen = set()

    for row in rows:

        if row.get("evidence_class") != "diagnostic_conformance":

            continue

        behaviour = row.get("scenario")

        code = row.get("returncode")

        if row.get("subject") != subject:

            if row.get("subject") == "git" and code == 1:

                result["git_reference_failures"].append(f"{behaviour}: {row.get('failure')}")

            continue

        seen.add(behaviour)

        entry = entries.get(behaviour)

        differential = str(row.get("git_differential") or "")

        if differential.startswith("differs"):

            result["differential_differs"].append(f"{behaviour}: {differential}")

        if code == 0:

            (result["fixed"] if entry else result["passed"]).append(

                f"{behaviour}: now passes; remove {entry['ticket']} from the expected-failures list" if entry else behaviour)

        elif code == 1:

            legs = row_failed_legs(row)

            if entry is None:

                result["regressions"].append(f"{behaviour}: {row.get('failure')}")

            elif sorted(entry["failed_legs"]) != legs:

                result["regressions"].append(

                    f"{behaviour}: known failure ({entry['ticket']}) changed shape: expected legs "

                    f"{sorted(entry['failed_legs'])}, observed {legs}: {row.get('failure')}")

            else:

                result["expected_failures"].append(f"{behaviour}: {entry['ticket']}")

        elif code == 77 and str(row.get("skip_reason", "")).startswith(CAPABILITY_SKIP_PREFIXES):

            result["skipped"].append(f"{behaviour}: {row.get('skip_reason')}")

        else:

            result["unmeasured"].append(f"{behaviour}: {row.get('failure') or row.get('skip_reason') or code}")

    for behaviour in sorted(set(required or ()) - seen):

        result["unmeasured"].append(f"{behaviour}: no {subject} conformance row")

    if not seen:

        result["unmeasured"].append(f"no {subject} conformance rows")

    result["verdict"] = ("REGRESSED" if result["regressions"] else

                         "UNMEASURED" if result["unmeasured"] else "PASS")

    return result

def summary_lines(result: dict) -> list:

    lines = [f"conformance ({result['subject']}): {result['verdict']} - {len(result['passed'])} pass, "

             f"{len(result['expected_failures'])} expected-fail, {len(result['fixed'])} fixed, "

             f"{len(result['regressions'])} regression(s), {len(result['unmeasured'])} unmeasured, "

             f"{len(result['skipped'])} capability/gated skip(s)"]

    for key, label in (("regressions", "REGRESSION"), ("fixed", "FIXED"), ("unmeasured", "UNMEASURED"),

                       ("expected_failures", "XFAIL"), ("differential_differs", "GIT-DIFF"),

                       ("git_reference_failures", "GIT-REF"), ("skipped", "SKIP")):

        lines += [f"  {label} {item}" for item in result[key]]

    return lines