#!/usr/bin/env python3
"""Original operations arithmetic, Python 3.11+. No network or deployment.

Synthetic request observations and a discrete queue model, not a load test.
"""
import json
from math import isfinite


def slo_report(events, target=0.99, latency_limit_ms=2000):
    if not isfinite(target) or not 0 < target <= 1 or not isfinite(latency_limit_ms) or latency_limit_ms < 0:
        raise ValueError("Use a target in (0, 1] and a finite nonnegative latency limit.")
    for event in events:
        if type(event["ok"]) is not bool or not isfinite(event["ms"]) or event["ms"] < 0:
            raise ValueError("Each event needs a boolean outcome and finite nonnegative latency.")
    count = len(events)
    good = sum(event["ok"] and event["ms"] <= latency_limit_ms for event in events)
    allowance = round(count * (1 - target), 10)
    return {"eligible": count, "good": good, "bad": count - good,
            "rate": good / count if count else None, "target": target,
            "bad_event_allowance": allowance,
            "remaining_budget": round(allowance - (count - good), 10),
            "meets_target": good / count >= target if count else None}


def queue_model(arrivals, capacity, limit):
    if any(type(x) is not int or x < 0 for x in [*arrivals, capacity, limit]):
        raise ValueError("Queue counts, capacity and limit must be nonnegative integers.")
    backlog = completed = rejected = 0
    steps = []
    for incoming in arrivals:
        admitted = min(incoming, limit - backlog)
        denied = incoming - admitted
        processed = min(capacity, backlog + admitted)
        backlog += admitted - processed
        completed += processed
        rejected += denied
        steps.append({"arrived": incoming, "admitted": admitted, "rejected": denied,
                      "processed": processed, "remaining": backlog})
    return {"assumption": "Admit arrivals before serving each discrete interval.",
            "steps": steps, "arrived": sum(arrivals), "completed": completed,
            "rejected": rejected, "remaining": backlog,
            "conserved": sum(arrivals) == completed + rejected + backlog}


def release_decision(critical_passed, reliability, recovery_compatible):
    reasons = []
    if critical_passed is not True:
        reasons.append("Critical checks are not established as passing")
    if reliability.get("meets_target") is not True:
        reasons.append("Defined reliability objective is not established as met")
    if recovery_compatible is not True:
        reasons.append("Recovery compatibility is not established")
    return {"decision": "hold" if reasons else "eligible for accountable review",
            "reasons": reasons, "scope": "Illustrative policy only; no release is performed or authorized."}


def main():
    events = [{"ok": True, "ms": 900} for _ in range(988)] + [{"ok": False, "ms": 100} for _ in range(12)]
    reliability = slo_report(events)
    print(json.dumps({"scope": "Synthetic arithmetic and queue simulation, not observed production behavior.",
                      "slo": reliability, "empty_window": slo_report([]),
                      "queue": queue_model([20, 8, 0], capacity=10, limit=15),
                      "release": release_decision(True, reliability, True)}, indent=2, allow_nan=False))


if __name__ == "__main__":
    main()