#!/usr/bin/env python3

"""Differential merge-correctness suite: git merge-ort (oracle) vs Oak's merge engine.

stdout: diagnostic JSONL (one row per directional case), then nothing else.

--summary FILE: JSON summary (counts per class, merge-law rates, oak-wrong list).

Exit: 0 when no case is oak-wrong or harness-error, 1 otherwise, 2 on usage error.

Rows are diagnostic evidence (evidence_class diagnostic_merge_correctness); never

ingest them into performance reports. See suites/merge/README.md.

"""

from __future__ import annotations

import argparse

import fnmatch

import json

from pathlib import Path

import shutil

import sys

HERE = Path(__file__).resolve().parent

sys.path.insert(0, str(HERE))

sys.path.insert(0, str(HERE.parents[1] / "scripts"))

from mergesuite import sources  # noqa: E402

from mergesuite.runner import SCHEMA_VERSION, Suite, stale_schema_rows, summarize  # noqa: E402

GROUPS = ("gix-tree", "gix-cartesian", "gix-text", "t64xx", "native", "generated")

def resolve_git(explicit: str | None) -> str:

    if explicit:

        return explicit

    try:

        from oakbench.subjects import which_measured_git

        found = which_measured_git()

    except Exception:  # pragma: no cover - oakbench import is best effort

        found = shutil.which("git")

    if not found:

        raise SystemExit("git not found")

    return found

def load(groups, workdir: Path, git_bin: str, home: Path, gen_count: int, gen_seed: int):

    scenarios = []

    if "gix-tree" in groups:

        scenarios += sources.gitoxide_tree(workdir, git_bin, home)

    if "gix-cartesian" in groups:

        scenarios += sources.gitoxide_cartesian(workdir, git_bin, home)

    if "gix-text" in groups:

        scenarios += sources.gitoxide_text(workdir, git_bin, home)

    if "t64xx" in groups:

        scenarios += sources.git_t64xx(workdir, git_bin, home)

    if "native" in groups:

        scenarios += sources.native_incidents(workdir, git_bin, home)

    if "generated" in groups:

        scenarios += sources.generated(workdir, git_bin, home, gen_count, gen_seed)

    return scenarios

def main(argv=None) -> int:

    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)

    ap.add_argument("--workdir", type=Path, required=True, help="scratch dir (fixtures, oak serve data, cases)")

    ap.add_argument("--oak-bin", default="oak")

    ap.add_argument("--git-bin", default=None, help="oracle git (default: real git, xcrun shim resolved)")

    ap.add_argument("--groups", default=",".join(GROUPS), help="comma list of " + ",".join(GROUPS))

    ap.add_argument("--only", default=None, help="fnmatch pattern on scenario id")

    ap.add_argument("--limit", type=int, default=None)

    ap.add_argument("--jobs", type=int, default=4)

    ap.add_argument("--generated-count", type=int, default=40)

    ap.add_argument("--generated-seed", type=int, default=20260928)

    ap.add_argument("--keep-equal", action="store_true", help="keep case dirs of equal-to-git cases")

    ap.add_argument("--summary", type=Path, default=None)

    ap.add_argument("--list", action="store_true", help="list scenario ids and exit")

    ap.add_argument("--resummarize", type=Path, default=None, metavar="JSONL",

                    help="recompute the summary (known-bug mapping included) from an existing JSONL run; no Oak")

    ap.add_argument("--allow-stale-schema", action="store_true",

                    help="with --resummarize: summarize rows written under an older row/reason schema anyway "

                         "(known-bug statuses become 'indeterminate'); default refuses")

    args = ap.parse_args(argv)

    groups = [g for g in args.groups.split(",") if g]

    if not set(groups) <= set(GROUPS):

        ap.error("unknown group")

    if args.resummarize:

        rows = [json.loads(line) for line in args.resummarize.read_text().splitlines() if line.strip()]

        stale = stale_schema_rows(rows)

        if stale:

            print(f"resummarize: {sum(stale.values())}/{len(rows)} row(s) predate merge-suite row/reason schema "

                  f"v{SCHEMA_VERSION} (found {stale}); their reasons cannot be mapped to the current known-bug "

                  "patterns, so a missing bug would read as 'fixed'. Re-run the suite"

                  + (" (--allow-stale-schema given: statuses reported as indeterminate)."

                     if args.allow_stale_schema else ", or pass --allow-stale-schema."), file=sys.stderr)

            if not args.allow_stale_schema:

                return 2

        summary = finish_summary(summarize(rows), rows)

        if args.summary:

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

        print(format_table(summary), file=sys.stderr)

        return 1 if summary["counts"]["oak-wrong"] or summary["counts"]["harness-error"] else 0

    git_bin = resolve_git(args.git_bin)

    workdir = args.workdir.resolve()

    workdir.mkdir(parents=True, exist_ok=True)

    suite = Suite(workdir, args.oak_bin, git_bin, jobs=args.jobs, keep_equal=args.keep_equal)

    scenarios = load(groups, workdir / "fixtures-src", git_bin, suite.git_home,

                     args.generated_count, args.generated_seed)

    if args.only:

        scenarios = [s for s in scenarios if fnmatch.fnmatch(s["id"], args.only)]

    if args.limit:

        scenarios = scenarios[:args.limit]

    if args.list:

        for s in scenarios:

            print(s["id"] + ("  [unsupported: %s]" % s["unsupported"] if s["unsupported"] else ""))

        return 0

    def emit(row):

        print(json.dumps(row, sort_keys=True), flush=True)

    rows = suite.run(scenarios, emit)

    summary = finish_summary(summarize(rows), rows)

    summary["meta"] = suite.meta

    summary["run_id"] = suite.run_id

    if args.summary:

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

    print(format_table(summary), file=sys.stderr)

    return 1 if summary["counts"]["oak-wrong"] or summary["counts"]["harness-error"] else 0

def finish_summary(summary: dict, rows) -> dict:

    summary["phase2_specs_not_executed"] = [s["id"] for s in sources.PHASE2_SPECS]

    summary["oak_wrong"] = [{"scenario": r["scenario"], "direction": r["direction"], "reasons": r["reasons"],

                             "known_bug": r.get("known_bug"),

                             "case_dir": r.get("case_dir"), "repro": r["repro"]}

                            for r in rows if r["class"] == "oak-wrong"]

    summary["harness_errors"] = [{"scenario": r["scenario"], "direction": r["direction"], "reasons": r["reasons"]}

                                 for r in rows if r["class"] == "harness-error"]

    return summary

def format_table(summary: dict) -> str:

    classes = list(summary["counts"])

    lines = ["| origin | " + " | ".join(classes) + " |", "|---|" + "---|" * len(classes)]

    for origin, counts in sorted(summary["by_origin"].items()):

        lines.append(f"| {origin} | " + " | ".join(str(counts[c]) for c in classes) + " |")

    lines.append("| **total** | " + " | ".join(str(summary["counts"][c]) for c in classes) + " |")

    lines.append("")

    for law, v in summary["laws"].items():

        lines.append(f"{law}: {v['true']}/{v['measured']}")

    lines.append("")

    for bug, info in (summary.get("known_bugs") or {}).items():

        lines.append(f"{bug} ({info['family']}): {info['rows']} row(s), pinned {info['expected_rows']} - "

                     f"{info['status']}; new={len(info['new_rows'])} vanished={len(info['vanished_rows'])}")

    if "oak_wrong_unmapped" in summary:

        lines.append(f"oak-wrong rows not mapped to a known bug: {summary['oak_wrong_unmapped']}")

        lines.append(f"failed pulls violating 'failed sync => worktree matches HEAD' (HEAD moved or worktree "

                     f"left dirty): {summary['post_failure_hazard_rows']}")

        lines.append(f"missed conflicts by class: {summary['missed_conflict_by_class']}")

        lines.append(f"missed conflicts by git kind: {summary['missed_conflict_by_git_kind']}")

    return "\n".join(lines)

if __name__ == "__main__":

    raise SystemExit(main())