"""Statistica appaiata: McNemar esatto, IC Newcombe (metodo 10) e Tango, Wilson, bootstrap a grappoli."""
import math
import random

Z90 = 1.6448536269514722
Z95 = 1.959963984540054


def binom_two_sided(b, c):
    """McNemar esatto a due code: binomiale(n=b+c, 1/2), p = min(1, 2*P(X<=min))."""
    n = b + c
    if n == 0:
        return 1.0
    k = min(b, c)
    s = sum(math.comb(n, i) for i in range(k + 1)) / 2 ** n
    return min(1.0, 2 * s)


def wilson(x, n, z=Z95):
    if n == 0:
        return (0.0, 1.0)
    p = x / n
    den = 1 + z * z / n
    c = (p + z * z / (2 * n)) / den
    h = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / den
    return (max(0.0, c - h), min(1.0, c + h))


def paired_counts(x, y):
    """x, y: liste 0/1 appaiate. a = entrambe giuste, b = x giusta y sbagliata, c = x sbagliata y giusta, d."""
    a = sum(1 for i, j in zip(x, y) if i and j)
    b = sum(1 for i, j in zip(x, y) if i and not j)
    c = sum(1 for i, j in zip(x, y) if not i and j)
    d = sum(1 for i, j in zip(x, y) if not i and not j)
    return a, b, c, d


def newcombe10(a, b, c, d, z=Z90):
    """Newcombe (1998) metodo 10, differenza p1 - p2 con p1 = (a+b)/n, p2 = (a+c)/n."""
    n = a + b + c + d
    p1, p2 = (a + b) / n, (a + c) / n
    l1, u1 = wilson(a + b, n, z)
    l2, u2 = wilson(a + c, n, z)
    num = a * d - b * c
    if num > 0:
        num = max(num - n / 2, 0)
    den = (a + b) * (c + d) * (a + c) * (b + d)
    phi = num / math.sqrt(den) if den > 0 else 0.0
    th = p1 - p2
    dl = math.sqrt(max(0.0, (p1 - l1) ** 2 - 2 * phi * (p1 - l1) * (u2 - p2) + (u2 - p2) ** 2))
    du = math.sqrt(max(0.0, (u1 - p1) ** 2 - 2 * phi * (u1 - p1) * (p2 - l2) + (p2 - l2) ** 2))
    return th, th - dl, th + du


def _tango_z(b, c, n, delta):
    """Statistica score di Tango (1998) per Δ = (b - c)/n; p21 vincolata stimata per massima verosimiglianza."""
    # log-verosimiglianza in q = p21 con p12 = q + Δ, resto 1 - 2q - Δ (a+d raggruppati)
    lo = max(0.0, -delta) + 1e-12
    hi = (1 - delta) / 2 - 1e-12
    if hi <= lo:
        return float("inf") if (b - c - n * delta) > 0 else float("-inf")
    rest = n - b - c

    def ll(q):
        v = 0.0
        if b:
            v += b * math.log(q + delta)
        if c:
            v += c * math.log(q)
        if rest:
            v += rest * math.log(max(1e-300, 1 - 2 * q - delta))
        return v
    # massimo di una funzione concava: sezione aurea
    g = (math.sqrt(5) - 1) / 2
    x1, x2 = hi - g * (hi - lo), lo + g * (hi - lo)
    f1, f2 = ll(x1), ll(x2)
    for _ in range(200):
        if f1 < f2:
            lo, x1, f1 = x1, x2, f2
            x2 = lo + g * (hi - lo)
            f2 = ll(x2)
        else:
            hi, x2, f2 = x2, x1, f1
            x1 = hi - g * (hi - lo)
            f1 = ll(x1)
    q = (lo + hi) / 2
    var = n * (2 * q + delta - delta * delta)
    if var <= 0:
        var = 1e-12
    return (b - c - n * delta) / math.sqrt(var)


def tango(a, b, c, d, z=Z90):
    n = a + b + c + d
    th = (b - c) / n

    def root(lo, hi, target):
        # Z(Δ) è decrescente in Δ
        for _ in range(100):
            m = (lo + hi) / 2
            if _tango_z(b, c, n, m) > target:
                lo = m
            else:
                hi = m
        return (lo + hi) / 2
    low = root(-0.999999, th, z) if th > -0.999999 else -1.0
    up = root(th, 0.999999, -z) if th < 0.999999 else 1.0
    return th, low, up


def ni_verdict(lower, margin=0.05):
    return "dimostrata" if lower > -margin else "non dimostrata"


def cluster_bootstrap(pairs_by_cluster, B=10000, seed=20261017):
    """pairs_by_cluster: {cluster: [(x, y), ...]}. Restituisce la distribuzione della differenza p_x - p_y."""
    rng = random.Random(seed)
    keys = list(pairs_by_cluster)
    out = []
    for _ in range(B):
        sx = sy = n = 0
        for _k in range(len(keys)):
            for x, y in pairs_by_cluster[keys[rng.randrange(len(keys))]]:
                sx += x
                sy += y
                n += 1
        out.append((sx - sy) / n)
    out.sort()
    return out


def pct(sorted_vals, q):
    i = q * (len(sorted_vals) - 1)
    lo, hi = math.floor(i), math.ceil(i)
    return sorted_vals[lo] + (sorted_vals[hi] - sorted_vals[lo]) * (i - lo)