"""Sequential test: stopping boundaries and path simulator.

beta_theory(n, alpha)    = 1 + log(2(1+n)/alpha)      eq. (7)
beta_practical(n, alpha) = log(1/alpha)                eq. (8)
tau = inf{ n >= 1 : n * KL_inf(q_hat_n, m_o) >= beta(n, alpha) }   eq. (3)
"""
import math
import numpy as np

from core.klinf import ell, klinf_emp

_HT_TOL = 1e-9
_SANDWICH_TOL = 1e-6


def beta_theory(n, alpha):
    return 1.0 + math.log(2.0 * (1.0 + n) / alpha)


def beta_practical(n, alpha):
    return math.log(1.0 / alpha)


def _beta_fn(beta_kind):
    if beta_kind == "theory":
        return beta_theory
    if beta_kind == "practical":
        return beta_practical
    raise ValueError(f"unknown beta_kind {beta_kind!r}")


def run_path(rng, sampler, m_o, alphas, beta_kind, n_max, n_chunk=256):
    """Simulate one path, recording the first crossing n for every alpha in
    `alphas` on a single shared stream. Returns a dict keyed by alpha with
    tau, klinf/lam_star/sigma2 at tau and tau-1, and a censored flag."""
    beta_fn = _beta_fn(beta_kind)
    # eq (11) bounds the '+' branch (m_o >= mean) by 1/(1-m_o); by the
    # mirrored argument the '-' branch (m_o < mean) is bounded by 1/m_o.
    ht_bound_plus = 1.0 / (1.0 - m_o)
    ht_bound_minus = 1.0 / m_o

    x = np.empty(n_max, dtype=float)
    n = 0
    lam_prev = None
    prev_snapshot = None  # (val, lam, sigma2) at n-1
    pending = set(alphas)
    out = {}

    while n < n_max and pending:
        take = min(n_chunk, n_max - n)
        x[n:n + take] = sampler(rng, take)
        for i in range(take):
            n += 1
            xk = x[:n]
            val, lam, case = klinf_emp(xk, m_o, lam_hint=lam_prev)
            lam_prev = lam if case == "interior" else None

            running_mean = float(np.mean(xk))
            ht_bound = ht_bound_plus if m_o >= running_mean else ht_bound_minus
            assert val <= ht_bound + _HT_TOL, f"HT bound violated at n={n}: {val} > {ht_bound}"

            resid = ell(lam, xk, m_o) - val
            sigma2_hat = float(np.mean(resid ** 2))
            snapshot = dict(n=n, klinf=val, lam_star=lam, sigma2=sigma2_hat)

            stat = n * val
            crossed_now = []
            for a in list(pending):
                b = beta_fn(n, a)
                if stat >= b:
                    crossed_now.append(a)

            for a in crossed_now:
                b_tau = beta_fn(n, a)
                if n >= 2 and prev_snapshot is not None:
                    b_tau_m1 = beta_fn(n - 1, a)
                    lower = b_tau / val if val > 0 else float("inf")
                    upper = 1.0 + (b_tau_m1 / prev_snapshot["klinf"]
                                    if prev_snapshot["klinf"] > 0 else float("inf"))
                    assert lower - _SANDWICH_TOL <= n < upper + _SANDWICH_TOL, \
                        f"eq(17) sandwich violated at tau={n}, alpha={a}: {lower} <= {n} < {upper}"
                out[a] = dict(
                    tau=n, censored=False,
                    klinf_tau=snapshot["klinf"], lam_star_tau=snapshot["lam_star"],
                    sigma2_tau=snapshot["sigma2"],
                    klinf_tau_m1=(prev_snapshot["klinf"] if prev_snapshot else None),
                    lam_star_tau_m1=(prev_snapshot["lam_star"] if prev_snapshot else None),
                    sigma2_tau_m1=(prev_snapshot["sigma2"] if prev_snapshot else None),
                )
                pending.discard(a)

            prev_snapshot = snapshot
            if not pending:
                break

    for a in pending:
        out[a] = dict(tau=n, censored=True, klinf_tau=None, lam_star_tau=None,
                       sigma2_tau=None, klinf_tau_m1=None, lam_star_tau_m1=None,
                       sigma2_tau_m1=None)
    for a in out:
        if "censored" not in out[a]:
            out[a]["censored"] = False
    return out