#!/usr/bin/env python3
"""MQG test 21 scorer: applies the frozen rules of MQG_TEST_21_PUBLIC_PLAN (rev. 2, Sec. 5) to the 36 rows written
by mqg_test21_runner.py. Usage: python mqg_test21_score.py <output-dir of the runner> [--json verdict.json]
Pure Python + NumPy; no scipy. The frozen numbers below are checked against the plan's predictor at start."""
import argparse, json, math
from pathlib import Path

THETAS = (0.005, 0.015, 0.03)
SIZES = (640, 1280, 2560, 5120)
MUS = (1.5, 2.0, 2.5)
DECIDE, DECIDING_ROWS = 0.025, (10, 13, 16, 19, 21, 25, 27)       # predictor_output.txt
TOL_K, TIE_E, MIN_NONTIE_E = 0.02, 0.002, 5
D_HI, D_LO = 0.99, 0.90
TOL_C = 0.01
PAIRS = (((0.015, 2560), (0.03, 640)), ((0.015, 5120), (0.03, 1280)))
TOL_ABS_R, TOL_ARG_DEG = 0.03, 6.0
SMALL_X = 0.6


def Phi(z):
    return 0.5 * (1 + math.erf(z / math.sqrt(2)))


def table():
    out, k = {}, 0
    for th in THETAS:
        for N in SIZES:
            for mu in MUS:
                k += 1
                x = math.sin(2 * th) * math.sqrt(N / 2)
                kap = math.sqrt(2 / mu)
                psi = math.degrees(math.atan2(math.sqrt(mu - 1), 1 - mu / 2))
                out[k] = dict(k=k, theta=th, N=N, mu=mu, x=x, PhiK=Phi(kap * x), PhiE=Phi(x), psi=psi)
    dec = tuple(k for k, r in out.items() if abs(r['PhiK'] - r['PhiE']) >= DECIDE)
    assert dec == DECIDING_ROWS, f'deciding rows {dec} differ from the frozen list'
    return out


def score(rows):
    """rows: dict k -> dict(censored, P, r=[re, im], twa=dict(P, se, censored)). Returns the verdicts."""
    T = table()
    assert sorted(rows) == list(range(1, 37)), 'need rows 1..36'
    cens = sorted(k for k in rows if rows[k]['censored'])
    v = dict(censored_rows=cens)
    # K
    if cens:
        v['K'] = 'not evaluable'
    else:
        dk = {k: abs(rows[k]['P'] - T[k]['PhiK']) for k in rows}
        v['K_max_dev'] = max(dk.values())
        v['K'] = 'met' if all(d <= TOL_K for d in dk.values()) else 'not met'
    # E
    if any(k in cens for k in DECIDING_ROWS):
        v['E'] = 'not evaluable'
    else:
        det, nontie = [], []
        for k in DECIDING_ROWS:
            a, b = abs(rows[k]['P'] - T[k]['PhiK']), abs(rows[k]['P'] - T[k]['PhiE'])
            tie = abs(a - b) < TIE_E
            det.append(dict(k=k, dK=a, dE=b, tie=tie))
            if not tie:
                nontie.append(a < b)
        v['E_rows'] = det
        if len(nontie) >= MIN_NONTIE_E and all(nontie):
            v['E'] = 'K favoured'
        elif len(nontie) >= MIN_NONTIE_E and not any(nontie):
            v['E'] = 'E favoured'
        else:
            v['E'] = 'neither'
    # D
    small = [k for k in rows if T[k]['theta'] == 0.005]
    if any(k in cens for k in small):
        v['D'] = 'not evaluable'
    else:
        Ps = [rows[k]['P'] for k in small]
        v['D'] = 'favoured' if all(p >= D_HI for p in Ps) else ('rejected' if all(p <= D_LO for p in Ps) else 'neither')
    # C
    key = {(T[k]['theta'], T[k]['N'], T[k]['mu']): k for k in T}
    comps, ne = [], False
    for (a, b) in PAIRS:
        for mu in MUS:
            ka, kb = key[a + (mu,)], key[b + (mu,)]
            if ka in cens or kb in cens:
                ne = True
                continue
            comps.append(dict(rows=(ka, kb), diff=abs(rows[ka]['P'] - rows[kb]['P'])))
    v['C_comparisons'] = comps
    v['C'] = 'not evaluable' if ne else ('met' if all(c['diff'] <= TOL_C for c in comps) else 'not met')
    # S
    if cens:
        v['S'] = 'not evaluable'
    else:
        worst_abs = worst_arg = 0.0
        for k in rows:
            re, im = rows[k]['r']
            worst_abs = max(worst_abs, abs(math.hypot(re, im) - 1))
            d = (math.degrees(math.atan2(im, re)) - T[k]['psi'] + 180) % 360 - 180
            worst_arg = max(worst_arg, abs(d))
        v['S_worst'] = dict(abs_r_minus_1=worst_abs, arg_deg=worst_arg)
        v['S'] = 'met' if (worst_abs <= TOL_ABS_R and worst_arg <= TOL_ARG_DEG) else 'not met'
    # Q (information only)
    q = []
    for k in rows:
        tw = rows[k].get('twa') or {}
        if rows[k]['censored'] or tw.get('censored', True):
            continue
        d = rows[k]['P'] - tw['P']
        se = tw['se']
        q.append(dict(k=k, x=T[k]['x'], diff=d, se=se,
                      flag=bool(T[k]['x'] < SMALL_X and se > 0 and abs(d) > 3 * se)))
    v['Q'] = q
    v['Q_flags'] = [e['k'] for e in q if e['flag']]
    v['outcome'] = outcome(v)
    return v


def outcome(v):
    """plan Sec. 7, in words."""
    s = []
    if v['K'] == 'met' and v['E'] == 'E favoured':
        s.append('K met and E favoured: both laws within tolerance; verdict follows E')
    elif v['K'] == 'met' and v['S'] == 'met' and v['C'] == 'met':
        s.append('K, S and C met: choice and slaving fixed by linear theory with one variable x')
        if v['E'] != 'K favoured':
            s.append(f"Rule E: {v['E']} (K and E not separated)")
    else:
        if v['K'] == 'not met' and v['E'] == 'E favoured':
            s.append('K not met, E favoured')
        if v['D'] == 'favoured':
            s.append('D favoured')
        if v['C'] == 'not met':
            s.append('C not met')
        if v['S'] == 'not met':
            s.append('S not met')
        if not s:
            s.append('mixed result; see the individual rules')
    if v['censored_rows']:
        s.append(f"censored rows: {v['censored_rows']}")
    return '; '.join(s)


def load_rows(d):
    rows = {}
    for f in sorted(Path(d, 'rows').glob('MQG21-*.json')):
        if f.name.endswith('_series.npz'):
            continue
        r = json.loads(f.read_text())
        rows[r['k']] = r
    return rows


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument('outdir')
    ap.add_argument('--json')
    a = ap.parse_args()
    g = json.loads(Path(a.outdir, 'guards.json').read_text())
    if not all(x['ok'] for x in g.values()):
        raise SystemExit('a guard failed: the run is void')
    rows = load_rows(a.outdir)
    shas = {r['runner_sha256'] for r in rows.values()}
    if len(shas) != 1:
        raise SystemExit(f'rows come from different runners: {shas}')
    v = score(rows)
    v['runner_sha256'] = shas.pop()
    v['deposit_doi'] = sorted({r['deposit_doi'] for r in rows.values()})
    for r in ('K', 'E', 'D', 'C', 'S'):
        print(f'Rule {r}: {v[r]}')
    print('Q flags (information only):', v['Q_flags'])
    print('Outcome:', v['outcome'])
    if a.json:
        Path(a.json).write_text(json.dumps(v, indent=1))


if __name__ == '__main__':
    main()
