"""Information content of VCS output: bytes saved vs information lost.

Compact output is only a win if the agent can still act on it. These oracles

score a status/diff output against the fixture's ground-truth changed file

list: information_recall is the fraction of actually-changed paths an agent

(or a script) could recover from the bytes it was shown. A subject that emits

half the bytes but names half the files has not saved anything — it has moved

the cost to a follow-up command.

The second oracle is pipe compatibility: scripts and agents pipe diff output

into grep/patch/apply tooling that expects unified-diff structure. A diff

output without recognizable file headers and hunk markers silently breaks that

ecosystem; the probe records the structure so a format change is a visible

metric regression, not a downstream surprise.

"""

from __future__ import annotations

import re

from typing import Any, Iterable

STATUS_LINE = re.compile(r"^(?:(?!  )[ MADRCU?!]{2}|[MADRCU?!])\s+(.+)$")

UNIFIED_HUNK_HEADER = re.compile(r"^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@", re.MULTILINE)

UNIFIED_OLD_FILE = re.compile(r"^--- ", re.MULTILINE)

UNIFIED_NEW_FILE = re.compile(r"^\+\+\+ ", re.MULTILINE)

GIT_DIFF_HEADER = re.compile(r"^diff --git ", re.MULTILINE)

BINARY_NOTICE = re.compile(r"^Binary files? .* differ", re.MULTILINE | re.IGNORECASE)

def recovered_paths(output_text: str, changed_paths: Iterable[str]) -> list[str]:

    """Ground-truth paths an agent could recover from this output.

    A path counts as recovered when its repo-relative form appears in the

    output (including git's a/ b/ prefixes). Substring matching is

    deliberately generous and subject-neutral: it asks "is the information

    present at all?", not "is it in a specific format".

    """

    recovered: list[str] = []

    for path in changed_paths:

        if path in output_text:

            recovered.append(path)

    return recovered

def _normalize_reported_path(raw: str) -> str | None:

    path = raw.strip().strip("'\"`:,;()[]{}")

    if not path or path == "/dev/null" or path.startswith(("http://", "https://")):

        return None

    if path.startswith(("a/", "b/")):

        path = path[2:]

    name = path.rsplit("/", 1)[-1]

    root_file_like = "." in name or name in {"Dockerfile", "Makefile", "README", "LICENSE"}

    return path if "/" in path or root_file_like else None

def _line_reported_paths(line: str) -> list[str]:

    stripped = line.strip()

    candidates: list[str] = []

    if stripped.startswith("diff --git "):

        candidates.extend(stripped.split()[2:4])

    elif stripped.startswith(("--- ", "+++ ")):

        candidates.append(stripped.split(maxsplit=1)[1].split("\t", 1)[0])

    elif stripped.lower().startswith("binary files "):

        parts = stripped.split()

        if len(parts) >= 5:

            candidates.extend([parts[2], parts[4]])

    elif " | " in stripped:

        candidates.append(stripped.split(" | ", 1)[0])

    else:

        status = STATUS_LINE.match(line)

        if status:

            payload = status.group(1)

            candidates.extend(part.strip() for part in payload.split(" -> "))

    normalized = [_normalize_reported_path(candidate) for candidate in candidates]

    return [path for path in normalized if path is not None]

def reported_paths(output_text: str) -> list[str]:

    """Repo-like paths reported by VCS metadata lines.

    Diff bodies can contain dotted identifiers and version strings that look

    path-ish. Precision measures named changed files, so it only scans status

    rows, diff headers, file headers, binary notices, and diffstat rows.

    """

    paths: set[str] = set()

    in_unified_hunk = False

    for line in output_text.splitlines():

        stripped = line.strip()

        if stripped.startswith("diff --git "):

            in_unified_hunk = False

        elif stripped.startswith("@@ "):

            in_unified_hunk = True

            continue

        elif in_unified_hunk:

            continue

        paths.update(_line_reported_paths(line))

    return sorted(paths)

def information_recall_fields(

    output_text: str,

    changed_paths: list[str],

    output_bytes: int,

    output_truncated: bool,

) -> dict[str, Any]:

    """Recall and byte-efficiency fields for one status/diff output.

    information_recall is null (unmeasured) when there is no ground truth to

    score against; bytes_per_changed_file_named is null when nothing was

    recovered — never zero (ADR-0002).

    """

    expected_paths = set(changed_paths)

    recovered = recovered_paths(output_text, changed_paths)

    reported = reported_paths(output_text)

    false_positives = [path for path in reported if path not in expected_paths]

    true_reported = [path for path in reported if path in expected_paths]

    expected = len(changed_paths)

    recall = round(len(recovered) / expected, 4) if expected else None

    precision = round(len(true_reported) / len(reported), 4) if expected and reported else None

    bytes_per_named = round(output_bytes / len(recovered), 1) if recovered else None

    return {

        "changed_files_expected": expected,

        "changed_files_recovered": len(recovered),

        "changed_files_reported": len(reported),

        "changed_files_false_positive": len(false_positives),

        "information_recall": recall,

        "information_precision": precision,

        "bytes_per_changed_file_named": bytes_per_named,

        "probe_output_truncated": output_truncated,

        "information_recall_source": "ground_truth_path_substring_match",

        "information_precision_source": "path_token_precision_against_changed_paths",

    }

def unified_diff_compat_fields(output_text: str) -> dict[str, Any]:

    """Structure fields for piped-diff compatibility.

    pipe_compatible_unified means the output carries both unified file headers

    and hunk markers (or is an explicit binary notice), i.e. standard tooling

    (patch, git apply, diffstat, grep '^+') can consume it.

    """

    hunk_headers = len(UNIFIED_HUNK_HEADER.findall(output_text))

    old_headers = len(UNIFIED_OLD_FILE.findall(output_text))

    new_headers = len(UNIFIED_NEW_FILE.findall(output_text))

    git_headers = len(GIT_DIFF_HEADER.findall(output_text))

    binary_notices = len(BINARY_NOTICE.findall(output_text))

    has_text_structure = hunk_headers > 0 and old_headers > 0 and new_headers > 0

    return {

        "unified_hunk_header_count": hunk_headers,

        "unified_file_header_count": min(old_headers, new_headers),

        "git_diff_header_count": git_headers,

        "binary_notice_count": binary_notices,

        "pipe_compatible_unified": bool(has_text_structure or binary_notices > 0),

    }