#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-3.0-or-later
"""Synthetic tests for Phase-1.0AB nonblocking lifecycle traces."""

from __future__ import annotations

import argparse
import importlib.util
from pathlib import Path
import sys


def load(path: Path):
    spec = importlib.util.spec_from_file_location("phase10ab_trace", path)
    assert spec and spec.loader
    module = importlib.util.module_from_spec(spec); sys.modules[spec.name] = module
    spec.loader.exec_module(module); return module


def main() -> int:
    parser = argparse.ArgumentParser(); parser.add_argument("--root", type=Path, required=True)
    args = parser.parse_args(); module = load(args.root.resolve() / "tools/phase10ab_nonblocking_trace_model.py")

    def event(op, at, value=0): return module.TraceEvent(op, at, value)
    def valid(pending=True, sends=(2, 3), waits=()):
        values = [event(module.RECEIPT_CREATED, 0), event(module.SOCKET_CREATED, 0), event(module.SET_NONBLOCKING, 0)]
        if pending:
            values += [event(module.CONNECT_PENDING, .1), event(module.READY_WRITE, .2), event(module.SO_ERROR_ZERO, .2)]
        else: values += [event(module.CONNECT_IMMEDIATE, .1)]
        at = .3
        for count in sends:
            values += [event(module.READY_WRITE, at), event(module.SEND_BYTES, at, count)]; at += .1
        for op in waits: values.append(event(op, at)); at += .1
        values += [event(module.READY_READ, at), event(module.RECV_BYTES, at, 100), event(module.DEADLINE_REACHED, 10), event(module.SANITIZER_ACCEPTED, 10), event(module.LOCAL_CLOSE, 10), event(module.OUTPUT_CREATED, 10)]
        return tuple(values)
    def expect_failure(function):
        try: function()
        except module.TraceModelError: return
        raise RuntimeError("invalid trace accepted")
    cases = []
    def case(name):
        def register(function): cases.append((name, function)); return function
        return register

    @case("01 pending connect complete trace succeeds")
    def _():
        result = module.assess_nonblocking_trace(5, 10, valid()); assert result.batch_bytes_sent == 5
    @case("02 immediate connect complete trace succeeds")
    def _(): assert module.assess_nonblocking_trace(5, 10, valid(False)).classification == "OFFLINE_NONBLOCKING_SEQUENCE_FEASIBLE"
    @case("03 partial sends require repeated readiness")
    def _(): assert module.assess_nonblocking_trace(5, 10, valid(sends=(1, 1, 3))).complete_send_loop
    @case("04 interrupted waits are recomputed")
    def _(): assert module.assess_nonblocking_trace(5, 10, valid(waits=(module.WAIT_INTERRUPTED,))).deadline_only_completion
    @case("05 timeout before deadline is not completion")
    def _(): assert module.assess_nonblocking_trace(5, 10, valid(waits=(module.WAIT_TIMEOUT,))).local_close_observed
    @case("06 receipt must precede creation")
    def _(): expect_failure(lambda: module.assess_nonblocking_trace(5, 10, valid()[1:]))
    @case("07 nonblocking must precede connect")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.SET_NONBLOCKING); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("08 pending connect requires readiness")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.READY_WRITE or e.at_seconds != .2); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("09 pending connect requires SO_ERROR")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.SO_ERROR_ZERO); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("10 send requires write readiness")
    def _():
        trace = tuple(e for e in valid() if not (e.operation == module.READY_WRITE and e.at_seconds == .3)); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("11 send cannot exceed exact batch")
    def _(): expect_failure(lambda: module.assess_nonblocking_trace(5, 10, valid(sends=(6,))))
    @case("12 incomplete send fails")
    def _(): expect_failure(lambda: module.assess_nonblocking_trace(5, 10, valid(sends=(2, 2))))
    @case("13 receive requires read readiness")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.READY_READ); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("14 receive bound is enforced")
    def _():
        trace = list(valid()); index = next(i for i,e in enumerate(trace) if e.operation == module.RECV_BYTES); trace[index] = event(module.RECV_BYTES, trace[index].at_seconds, 65537); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, tuple(trace)))
    @case("15 EOF never completes")
    def _():
        trace = list(valid()); index = next(i for i,e in enumerate(trace) if e.operation == module.RECV_BYTES); trace[index] = event(module.RECV_EOF, trace[index].at_seconds); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, tuple(trace)))
    @case("16 early deadline fails")
    def _():
        trace = tuple(event(e.operation, 9 if e.operation in {module.DEADLINE_REACHED,module.SANITIZER_ACCEPTED,module.LOCAL_CLOSE,module.OUTPUT_CREATED} else e.at_seconds, e.value) for e in valid()); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("17 data at deadline fails")
    def _():
        trace = list(valid()); index = next(i for i,e in enumerate(trace) if e.operation == module.RECV_BYTES); trace[index] = event(module.RECV_BYTES, 10, 100); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, tuple(trace)))
    @case("18 deadline requires received data")
    def _():
        trace = tuple(e for e in valid() if e.operation not in {module.READY_READ,module.RECV_BYTES}); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("19 sanitizer must follow deadline")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.DEADLINE_REACHED); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("20 close must follow sanitizer")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.SANITIZER_ACCEPTED); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("21 output must follow close")
    def _():
        trace = tuple(e for e in valid() if e.operation != module.LOCAL_CLOSE); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, trace))
    @case("22 backward time fails")
    def _():
        trace = list(valid()); trace[2] = event(module.SET_NONBLOCKING, -.0); trace[1] = event(module.SOCKET_CREATED, .1); expect_failure(lambda: module.assess_nonblocking_trace(5, 10, tuple(trace)))
    @case("23 trace event bound is enforced")
    def _(): expect_failure(lambda: module.assess_nonblocking_trace(5, 10, tuple(event(module.RECEIPT_CREATED, 0) for _ in range(513))))
    @case("24 result never claims device proof")
    def _():
        result = module.assess_nonblocking_trace(5, 10, valid()); assert not result.device_behavior_proven and not result.live_transport_present
    @case("25 no live API exists")
    def _(): assert not ({"connect", "send", "recv", "main"} & set(dir(module)))

    failures=[]
    for name,function in cases:
        try: function(); print(f"PASS {name}")
        except Exception as error: failures.append(f"{name}: {error}"); print(f"FAIL {name}: {error}")
    if failures: return 1
    print(f"Phase-1.0AB nonblocking-trace tests passed: {len(cases)}"); return 0


if __name__ == "__main__": raise SystemExit(main())