#!/usr/bin/env python3
"""Require the native acceptance matrix and report observed metadata work."""

import pathlib
import re
import sys


def report(path):
    """Read completed fixture records without accepting partial test output."""
    lines = path.read_text().splitlines()
    completed = set(lines)
    samples = {}
    waits = {}
    pending = None
    pending_wait = None
    invariants = False
    cycles_invariants = False
    cycles_pending = None
    cycles_wait = None
    for line in lines:
        if line == "smp final ownership and interval invariants passed":
            if invariants:
                raise ValueError("duplicate SMP invariant completion")
            invariants = True
        elif match := re.fullmatch(r"smp metadata instructions: 0x([0-9a-f]+)", line):
            pending = int(match[1], 16)
        elif match := re.fullmatch(r"smp acquisition instructions: 0x([0-9a-f]+)", line):
            pending_wait = int(match[1], 16)
        elif match := re.fullmatch(r"smp: ([128])-hart execution passed", line):
            if pending is None or pending <= 0:
                raise ValueError("SMP completion has no positive metadata measurement")
            if not invariants:
                raise ValueError("SMP completion has no final invariant check")
            invariants = False
            name = f"SMP {match[1]} harts"
            if name in samples:
                raise ValueError("duplicate SMP completion")
            samples[name] = pending
            waits[name] = pending_wait
            pending = None
            pending_wait = None
        elif line == "cycles final recovery and invariants passed":
            if cycles_invariants:
                raise ValueError("duplicate cycles invariant completion")
            cycles_invariants = True
        elif match := re.fullmatch(r"cycles metadata instructions: ([0-9a-f]+)", line):
            cycles_pending = int(match[1], 16)
        elif match := re.fullmatch(r"cycles acquisition instructions: ([0-9a-f]+)", line):
            cycles_wait = int(match[1], 16)
        elif match := re.fullmatch(r"cycles: ([128])-hart load, spawn, yield, fault, and recovery passed", line):
            if not cycles_invariants or cycles_pending is None or cycles_pending <= 0:
                raise ValueError("cycles completion has no final invariants or metadata measurement")
            name = f"cycles {match[1]} harts"
            if name in samples:
                raise ValueError("duplicate cycles completion")
            samples[name] = cycles_pending
            waits[name] = cycles_wait
            cycles_invariants = False
            cycles_pending = None
            cycles_wait = None
        elif match := re.fullmatch(r"runtime (admission )?metadata instructions: ([0-9a-f]+)", line):
            name = "runtime admission" if match[1] else "runtime completion"
            if name in samples:
                raise ValueError("duplicate runtime metadata measurement")
            samples[name] = int(match[2], 16)
        elif match := re.fullmatch(r"runtime (admission )?acquisition instructions: ([0-9a-f]+)", line):
            name = "runtime admission" if match[1] else "runtime completion"
            if name in waits:
                raise ValueError("duplicate runtime acquisition measurement")
            waits[name] = int(match[2], 16)
    names = {"SMP 1 harts", "SMP 2 harts", "SMP 8 harts", "runtime admission", "runtime completion"}
    names.update(f"cycles {harts} harts" for harts in (1, 2, 8))
    if samples.keys() != names or any(value <= 0 for value in samples.values()):
        raise ValueError("metadata measurements are incomplete")
    if waits.keys() != names or any(value is None or value <= 0 for value in waits.values()):
        raise ValueError("acquisition measurements are incomplete")
    required = {
        "dispatch: 1-hart execution passed",
        "termination: 1-hart execution passed",
        "runtime: scheduled cancellation, retry, and publication passed",
        "bootstrap: root exit preserves allocation and creation authority",
        "mmio: 1-hart execution passed",
    }
    for harts in (1, 2, 8):
        required.add(f"scheduling: {harts}-hart root handoff, four user-space yields, and checked shutdown passed")
    for profile, counts in (("dispatch", (1,)), ("smp", (1, 2, 8)), ("termination", (1,)),
                            ("runtime", (1,)), ("bootstrap", (1,)), ("mmio", (1,)),
                            ("scheduling", (1, 2, 8)), ("cycles", (1, 2, 8))):
        for harts in counts:
            required.add(f"replay: {profile} {harts}-hart output matched")
    if missing := required - completed:
        raise ValueError("native completions are missing: " + "; ".join(sorted(missing)))
    for name, value in sorted(samples.items()):
        print(f"{name}: {value} maximum metadata instructions")
        print(f"{name}: {waits[name]} maximum acquisition instructions")
    print(f"SMP/runtime/cycles maximum observed metadata work: {max(samples.values())} instructions")
    print(f"SMP/runtime/cycles maximum observed acquisition work: {max(waits.values())} instructions")


def main():
    """Report a log produced by the acceptance runner."""
    if len(sys.argv) != 2:
        raise ValueError("usage: metrics test-log")
    report(pathlib.Path(sys.argv[1]))


if __name__ == "__main__":
    try:
        main()
    except (OSError, ValueError) as error:
        print(f"kernel acceptance: {error}", file=sys.stderr)
        sys.exit(1)