"""Branch triage fixture shapes, manifest validation, and correctness metrics.

The generator produces labeled git branch states plus ``BRANCH_MANIFEST.json``.

Scoring compares measured Oak triage JSON against the manifest oracle. Null means

unmeasured (ADR-0002): missing ``oak branch triage`` / review triage support

must yield skip rows and null metrics, never fabricated zeros or silent passes.

"""

from __future__ import annotations

import json

import math

from dataclasses import dataclass

from pathlib import Path

from typing import Any, Mapping, Optional

MANIFEST_FILENAME = "BRANCH_MANIFEST.json"

GENERATOR_VERSION = "branch-triage-shape-v2"

SCHEMA_VERSION = 1

RECOMMENDED_ACTIONS = (

    "close",

    "validate_then_merge",

    "resolve",

    "rebuild",

    "review",

    "unknown",

)

MERGEABILITY = ("clean", "conflicts", "unknown")

CONTRIBUTION = (

    "empty",

    "superseded_exact",

    "clean_contributes",

    "conflict_additive",

    "contributes_and_reverts_target",

    "missing_data",

    "unknown",

)

TARGET_RISK = ("none", "reverts_target_exact", "missing_data", "unknown")

# Six deterministic shapes cycled for larger branch counts.

SHAPE_NAMES = (

    "empty",

    "superseded_exact",

    "clean_contributes",

    "conflict_additive",

    "contributes_and_reverts_target",

    "missing_data",

)

TRIAGE_METRIC_KEYS = (

    "triage_recall",

    "triage_precision",

    "false_close_count",

    "close_eligible_n",

    "false_vcs_merge_safe_count",

    "vcs_merge_safe_n",

    "false_merge_allowed_count",

    "merge_allowed_n",

    "branches_scored",

    "branches_expected",

)

@dataclass(frozen=True)

class ExpectedTriage:

    recommended_action: str

    reason: str

    close_allowed: bool

    vcs_merge_safe: Optional[bool]

    merge_allowed: bool

    mergeability: str

    contribution: str

    target_risk: str

    def as_dict(self) -> dict[str, Any]:

        return {

            "recommended_action": self.recommended_action,

            "reason": self.reason,

            "close_allowed": self.close_allowed,

            "vcs_merge_safe": self.vcs_merge_safe,

            "merge_allowed": self.merge_allowed,

            "mergeability": self.mergeability,

            "contribution": self.contribution,

            "target_risk": self.target_risk,

        }

@dataclass(frozen=True)

class BranchManifestEntry:

    name: str

    shape: str

    expected: ExpectedTriage

    def as_dict(self) -> dict[str, Any]:

        return {

            "name": self.name,

            "shape": self.shape,

            "expected": self.expected.as_dict(),

        }

def shape_name(index: int) -> str:

    return SHAPE_NAMES[index % len(SHAPE_NAMES)]

def branch_name(index: int) -> str:

    return f"triage-{shape_name(index)}-{index}"

def expected_triage_for_shape(shape: str) -> ExpectedTriage:

    """Manifest oracle for one labeled shape (full merge-preview analysis)."""

    if shape == "empty":

        return ExpectedTriage(

            recommended_action="close",

            reason="empty",

            close_allowed=True,

            vcs_merge_safe=None,

            merge_allowed=False,

            mergeability="unknown",

            contribution="empty",

            target_risk="unknown",

        )

    if shape == "superseded_exact":

        return ExpectedTriage(

            recommended_action="close",

            reason="superseded_exact",

            close_allowed=True,

            vcs_merge_safe=None,

            merge_allowed=False,

            mergeability="unknown",

            contribution="superseded_exact",

            target_risk="unknown",

        )

    if shape == "clean_contributes":

        return ExpectedTriage(

            recommended_action="validate_then_merge",

            reason="clean_contributes",

            close_allowed=False,

            vcs_merge_safe=True,

            merge_allowed=True,

            mergeability="clean",

            contribution="clean_contributes",

            target_risk="none",

        )

    if shape == "conflict_additive":

        return ExpectedTriage(

            recommended_action="resolve",

            reason="conflict_additive",

            close_allowed=False,

            vcs_merge_safe=False,

            merge_allowed=False,

            mergeability="conflicts",

            contribution="conflict_additive",

            target_risk="none",

        )

    if shape == "contributes_and_reverts_target":

        return ExpectedTriage(

            recommended_action="review",

            reason="reverts_target_exact",

            close_allowed=False,

            vcs_merge_safe=True,

            merge_allowed=False,

            mergeability="clean",

            contribution="contributes_and_reverts_target",

            target_risk="reverts_target_exact",

        )

    if shape == "missing_data":

        return ExpectedTriage(

            recommended_action="review",

            reason="missing_data",

            close_allowed=False,

            vcs_merge_safe=None,

            merge_allowed=False,

            mergeability="unknown",

            contribution="missing_data",

            target_risk="missing_data",

        )

    raise ValueError(f"unknown branch triage shape {shape!r}")

def manifest_entries(branch_count: int) -> list[BranchManifestEntry]:

    if branch_count < 1:

        raise ValueError("branch_count must be at least 1")

    entries: list[BranchManifestEntry] = []

    for index in range(branch_count):

        shape = shape_name(index)

        entries.append(

            BranchManifestEntry(

                name=branch_name(index),

                shape=shape,

                expected=expected_triage_for_shape(shape),

            )

        )

    return entries

def build_manifest(*, seed: str, branch_count: int, against: str = "main") -> dict[str, Any]:

    return {

        "schema_version": SCHEMA_VERSION,

        "generator": GENERATOR_VERSION,

        "seed": seed,

        "against": against,

        "branch_count": branch_count,

        "shapes": list(SHAPE_NAMES),

        "branches": [entry.as_dict() for entry in manifest_entries(branch_count)],

    }

def write_manifest(path: Path, *, seed: str, branch_count: int, against: str = "main") -> dict[str, Any]:

    manifest = build_manifest(seed=seed, branch_count=branch_count, against=against)

    path.parent.mkdir(parents=True, exist_ok=True)

    path.write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")

    return manifest

def load_manifest(path: Path) -> dict[str, Any]:

    return json.loads(path.read_text())

def validate_manifest(manifest: Mapping[str, Any]) -> list[str]:

    errors: list[str] = []

    if manifest.get("schema_version") != SCHEMA_VERSION:

        errors.append(f"schema_version must be {SCHEMA_VERSION}")

    if manifest.get("generator") != GENERATOR_VERSION:

        errors.append(f"generator must be {GENERATOR_VERSION!r}")

    seed = manifest.get("seed")

    if not isinstance(seed, str) or not seed:

        errors.append("seed must be a non-empty string")

    against = manifest.get("against")

    if not isinstance(against, str) or not against:

        errors.append("against must be a non-empty string")

    branch_count = manifest.get("branch_count")

    if not isinstance(branch_count, int) or branch_count < 1:

        errors.append("branch_count must be a positive integer")

    branches = manifest.get("branches")

    if not isinstance(branches, list) or not branches:

        errors.append("branches must be a non-empty list")

        return errors

    if isinstance(branch_count, int) and len(branches) != branch_count:

        errors.append("branch_count does not match branches length")

    seen_names: set[str] = set()

    for index, branch in enumerate(branches, 1):

        if not isinstance(branch, dict):

            errors.append(f"branch {index}: expected object")

            continue

        name = branch.get("name")

        if not isinstance(name, str) or not name:

            errors.append(f"branch {index}: missing name")

        elif name in seen_names:

            errors.append(f"branch {index}: duplicate name {name!r}")

        else:

            seen_names.add(name)

        shape = branch.get("shape")

        if shape not in SHAPE_NAMES:

            errors.append(f"branch {index}: unknown shape {shape!r}")

        expected = branch.get("expected")

        if not isinstance(expected, dict):

            errors.append(f"branch {index}: missing expected object")

            continue

        errors.extend(_validate_expected(index, expected))

    return errors

def _validate_expected(index: int, expected: Mapping[str, Any]) -> list[str]:

    errors: list[str] = []

    action = expected.get("recommended_action")

    if action not in RECOMMENDED_ACTIONS:

        errors.append(f"branch {index}: invalid recommended_action {action!r}")

    for key in ("mergeability", "contribution", "target_risk"):

        allowed = MERGEABILITY if key == "mergeability" else CONTRIBUTION if key == "contribution" else TARGET_RISK

        value = expected.get(key)

        if value not in allowed:

            errors.append(f"branch {index}: invalid {key} {value!r}")

    for key in ("close_allowed", "merge_allowed"):

        if not isinstance(expected.get(key), bool):

            errors.append(f"branch {index}: {key} must be boolean")

    vms = expected.get("vcs_merge_safe")

    if vms is not None and not isinstance(vms, bool):

        errors.append(f"branch {index}: vcs_merge_safe must be boolean or null")

    reason = expected.get("reason")

    if not isinstance(reason, str) or not reason:

        errors.append(f"branch {index}: reason must be a non-empty string")

    return errors

def normalize_actual_triage(payload: Mapping[str, Any]) -> dict[str, Any]:

    """Extract triage fields from branch review/triage JSON payloads."""

    triage = payload.get("triage")

    source = triage if isinstance(triage, dict) else payload

    contribution = source.get("contribution")

    target_risk = source.get("target_risk")

    return {

        "recommended_action": _string_or_none(source.get("recommended_action")),

        "reason": _string_or_none(source.get("reason")),

        "close_allowed": source.get("close_allowed") if isinstance(source.get("close_allowed"), bool) else None,

        "vcs_merge_safe": source.get("vcs_merge_safe") if source.get("vcs_merge_safe") in (True, False) else None,

        "merge_allowed": source.get("merge_allowed") if isinstance(source.get("merge_allowed"), bool) else None,

        "mergeability": _string_or_none(source.get("mergeability")),

        "contribution": _string_or_none(contribution),

        "target_risk": _string_or_none(target_risk),

    }

def _string_or_none(value: Any) -> Optional[str]:

    return str(value) if isinstance(value, str) and value else None

def _matches_expected(actual: Mapping[str, Any], expected: Mapping[str, Any]) -> bool:

    for key, expected_value in expected.items():

        actual_value = actual.get(key)

        if key == "vcs_merge_safe":

            if actual_value != expected_value:

                return False

            continue

        if actual_value != expected_value:

            return False

    return True

def score_branch(actual: Mapping[str, Any], expected: Mapping[str, Any]) -> dict[str, Any]:

    normalized = normalize_actual_triage(actual)

    measured = normalized["recommended_action"] is not None

    correct = measured and _matches_expected(normalized, expected)

    false_close = (

        measured

        and normalized["close_allowed"] is True

        and expected.get("close_allowed") is False

    )

    false_vcs_merge_safe = (

        measured

        and normalized["vcs_merge_safe"] is True

        and expected.get("vcs_merge_safe") is not True

    )

    false_merge_allowed = (

        measured

        and normalized["merge_allowed"] is True

        and expected.get("merge_allowed") is False

    )

    return {

        "branch": expected.get("branch_name"),

        "measured": measured,

        "correct": correct,

        "false_close": false_close,

        "false_vcs_merge_safe": false_vcs_merge_safe,

        "false_merge_allowed": false_merge_allowed,

        "actual": normalized,

    }

def aggregate_triage_metrics(

    branch_results: list[dict[str, Any]],

    *,

    branches_expected: int,

) -> dict[str, Any]:

    measured = [row for row in branch_results if row.get("measured")]

    if not measured:

        return unmeasured_triage_metrics(branches_expected=branches_expected)

    correct = sum(1 for row in measured if row.get("correct"))

    false_close_count = sum(1 for row in measured if row.get("false_close"))

    close_eligible_n = sum(

        1 for row in branch_results if row.get("expected_close_allowed") is True

    )

    false_vcs_merge_safe_count = sum(1 for row in measured if row.get("false_vcs_merge_safe"))

    vcs_merge_safe_n = sum(

        1 for row in branch_results if row.get("expected_vcs_merge_safe") is True

    )

    false_merge_allowed_count = sum(1 for row in measured if row.get("false_merge_allowed"))

    merge_allowed_n = sum(

        1 for row in branch_results if row.get("expected_merge_allowed") is True

    )

    # Recall is recovery against the oracle set; precision is exact-match

    # accuracy among the branches that emitted a triage payload.

    recall = round(correct / branches_expected, 4) if branches_expected else None

    precision = round(correct / len(measured), 4) if measured else None

    return {

        "triage_recall": recall,

        "triage_precision": precision,

        "false_close_count": false_close_count,

        "close_eligible_n": close_eligible_n,

        "false_vcs_merge_safe_count": false_vcs_merge_safe_count,

        "vcs_merge_safe_n": vcs_merge_safe_n,

        "false_merge_allowed_count": false_merge_allowed_count,

        "merge_allowed_n": merge_allowed_n,

        "branches_scored": len(measured),

        "branches_expected": branches_expected,

    }

def unmeasured_triage_metrics(*, branches_expected: int) -> dict[str, Any]:

    return {key: None for key in TRIAGE_METRIC_KEYS} | {

        "branches_expected": branches_expected,

    }

def score_manifest_against_actuals(

    manifest: Mapping[str, Any],

    actual_by_branch: Mapping[str, Mapping[str, Any]],

) -> dict[str, Any]:

    branches = manifest.get("branches") or []

    branch_results: list[dict[str, Any]] = []

    for branch in branches:

        if not isinstance(branch, dict):

            continue

        name = str(branch.get("name") or "")

        expected = branch.get("expected") or {}

        actual = actual_by_branch.get(name, {})

        row = score_branch(actual, expected)

        row["branch"] = name

        row["shape"] = branch.get("shape")

        row["expected_close_allowed"] = expected.get("close_allowed")

        row["expected_vcs_merge_safe"] = expected.get("vcs_merge_safe")

        row["expected_merge_allowed"] = expected.get("merge_allowed")

        row["expected_recommended_action"] = expected.get("recommended_action")

        branch_results.append(row)

    return {

        "branch_results": branch_results,

        "metrics": aggregate_triage_metrics(

            branch_results,

            branches_expected=len(branch_results),

        ),

    }

def triage_metrics_row_fields(metrics: Mapping[str, Any]) -> dict[str, Any]:

    fields: dict[str, Any] = {}

    for key in TRIAGE_METRIC_KEYS:

        value = metrics.get(key)

        if key.endswith("_n") or key in ("branches_scored", "branches_expected"):

            fields[key] = value if isinstance(value, int) and value >= 0 else None

        elif value is None:

            fields[key] = None

        elif key.endswith("_count"):

            fields[key] = int(value)

        elif key in ("triage_recall", "triage_precision"):

            number = float(value)

            fields[key] = number if math.isfinite(number) and 0.0 <= number <= 1.0 else None

        else:

            fields[key] = value

    return fields

def validate_triage_metrics(metrics: Mapping[str, Any]) -> list[str]:

    errors: list[str] = []

    for key in TRIAGE_METRIC_KEYS:

        if key not in metrics:

            errors.append(f"missing triage metric {key!r}")

    for key in ("triage_recall", "triage_precision"):

        value = metrics.get(key)

        if value is not None and (

            isinstance(value, bool) or not isinstance(value, (int, float)) or not 0.0 <= float(value) <= 1.0

        ):

            errors.append(f"{key} must be null or within [0, 1]")

    for key in (

        "false_close_count",

        "close_eligible_n",

        "false_vcs_merge_safe_count",

        "vcs_merge_safe_n",

        "false_merge_allowed_count",

        "merge_allowed_n",

        "branches_scored",

        "branches_expected",

    ):

        value = metrics.get(key)

        if value is not None and (isinstance(value, bool) or not isinstance(value, int) or value < 0):

            errors.append(f"{key} must be null or a non-negative integer")

    return errors