#!/usr/bin/env python3

"""Run local VCS correctness diagnostics; stdout is diagnostic JSONL, not timing rows.

Suites: ``legacy`` (the five v1 restore/roundtrip scenarios), ``matrix`` (the

roundtrip conformance matrix, commit -> push -> fresh clone/pull, compared via

the independent reader and filesystem bytes), ``all`` (both, the default).

``--gate`` evaluates the Oak rows against config/conformance_expected_failures.json

and exits 0 PASS / 1 REGRESSED / 2 UNMEASURED (the devloop convention).

Without ``--gate`` the exit code is 1 when any row failed, else 0.

"""

import argparse

import json

from pathlib import Path

import sys

from oakbench.conformance import SCENARIOS, run_scenario

from oakbench import conformance_gate

from oakbench.conformance_matrix import BEHAVIOURS, BY_ID, fs_profile, probe_capabilities, run_matrix

def main():

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

    parser.add_argument("--workdir", type=Path, required=False)

    parser.add_argument("--subjects", default="git,oak")

    parser.add_argument("--git-bin", default="git")

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

    parser.add_argument("--suite", choices=("legacy", "matrix", "all"), default="all")

    parser.add_argument("--scenarios", default=",".join(SCENARIOS), help="legacy scenarios")

    parser.add_argument("--behaviours", default="", help="comma list of matrix behaviour IDs (default: all)")

    parser.add_argument("--include-gated", action="store_true", help="also run gated behaviours (huge files)")

    parser.add_argument("--output", type=Path, help="also write the JSONL rows here")

    parser.add_argument("--quiet", action="store_true", help="do not echo rows on stdout (use with --output)")

    parser.add_argument("--gate", action="store_true", help="exit by the conformance gate verdict")

    parser.add_argument("--expected-failures", type=Path, default=conformance_gate.EXPECTED_FAILURES)

    parser.add_argument("--list", action="store_true", help="print the behaviour catalog as JSONL and exit")

    args = parser.parse_args()

    if args.list:

        for behaviour in BEHAVIOURS:

            print(json.dumps(behaviour.describe(), sort_keys=True))

        return 0

    if args.workdir is None:

        parser.error("--workdir is required")

    subjects = args.subjects.split(",")

    scenarios = [s for s in args.scenarios.split(",") if s]

    behaviours = [b for b in args.behaviours.split(",") if b]

    if (not set(subjects) <= {"git", "oak"} or not set(scenarios) <= set(SCENARIOS)

            or not set(behaviours) <= set(BY_ID)):

        parser.error("unknown subject, scenario or behaviour")

    rows = []

    if args.output:

        args.output.parent.mkdir(parents=True, exist_ok=True)

    sink = args.output.open("w") if args.output else None

    profile = fs_profile(probe_capabilities(args.workdir.resolve()))

    def emit(row):

        row.setdefault("fs_profile", profile)

        line = json.dumps(row, sort_keys=True)

        if not args.quiet:

            print(line, flush=True)

        if sink:

            sink.write(line + "\n")

            sink.flush()

        rows.append(row)

    try:

        if args.suite in ("legacy", "all"):

            for subject in subjects:

                for scenario in scenarios:

                    emit(run_scenario(args.workdir.resolve(), subject, getattr(args, f"{subject}_bin"), scenario))

        if args.suite in ("matrix", "all"):

            run_matrix(args.workdir.resolve() / "matrix", {s: getattr(args, f"{s}_bin") for s in subjects},

                       behaviours or None, include_gated=args.include_gated or None, progress=emit)

    finally:

        if sink:

            sink.close()

    if args.gate:

        expected = conformance_gate.load_expected(args.expected_failures)

        required = []

        if "oak" in subjects:

            if args.suite in ("legacy", "all"):

                required += scenarios

            if args.suite in ("matrix", "all"):

                required += behaviours or [b.id for b in BEHAVIOURS]

        result = conformance_gate.evaluate(rows, expected, required)

        print("\n".join(conformance_gate.summary_lines(result)), file=sys.stderr)

        return {"PASS": 0, "REGRESSED": 1}.get(result["verdict"], 2)

    return int(any(row["returncode"] == 1 for row in rows))

if __name__ == "__main__":

    raise SystemExit(main())