"""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

from oakbench.workflow_oracles import SCENARIOS as TRUSTED_WORKFLOWS, VERSION as WORKFLOW_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]:

    """Require independent persisted-state evidence for trusted payload tasks.

    Source labels describe how observations were obtained; they are not

    equivalence classes. Every workflow summary must pass its measured oracle.

    In particular, this rule does not certify bugfix_test_loop persistence.

    """

    groups = {}

    failures = []

    for row in rows:

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

            if (row.get("workflow_integrity_passed") is not True or row.get("returncode") != 0

                    or row.get("skipped") or row.get("success") is False

                    or row.get("correctness_passed") is False):

                failures.append(f"{row.get('subject')}/{row.get('scenario')}: workflow correctness is failed, skipped or unmeasured")

        if row.get("operation") in {"agent.workflow", "workflow.total"} and row.get("workflow_integrity_evidence_class") == "independent_committed_tree":

            instrument = row.get("git_head_instrument_sha256")

            subject = row.get("workflow_subject_binary_sha256")

            if (not all(isinstance(value, str) and re.fullmatch(r"[0-9a-f]{64}", value) for value in (instrument, subject))

                    or instrument == subject or "subject_produced" in str(row.get("workflow_integrity_source", ""))):

                failures.append("independent reader lacks distinct observed subject/instrument identities or uses subject-produced evidence")

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

            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)

    for key, items in groups.items():

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

            continue

        if any(item.get("oracle_version") != WORKFLOW_ORACLE_VERSION for item in items):

            failures.append(f"{key}: trusted task validator version is incompatible or missing")

        if any(item.get("workflow_integrity_evidence_class") != "independent_committed_tree" for item in items):

            failures.append(f"{key}: trusted persisted-state comparison requires independent committed-tree readers; subject-produced exports and metadata are insufficient")

        if any(not isinstance(item.get("workflow_integrity_source"), str) or not item["workflow_integrity_source"].strip() for item in items):

            failures.append(f"{key}: correctness evidence source is missing")

        if any("subject_produced" in str(item.get("workflow_integrity_source", ""))

               and item.get("workflow_integrity_evidence_class") == "independent_committed_tree" for item in items):

            failures.append(f"{key}: subject-produced evidence cannot declare an independent reader class")

        if 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