#!/usr/bin/env python3
"""Freeze toolchain oracle truth for the Rust port battery (dichotomy
wave #2479 tranche, batch: toolchain — RUST side verdict).

Exercises EVERY public function across EVERY branch:
  ToolchainConstraints (known/unknown key classification, get with and
  without default, to_dict), DecisionRecord (list normalization: sorting
  of libraries/decisive_constraints/evidence_refs, None-list defaults,
  alternatives copy, confidence), CONSTRAINT_KEYS (frozen vocabulary),
  _major_change (existing-language equality branches), resolve_toolchain
  (INSUFFICIENT_EVIDENCE short path, KEEP_EXISTING with/without hard
  factors and performance evidence, same-language request, CHANGE_MAJOR
  with and without significant evidence, greenfield recommendation,
  greenfield INSUFFICIENT_EVIDENCE, falsy existing_language edges).

Output: src/rust/toolchain/src/frozen_tc_truth.json — replayed VERBATIM
by src/rust/toolchain/src/branch_battery.rs.

The module is fully deterministic (no wall-clock fields) — every case
compares exactly, no masking.
"""
from __future__ import annotations

import json
import os
import sys
from pathlib import Path

os.environ["RUNE_TC_CORE"] = "python"  # POISONED-TRUTH LAW: freeze the ORACLE, never the kernel

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))

from rune import toolchain as tc  # noqa: E402

cases: dict[str, list] = {}


def run(fn: str, name: str, *args, **kwargs):
    out = getattr(tc, fn)(**kwargs) if args == () else getattr(tc, fn)(*args, **kwargs)
    if hasattr(out, "to_dict"):
        out = out.to_dict()
    cases.setdefault(fn, []).append(
        {"name": name, "input": kwargs if args == () else {"args": args, "kwargs": kwargs},
         "expected": out})


# ── CONSTRAINT_KEYS: the frozen vocabulary ────────────────────────────
cases["constraint_keys"] = [{"name": "vocabulary",
                             "input": {},
                             "expected": sorted(tc.CONSTRAINT_KEYS)}]

# ── ToolchainConstraints: classification, get, to_dict ────────────────
for nm, kw in (
    ("known-only", dict(existing_language="python", target_platform="linux")),
    ("unknown-only", dict(wibble="future-thing", flurb=42)),
    ("mixed", dict(existing_language="rust", existing_runtime="tokio",
                   not_a_key=[1, 2], performance_sensitive=True, none_val=None)),
    ("empty", {}),
    ("every-known-key", {k: f"v-{k}" for k in tc.CONSTRAINT_KEYS}),
    ("falsy-values", dict(existing_language="", performance_sensitive=False,
                          memory_constrained=0)),
):
    c = tc.ToolchainConstraints(**kw)
    cases.setdefault("constraints", []).append(
        {"name": nm, "input": {"kwargs": kw}, "expected": c.to_dict()})

for nm, kw, key, default, has_default in (
    ("get-known", dict(existing_language="python"), "existing_language", None, False),
    ("get-missing-no-default", dict(existing_language="python"), "existing_runtime", None, False),
    ("get-missing-with-default", dict(existing_language="python"), "existing_runtime", "", True),
    ("get-unknown-key-stored", dict(wibble="x"), "wibble", None, False),
    ("get-known-falsy-value", dict(existing_language=""), "existing_language", "dflt", True),
    ("get-default-none-explicit", dict(a="1"), "b", None, True),
):
    c = tc.ToolchainConstraints(**kw)
    val = c.get(key, default) if has_default else c.get(key)
    cases.setdefault("constraints_get", []).append(
        {"name": nm, "input": {"known": c.known, "key": key,
                               "default": default if has_default else None},
         "expected": val})

# ── DecisionRecord: normalization branches ────────────────────────────
for nm, kw in (
    ("full-fields", dict(
        selected_language="rust", runtime="tokio", framework="axum",
        libraries=["zlib", "openssl", "a-lib"], build_system="cargo",
        alternatives=[{"language": "go", "rejected_because": "no evidence"}],
        decisive_constraints=["requested_language", "existing_language"],
        rationale="measured benefit", evidence_refs=["bench-2", "bench-1"],
        confidence=0.8, user_approval_required=True, resolution="CHANGE_MAJOR")),
    ("defaults", dict(selected_language="python")),
    ("none-lists-become-sorted-empty", dict(
        selected_language="python", libraries=None, decisive_constraints=None,
        evidence_refs=None, alternatives=None)),
    ("unsorted-normalized", dict(
        selected_language="python", libraries=["b", "a", "c"],
        decisive_constraints=["z", "a"], evidence_refs=["e2", "e1", "e0"],
        confidence=0.85)),
    ("empty-lists-kept", dict(
        selected_language="python", libraries=[], alternatives=[],
        decisive_constraints=[], evidence_refs=[], resolution="KEEP_EXISTING")),
):
    d = tc.DecisionRecord(**kw)
    cases.setdefault("decision_record", []).append(
        {"name": nm, "input": kw, "expected": d.to_dict()})

# ── _major_change ─────────────────────────────────────────────────────
for nm, kw, language in (
    ("different-language", dict(existing_language="python"), "rust"),
    ("same-language", dict(existing_language="python"), "python"),
    ("no-existing", {}, "rust"),
    ("falsy-existing", dict(existing_language=""), "rust"),
    ("non-str-existing", dict(existing_language=None), "rust"),
):
    c = tc.ToolchainConstraints(**kw)
    cases.setdefault("major_change", []).append(
        {"name": nm, "input": {"known": c.known, "language": language},
         "expected": tc._major_change(c, language)})

# ── resolve_toolchain: every branch ───────────────────────────────────
def res(nm, ckw, **kw):
    c = tc.ToolchainConstraints(**ckw)
    d = tc.resolve_toolchain(c, **kw)
    cases.setdefault("resolve_toolchain", []).append(
        {"name": nm,
         "input": {"known": c.known, "unknown": c.unknown, **kw},
         "expected": d.to_dict()})

# INSUFFICIENT short path: no existing, no request, <2 hard factors
res("insufficient-no-factors", dict(existing_runtime="tokio"))
res("insufficient-one-factor", dict(target_platform="linux"))
# falls through to greenfield INSUFFICIENT: >=2 hard factors, approval required
res("greenfield-insufficient-two-factors", dict(target_platform="linux", deployment="server"))
res("greenfield-insufficient-bools-count", dict(performance_sensitive=True, memory_constrained=True))
# KEEP_EXISTING branches
res("keep-existing-no-hard-factors", dict(existing_language="python"))
res("keep-existing-with-hard-factors", dict(existing_language="rust",
                                            performance_sensitive=True))
res("keep-existing-with-runtime-framework", dict(
    existing_language="typescript", existing_runtime="node",
    existing_framework="svelte", target_platform="web"))
res("keep-existing-performance-evidence-rejected", dict(
    existing_language="python", performance_sensitive=True),
    performance_evidence={"significant_benefit": True, "basis": "measured 10x"})
res("keep-existing-empty-perf-evidence", dict(existing_language="python"),
    performance_evidence={})
res("keep-existing-same-language-request", dict(existing_language="python"),
    requested_language="python")
res("keep-existing-with-evidence-refs", dict(existing_language="go"),
    evidence_refs=["ref-b", "ref-a", "ref-c"])
# CHANGE_MAJOR branches
res("change-major-no-evidence", dict(existing_language="python"),
    requested_language="rust")
res("change-major-significant", dict(existing_language="python",
                                     performance_sensitive=True),
    requested_language="rust",
    performance_evidence={"significant_benefit": True, "basis": "measured"})
res("change-major-falsy-significant", dict(existing_language="python"),
    requested_language="rust",
    performance_evidence={"significant_benefit": False})
res("change-major-null-significant", dict(existing_language="python"),
    requested_language="zig", performance_evidence={"significant_benefit": None})
# greenfield recommendation
res("greenfield-requested", dict(target_platform="linux", deployment="server"),
    requested_language="zig")
res("greenfield-requested-no-factors", dict(), requested_language="go")
# falsy existing_language edges: "" behaves as absent
res("falsy-existing-no-request", dict(existing_language=""))
res("falsy-existing-with-request", dict(existing_language=""),
    requested_language="rust")
# unknown keys ride along but do not affect the decision
res("unknown-keys-ignored", dict(existing_language="python", wibble="x"),
    requested_language="python")

truth = {
    "frozen": "toolchain full oracle truth (dichotomy wave #2479)",
    "oracle": "src/rune/toolchain.py",
    "note": ("The module is fully deterministic — no wall-clock fields, "
             "every case compares exactly. error = the exact Python "
             "exception message where applicable."),
    "cases": cases,
}
out = Path(__file__).resolve().parents[1] / "src" / "rust" / "toolchain" / "src" / "frozen_tc_truth.json"
out.write_text(json.dumps(truth, indent=1, sort_keys=True) + "\n")
total = sum(len(v) for v in cases.values())
print(f"frozen {total} cases across {len(cases)} functions -> {out}")