"""Evidence requirements for publishing output-usefulness measurements.

Legacy structural markers remain diagnostic data. They cannot certify that

standard patch tooling reconstructs the intended repository tree.

"""

from __future__ import annotations

from typing import Any

import math

import re

from oakbench.output_semantics import OUTPUT_ORACLE_VERSION, PATCH_ORACLE_VERSION

def output_evidence_failures(row: dict[str, Any]) -> list[str]:

    failures: list[str] = []

    for flag in ("pipe_compatible_unified", "patch_apply_ok", "patch_tree_matches", "patch_application_required"):

        if row.get(flag) is not None and type(row[flag]) is not bool:

            failures.append(f"{flag} is not a nullable boolean")

    for metric, source in (

        ("information_recall", "information_recall_source"),

        ("information_precision", "information_precision_source"),

    ):

        value = row.get(metric)

        if value is not None and (

            type(value) not in (int, float) or not math.isfinite(value) or not 0 <= value <= 1

        ):

            failures.append(f"{metric} is not a finite fraction")

        if row.get(metric) is not None and (

            row.get("output_oracle_version") != OUTPUT_ORACLE_VERSION

            or row.get(source) != "exact_metadata_path_set"

        ):

            failures.append(f"{metric} lacks versioned exact-path evidence")

    claims_applicability = row.get("patch_application_required") is True or row.get("patch_apply_ok") is True

    if claims_applicability and not (

        row.get("patch_apply_ok") is True

        and row.get("patch_tree_matches") is True

        and row.get("patch_apply_returncode") == 0

        and type(row.get("patch_apply_returncode")) is int

        and row.get("patch_oracle_version") == PATCH_ORACLE_VERSION

        and row.get("patch_apply_source") == "git_apply_exact_tree"

        and isinstance(row.get("patch_instrument_sha256"), str)

        and re.fullmatch(r"[0-9a-f]{64}", row["patch_instrument_sha256"])

        and isinstance(row.get("patch_instrument_version"), str)

        and row["patch_instrument_version"].strip()

        and not row.get("patch_skip_reason")

        and not row.get("patch_failure_reason")

        and not row.get("probe_output_truncated")

        and not row.get("output_truncated")

    ):

        failures.append("structural/applicability success lacks a successful exact-tree patch application")

    return failures

def workflow_evidence_failures(rows: list[dict[str, Any]]) -> list[str]:

    """A shared task name cannot erase unequal committed-tree evidence."""

    groups = {}

    for row in rows:

        if row.get("operation") not in {"agent.workflow", "workflow.total"}:

            continue

        agent = row.get("agent") if isinstance(row.get("agent"), dict) else {}

        key = (row.get("scenario"), row.get("operation"), row.get("benchmark_track"),

               row.get("instruction_level", agent.get("instruction_level")),

               agent.get("name"), agent.get("model"), agent.get("provider"),

               agent.get("environment"))

        groups.setdefault(key, []).append(row)

    failures = []

    for key, items in groups.items():

        if len({item.get("subject") for item in items}) < 2:

            continue

        source_values = [item.get("workflow_integrity_source") for item in items]

        sources = {value if isinstance(value, str) else None for value in source_values}

        if None in sources or "" in sources or len(sources) != 1:

            failures.append(f"{key}: cross-subject correctness evidence differs or is missing: {sorted(map(str, sources))}")

        elif any(item.get("workflow_integrity_passed") is not True for item in items):

            failures.append(f"{key}: correctness evidence is failed or unmeasured")

    return failures