#!/usr/bin/env python3
"""Synthetic reference study for the Supervisory Capacity Model.

This is not evidence about people or deployed LLMs. It separates an exact
logistic-model recovery control from a queue-model mismatch test and detects
violations caused by correlated arrivals, batching, and switching costs.
"""

from __future__ import annotations

import json
from pathlib import Path

import numpy as np
from scipy.optimize import least_squares


SEED = 20260828
TEAM_SIZES = np.array([1, 2, 3, 4, 5, 6, 8, 10], dtype=float)
SESSIONS_PER_SIZE = 500
DURATION_MIN = 30
LAMBDA = 0.25
BUDGET = 1.0
TYPE_NAMES = ("perception", "comprehension", "projection")
TYPE_PROBS = np.array([0.50, 0.30, 0.20])
TYPE_COSTS = np.array([0.60, 1.00, 1.60])
TYPE_DEADLINES = np.array([2.0, 3.0, 4.0])
CONDITIONS = ("additive", "correlated", "batched", "switching")


def logistic(n: np.ndarray, floor: float, span: float, midpoint: float, tau: float) -> np.ndarray:
    z = np.clip((n - midpoint) / tau, -40.0, 40.0)
    return floor + span / (1.0 + np.exp(z))


def fit_curve(x: np.ndarray, y: np.ndarray) -> np.ndarray:
    def residual(theta: np.ndarray) -> np.ndarray:
        return logistic(x, *theta) - y

    initial = np.array([0.12, 0.82, 4.0, 1.0])
    lower = np.array([0.0, 0.05, 0.25, 0.10])
    upper = np.array([0.60, 1.00, 15.0, 8.0])
    return least_squares(residual, initial, bounds=(lower, upper)).x


def minute_arrivals(rng: np.random.Generator, n_agents: int, condition: str,
                    minute: int, event_rate: float = LAMBDA,
                    cost_scale: float = 1.0):
    events: list[list[float | int]] = []
    independent_rate = 0.68 * event_rate if condition == "correlated" else event_rate
    for agent in range(n_agents):
        for _ in range(rng.poisson(independent_rate)):
            kind = int(rng.choice(len(TYPE_NAMES), p=TYPE_PROBS))
            events.append([
                minute + rng.random(), agent, kind,
                float(TYPE_COSTS[kind] * cost_scale),
            ])

    if condition == "correlated":
        for _ in range(rng.poisson(event_rate - independent_rate)):
            kind = int(rng.choice(len(TYPE_NAMES), p=TYPE_PROBS))
            when = minute + rng.random()
            for agent in range(n_agents):
                events.append([
                    when, agent, kind, float(TYPE_COSTS[kind] * cost_scale),
                ])

    if condition == "batched" and events:
        by_kind: dict[int, list[int]] = {}
        for index, event in enumerate(events):
            by_kind.setdefault(int(event[2]), []).append(index)
        for kind, indices in by_kind.items():
            if len(indices) > 1:
                total = (TYPE_COSTS[kind] * cost_scale
                         * (1.0 + 0.25 * (len(indices) - 1)))
                per_event = float(total / len(indices))
                for index in indices:
                    events[index][3] = per_event
    return events


def simulate_session(rng: np.random.Generator, n_agents: int, condition: str,
                     event_rate: float = LAMBDA, budget: float = BUDGET,
                     cost_scale: float = 1.0,
                     deadline_scale: float = 1.0) -> float:
    events: list[list[float | int]] = []
    for minute in range(DURATION_MIN):
        events.extend(minute_arrivals(
            rng, n_agents, condition, minute, event_rate, cost_scale
        ))
    events.sort(key=lambda event: (float(event[0]), rng.random()))
    if not events:
        return np.nan

    available = 0.0
    previous_agent = None
    correct = 0
    for arrival, agent, kind, cost in events:
        switch = 0.35 if condition == "switching" and previous_agent not in (None, agent) else 0.0
        start = max(float(arrival), available)
        completion = start + (float(cost) + switch) / budget
        recovered = (completion - float(arrival)
                     <= TYPE_DEADLINES[int(kind)] * deadline_scale)
        p_correct = 0.95 if recovered else 0.15
        correct += int(rng.random() < p_correct)
        available = completion
        previous_agent = agent
    return correct / len(events)


def bootstrap_midpoint(
    rng: np.random.Generator, values: dict[int, np.ndarray], repetitions: int = 400
) -> tuple[float, float]:
    estimates = []
    for _ in range(repetitions):
        means = np.array(
            [rng.choice(values[int(n)], size=len(values[int(n)]), replace=True).mean() for n in TEAM_SIZES]
        )
        estimates.append(float(fit_curve(TEAM_SIZES, means)[2]))
    return tuple(np.quantile(estimates, [0.025, 0.975]))


def direct_logistic_control(rng: np.random.Generator) -> dict[str, object]:
    """Generate scores from the fitted model itself as a code recovery check."""
    truth = np.array([0.15, 0.80, 4.35, 0.90])
    values: dict[int, np.ndarray] = {}
    means = []
    for n in TEAM_SIZES.astype(int):
        probability = float(logistic(np.array([n]), *truth)[0])
        scores = rng.binomial(1, probability, size=SESSIONS_PER_SIZE).astype(float)
        values[n] = scores
        means.append(float(scores.mean()))
    theta = fit_curve(TEAM_SIZES, np.array(means))
    interval = bootstrap_midpoint(rng, values)
    return {
        "true_floor": float(truth[0]),
        "true_span": float(truth[1]),
        "true_midpoint": float(truth[2]),
        "true_tau": float(truth[3]),
        "fitted_floor": float(theta[0]),
        "fitted_span": float(theta[1]),
        "fitted_midpoint": float(theta[2]),
        "fitted_tau": float(theta[3]),
        "midpoint_ci": list(map(float, interval)),
        "means": means,
    }


def sensitivity_battery(rng: np.random.Generator) -> list[dict[str, float | str]]:
    """One-factor-at-a-time queue sensitivity; descriptive, not inferential."""
    settings = [("baseline", 1.0)]
    for factor in ("event_rate", "budget", "cost_scale", "deadline_scale"):
        settings.extend([(factor, 0.8), (factor, 1.2)])
    records = []
    for factor, multiplier in settings:
        values = {
            "event_rate": LAMBDA,
            "budget": BUDGET,
            "cost_scale": 1.0,
            "deadline_scale": 1.0,
        }
        if factor != "baseline":
            values[factor] *= multiplier
        means = []
        for n in TEAM_SIZES.astype(int):
            scores = np.array([
                simulate_session(rng, n, "additive", **values)
                for _ in range(200)
            ])
            means.append(float(scores[np.isfinite(scores)].mean()))
        fitted = float(fit_curve(TEAM_SIZES, np.array(means))[2])
        predicted = float(
            values["budget"]
            / (values["event_rate"] * values["cost_scale"]
               * np.dot(TYPE_PROBS, TYPE_COSTS))
        )
        records.append({
            "factor": factor,
            "multiplier": multiplier,
            "event_rate": values["event_rate"],
            "budget": values["budget"],
            "cost_scale": values["cost_scale"],
            "deadline_scale": values["deadline_scale"],
            "predicted_midpoint": predicted,
            "fitted_midpoint": fitted,
            "bias": fitted - predicted,
        })
    return records


def main() -> None:
    rng = np.random.default_rng(SEED)
    all_values: dict[str, dict[int, np.ndarray]] = {}
    results = {"direct_logistic_control": direct_logistic_control(rng)}

    for condition in CONDITIONS:
        condition_values = {}
        means = []
        for n in TEAM_SIZES.astype(int):
            scores = np.array(
                [simulate_session(rng, n, condition) for _ in range(SESSIONS_PER_SIZE)]
            )
            scores = scores[np.isfinite(scores)]
            condition_values[n] = scores
            means.append(float(scores.mean()))
        all_values[condition] = condition_values
        theta = fit_curve(TEAM_SIZES, np.array(means))
        interval = bootstrap_midpoint(rng, condition_values)
        results[condition] = {
            "means": means,
            "floor": float(theta[0]),
            "span": float(theta[1]),
            "midpoint": float(theta[2]),
            "tau": float(theta[3]),
            "midpoint_ci": list(map(float, interval)),
        }

    predicted_midpoint = BUDGET / (LAMBDA * float(np.dot(TYPE_PROBS, TYPE_COSTS)))
    results["design"] = {
        "seed": SEED,
        "sessions_per_size": SESSIONS_PER_SIZE,
        "duration_minutes": DURATION_MIN,
        "lambda": LAMBDA,
        "mean_service_cost": float(np.dot(TYPE_PROBS, TYPE_COSTS)),
        "budget": BUDGET,
        "predicted_midpoint": predicted_midpoint,
    }
    results["sensitivity_battery"] = sensitivity_battery(rng)

    root = Path(__file__).resolve().parent
    (root / "simulation_summary.json").write_text(json.dumps(results, indent=2) + "\n")

    rows = ["n additive correlated batched switching"]
    for index, n in enumerate(TEAM_SIZES.astype(int)):
        rows.append(
            f"{n} "
            + " ".join(f"{results[c]['means'][index]:.4f}" for c in CONDITIONS)
        )
    (root / "simulation_curves.dat").write_text("\n".join(rows) + "\n")

    table = [
        r"\begin{tabular}{lccc}",
        r"\toprule",
        r"Condition & nominal $n_0$ & fitted $n_{\mathrm{mid}}$ (95\% bootstrap) & diagnostic \\",
        r"\midrule",
    ]
    diagnostics = {
        "additive": "reference",
        "correlated": "shared bursts",
        "batched": "joint service",
        "switching": "agent-switch cost",
    }
    for condition in CONDITIONS:
        record = results[condition]
        lo, hi = record["midpoint_ci"]
        pred = f"{predicted_midpoint:.2f}" if condition == "additive" else "4.35 (naive)"
        label = condition.capitalize()
        table.append(
            f"{label} & {pred} & {record['midpoint']:.2f} "
            f"[{lo:.2f}, {hi:.2f}] & {diagnostics[condition]} \\\\"
        )
    table.extend([r"\bottomrule", r"\end{tabular}"])
    (root / "simulation_table.tex").write_text("\n".join(table) + "\n")

    print(json.dumps(results, indent=2))


if __name__ == "__main__":
    main()