#!/usr/bin/env python3
"""Offline six-task teaching comparison; no network or external file access."""
from collections import Counter
from math import isfinite
from statistics import median

DEADLINE_SECONDS = 2.0
OBSERVATION_END_SECONDS = 4.0
REQUIRED_ON_TIME = 5
EXPECTED_TASK_IDS = frozenset("task-%02d" % n for n in range(1, 7))
EXPECTED_SCOPE = "authorized-window-1"
CONTRACT = {
    "schedule": "six-paired-tasks-v1",
    "target_set": "authorized-fixture-targets-v1",
    "window": EXPECTED_SCOPE,
    "clock": "scheduled-eligibility-to-first-accepted-result",
    "validity": "expected-item-fields-and-region-v1",
    "retry_policy": "one-attempt-no-retries",
    "deadline_seconds": DEADLINE_SECONDS,
    "observation_end_seconds": OBSERVATION_END_SECONDS,
    "client_region_load": "same-client-region-schedule-and-load-v1",
}
POLICIES = {name: dict(CONTRACT) for name in ("A", "B")}
KNOWN_OUTCOMES = frozenset(("accepted", "deadline_miss", "connection_failure",
                            "queue_not_started", "missing_telemetry"))
# Same task IDs name the same permitted task in each route. All data is invented.
ROWS = (
    ("A", "task-01", EXPECTED_SCOPE, "accepted", 1.0),
    ("A", "task-02", EXPECTED_SCOPE, "accepted", 1.1),
    ("A", "task-03", EXPECTED_SCOPE, "accepted", 1.2),
    ("A", "task-04", EXPECTED_SCOPE, "accepted", 1.3),
    ("A", "task-05", EXPECTED_SCOPE, "deadline_miss", None),
    ("A", "task-06", EXPECTED_SCOPE, "connection_failure", None),
    ("B", "task-01", EXPECTED_SCOPE, "accepted", 1.4),
    ("B", "task-02", EXPECTED_SCOPE, "accepted", 1.5),
    ("B", "task-03", EXPECTED_SCOPE, "accepted", 1.6),
    ("B", "task-04", EXPECTED_SCOPE, "accepted", 1.7),
    ("B", "task-05", EXPECTED_SCOPE, "accepted", 1.8),
    ("B", "task-06", EXPECTED_SCOPE, "queue_not_started", None),
)


def summarize(rows, policies=None):
    """Validate declarations, not their truth; only the fixed six-task design fits."""
    policies = POLICIES if policies is None else policies
    if not isinstance(policies, dict) or set(policies) != {"A", "B"}:
        raise ValueError("missing or unexpected policy declarations")
    for name, policy in policies.items():
        if (not isinstance(policy, dict) or set(policy) != set(CONTRACT)
                or any(type(policy[k]) is not type(v) or policy[k] != v
                       for k, v in CONTRACT.items())):
            raise ValueError("mismatched declared contract for " + name)
    if not isinstance(rows, (list, tuple)) or not rows:
        raise ValueError("rows must be a nonempty list or tuple")
    groups = {"A": [], "B": []}
    for row in rows:
        if not isinstance(row, (list, tuple)) or len(row) != 5:
            raise ValueError("each row needs provider, task, scope, outcome, elapsed")
        provider, task_id, scope, outcome, elapsed = row
        if not all(isinstance(x, str) for x in row[:4]):
            raise ValueError("provider, task, scope and outcome must be strings")
        if provider not in groups or outcome not in KNOWN_OUTCOMES:
            raise ValueError("unknown provider or outcome")
        if scope != EXPECTED_SCOPE:
            raise ValueError("mismatched row scope")
        if outcome == "accepted":
            if (type(elapsed) not in (int, float) or not isfinite(elapsed)
                    or not 0 <= elapsed <= OBSERVATION_END_SECONDS):
                raise ValueError("accepted elapsed must be finite and within the closed window")
        elif elapsed is not None:
            raise ValueError("no accepted-completion time may be invented for a noncompletion")
        groups[provider].append((task_id, outcome, elapsed))
    summary = {}
    for provider, tasks in groups.items():
        ids = [row[0] for row in tasks]
        if len(ids) != len(set(ids)):
            raise ValueError("duplicate task ID for " + provider)
        if set(ids) != EXPECTED_TASK_IDS:
            raise ValueError("mismatched schedule for " + provider)
        observed = [t for _, outcome, t in tasks if outcome == "accepted"]
        # Nearest-rank p95 has rank ceil(.95 * 6) = 6 in THIS fixed design.
        # Any absent accepted completion leaves that last order statistic unknown.
        summary[provider] = {
            "scheduled": len(tasks),
            "completed_p50": median(observed) if observed else None,
            "on_time_valid": sum(t <= DEADLINE_SECONDS for t in observed),
            "all_task_p95": max(observed) if len(observed) == 6 else None,
            "counts": Counter(outcome for _, outcome, _ in tasks),
        }
    return summary


def decision(summary):
    if any(item["counts"]["missing_telemetry"] for item in summary.values()):
        return "HOLD: missing telemetry prevents a comparable decision"
    eligible = [name for name, item in sorted(summary.items())
                if item["on_time_valid"] >= REQUIRED_ON_TIME]
    if not eligible:
        return "HOLD: no provider meets the predeclared on-time threshold"
    return "REVIEW: %s eligible_for_followup at >=%d/6 on-time valid tasks" % (
        ", ".join(eligible), REQUIRED_ON_TIME)


def assess(rows, policies=None):
    try:
        summary = summarize(rows, policies)
    except (ValueError, OverflowError) as error:
        return None, "HOLD: %s" % error
    return summary, decision(summary)


def format_p95(value):
    return "NOT_IDENTIFIABLE" if value is None else "%.2fs" % value


def render(summary, verdict):
    if summary is None:
        return verdict
    lines = ["synthetic fixture only; no network requests",
             "good_result=accepted; deadline_seconds=2.0; denominator=scheduled tasks; required_on_time=5/6"]
    for provider in ("A", "B"):
        x = summary[provider]; c = x["counts"]
        p50 = "UNDEFINED" if x["completed_p50"] is None else "%.2fs" % x["completed_p50"]
        lines.append("%s: scheduled=%d completed_only_p50=%s on_time_valid=%d/%d "
                     "all_task_p95=%s deadline_miss=%d connection_failure=%d "
                     "queue_not_started=%d missing_telemetry=%d" % (
                         provider, x["scheduled"], p50, x["on_time_valid"], x["scheduled"],
                         format_p95(x["all_task_p95"]), c["deadline_miss"],
                         c["connection_failure"], c["queue_not_started"], c["missing_telemetry"]))
    a, b = summary["A"], summary["B"]
    if a["completed_p50"] is None or b["completed_p50"] is None:
        lines.append("completed-only ranking: UNDEFINED")
    elif a["completed_p50"] == b["completed_p50"]:
        lines.append("completed-only ranking: TIE")
    else:
        fast, slow = sorted(summary, key=lambda k: summary[k]["completed_p50"])
        lines.append("completed-only ranking: %s faster (%.2fs < %.2fs)" % (
            fast, summary[fast]["completed_p50"], summary[slow]["completed_p50"]))
    if a["on_time_valid"] == b["on_time_valid"]:
        lines.append("deadline-completion ranking: TIE")
    else:
        high, low = sorted(summary, key=lambda k: -summary[k]["on_time_valid"])
        lines.append("deadline-completion ranking: %s stronger (%d/6 > %d/6)" % (
            high, summary[high]["on_time_valid"], summary[low]["on_time_valid"]))
    lines.append(verdict)
    return "\n".join(lines)


if __name__ == "__main__":
    print(render(*assess(ROWS)))
