#!/usr/bin/env python3
"""Numbers cards 09 to 14 of Part 3 need that no other script measured, written to find-film-extra-cardsB.json.

  shells        near rest, per Fourier shell: how many index pairs, sigma, the factor per period. Nothing but the Jacobian and the stencil.
  first_free    numpy seed 1, the first free period from noise: the envelope's size per band of shells, at 17 instants, and std(u).
  cost_by_k     the leading factor per sweep at k free periods, from the spectrum, and which mode sets it.
  slide_table   the exact frame: rms(slide^p(frame at j T/3) - frame) for p, j in 0, 1, 2.
  integrators   the film's T with Euler, Heun and RK4 at equal cost in rate calls, from the exact frame, one step length.
  fixed_h       the program with `h = t / steps` replaced by `h = dt`: the frames then land on multiples of dt, not on t.
  two_thirds    from the exact frame, simulate(third, T/3) against simulate(q, 2T/3), over a grid of T.
Run: PY find_film_extra_cardsB.py         (about two minutes, one core)"""
import json
import math
import os
import sys
import time

import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import twisted_average as ta  # noqa: E402

F = os.path.dirname(HERE)
OUT = os.path.join(F, 'results', 'find-film-extra-cardsB.json')
DATA = json.load(open(os.path.join(HERE, 'page', 'part3-data.json')))
T_STAR = DATA['T_star']
N, L, a, b = ta.N, ta.L, ta.a, ta.b
rest = np.array([a, b / a])[:, None, None]
rms = lambda x: float(np.sqrt(np.mean(x * x)))
res = {'about': 'Written by find_film_extra_cardsB.py: what cards 09 to 14 of Part 3 quote that no other script measured.', 'page': {}}


def save():
    json.dump(res, open(OUT, 'w'), indent=0)


def frame():
    import base64
    return np.frombuffer(base64.b64decode(DATA['frame_f64']), dtype='<f8').reshape(2, N, N).copy()


# ---- near rest: the Jacobian's eigenvector and each Fourier index's growth
J = np.array([[b - 1, a * a], [-b, -a * a]])
sigma0 = float(np.trace(J) / 2)
omega = float(np.sqrt(np.linalg.det(J) - sigma0 ** 2))
vals, right = np.linalg.eig(J)
i_plus = int(np.argmax(vals.imag))
r_vec = right[:, i_plus]
left = np.linalg.inv(right)[i_plus]                   # left[0] u + left[1] v is the envelope for sigma + i omega
assert abs(left @ r_vec - 1) < 1e-12


def wrap(i):
    return i - N if i >= N / 2 else i


def shell_of(m, n):
    return m * m + n * n + (m + n) * (m + n)


def lam(m, n):
    tm, tn = 2 * np.pi * m / N, 2 * np.pi * n / N
    return 2 / (3 * (L / N) ** 2) * (2 * np.cos(tm) + 2 * np.cos(tn) + 2 * np.cos(tm + tn) - 6)


def shells():
    by = {}
    for mi in range(N):
        for ni in range(N):
            m, n = wrap(mi), wrap(ni)
            s = shell_of(m, n)
            sg = sigma0 + lam(m, n)
            d = by.setdefault(s, dict(shell=s, count=0, sigma=[]))
            d['count'] += 1
            d['sigma'].append(float(sg))
    rows = []
    for s in sorted(by):
        d = by[s]
        sg = float(np.mean(d['sigma']))
        rows.append(dict(shell=s, count=d['count'], sigma=sg, sigma_spread=float(np.ptp(d['sigma'])), per_period=float(np.exp(sg * 6.355))))
    return rows


rows_sh = shells()
growing = [r for r in rows_sh if r['sigma'] > 0]
res['shells'] = dict(rows=rows_sh[:14], total_indices=N * N, growing_indices=int(sum(r['count'] for r in growing)), growing_shells=[r['shell'] for r in growing],
                     least_per_period=float(min(r['per_period'] for r in rows_sh)), lap_min=float(lam(N // 2, N // 2)) if False else float(min(lam(wrap(i), wrap(j)) for i in range(N) for j in range(N))))
lab = json.load(open(os.path.join(F, 'results', 'find-film-extra-lab.json')))
modes = json.load(open(os.path.join(F, 'results', 'find-film-modes.json')))
f_slow = modes['m6b_landings']['counts']['f']
res['per_decade'] = math.log(10) / math.log(1 / f_slow)
res['rest_xy_abs_max'] = max(abs(x) for x in modes['m6_state_space']['rest_state_xy'])
res['page']['story_rows'] = [dict(sweep=r['sweep'], T=r['T'], rms=r['rms']) for r in lab['story']['rows']]
save()

# ---- the first free period from noise, seed 1
BANDS = [[0, 0], [2, 2], [6, 6], [8, 8], [14, 14], [18, 18], [24, 26], [32, 62], [64, 200], [202, 800], [802, 100000]]
shell_grid = np.zeros((N, N), dtype=int)
for mi in range(N):
    for ni in range(N):
        shell_grid[ni, mi] = shell_of(wrap(mi), wrap(ni))
band_mask = [(shell_grid >= lo) & (shell_grid <= hi) for lo, hi in BANDS]


def band_sizes(q):
    q0 = rest
    A = left[0] * (q[0] - q0[0, 0, 0]) + left[1] * (q[1] - q0[1, 0, 0])
    Ah = np.fft.fft2(A) / (N * N)
    return [float(np.sqrt(np.mean(np.abs(Ah[m]) ** 2))) for m in band_mask]


noise = np.random.default_rng(1).standard_normal((2, N, N))
q0 = rest + 0.1 * noise
q0 = (q0 + ta.turn(q0) + ta.turn(ta.turn(q0))) / 3
rows = []
q = q0.copy()
for j in range(17):
    t = 6.355 * j / 16
    if j:
        q = ta.simulate(q, 6.355 / 16)
    rows.append(dict(t=t, std_u=float(np.std(q[0])), bands=band_sizes(q)))
first = rows[0]['bands']
last = rows[-1]['bands']
res['first_free'] = dict(seed=1, bands=BANDS, std_start=rows[0]['std_u'], std_end=rows[-1]['std_u'], rows=rows, ratio=[None if x == 0 else y / x for x, y in zip(first, last)])
res['page']['bands'] = BANDS
# The mean's bar runs under the line at amplitude 0.1. At a small amplitude every bar sits on its line: so the gap is the square of the noise, not the linear law.
small = rest + 1e-3 * noise
small = (small + ta.turn(small) + ta.turn(ta.turn(small))) / 3
after = ta.simulate(small, 6.355)
s0, s1 = band_sizes(small), band_sizes(after)
res['first_free']['ratio_small_amp'] = dict(amp=1e-3, ratio=[y / x for x, y in zip(s0, s1)])
res['first_free']['linear_mean'] = float(np.exp(sigma0 * 6.355))
res['first_free']['ratio_mean'] = res['first_free']['ratio'][0]
res['first_free']['ratio_mean_small'] = s1[0] / s0[0]
res['first_free']['ratio_fine'] = res['first_free']['ratio'][-1]
save()

# ---- k free periods: the leading factor per sweep, from the spectrum
spec = DATA['spectrum_sym']
rows = []
for k in range(0, 9):
    best = None
    for m in spec:
        if (m.get('name') or '').startswith('time shift'):
            continue
        f = m['abs3'] ** k * m['bare']
        if best is None or f > best[0]:
            best = (f, m.get('name') or ('abs3=%.3f' % m['abs3']))
    # lag = C f^sweep, C about the program's median
    C = 0.29
    rows.append(dict(k=k, factor=best[0], mode=best[1], sweeps=math.log(1e-10 / C) / math.log(best[0]) if best[0] < 1 else None, cost_per_sweep=k + 2 / 3))
    rows[-1]['periods'] = rows[-1]['sweeps'] * rows[-1]['cost_per_sweep'] if rows[-1]['sweeps'] else None
res['cost_by_k'] = dict(C=0.29, rows=rows)
save()

# ---- the slide table on the exact frame
fr = frame()
third = ta.simulate(fr, T_STAR / 3)
two = ta.simulate(third, T_STAR / 3)
frames = [fr, third, two]
table = []
for j, f in enumerate(frames):
    row = []
    for p in range(3):
        g = f
        for _ in range(p):
            g = ta.slide(g)
        row.append(rms(g - fr))
    table.append(row)
res['slide_table'] = dict(rows=table, spread_u=float(np.std(fr[0])), q_minus_slide_q=table[0][1], third_vs_q=table[1][0], third_slid=table[1][1], two_slid=table[2][2])
save()

# ---- the integrators, at one step length, from the exact frame


def euler(q, t, dt):
    steps = int(np.ceil(t / dt))
    h = t / steps
    for _ in range(steps):
        q = q + h * ta.rate(q)
    return q


def heun(q, t, dt):
    steps = int(np.ceil(t / dt))
    h = t / steps
    for _ in range(steps):
        k1 = ta.rate(q)
        k2 = ta.rate(q + h * k1)
        q = q + h / 2 * (k1 + k2)
    return q


def rk4(q, t, dt):
    steps = int(np.ceil(t / dt))
    h = t / steps
    for _ in range(steps):
        k1 = ta.rate(q)
        k2 = ta.rate(q + h / 2 * k1)
        k3 = ta.rate(q + h / 2 * k2)
        k4 = ta.rate(q + h * k3)
        q = q + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
    return q


def loop_thirds(step, dt, sweeps=60, tol=1e-12):
    """The program with the free period run as three thirds, so one step length and no floor from mismatched counts."""
    q, T = fr.copy(), T_STAR
    last = None
    for sweep in range(1, sweeps + 1):
        for _ in range(3):
            q = step(q, T / 3, dt)
        third = step(q, T / 3, dt)
        two_ = step(third, T / 3, dt)
        lag = ta.slide(third) - q
        last = rms(lag)
        if last < tol:
            return dict(T=float(T), sweeps=sweep, lag=last, std_u=float(np.std(q[0])), status='returned')
        speed = ta.rate(q)
        T -= np.clip(3 * np.sum(lag * speed) / np.sum(speed * speed), -0.1, 0.1)
        q = (q + ta.slide(third) + ta.slide(ta.slide(two_))) / 3
    return dict(T=float(T), sweeps=sweeps, lag=last, std_u=float(np.std(q[0])), status='stopped')


t0 = time.time()
rows = []
for name, step, order, cost, dts in (('RK4', rk4, 4, 4, [0.04, 0.02, 0.01, 0.005]), ('Heun', heun, 2, 2, [0.04, 0.02, 0.01]), ('Euler', euler, 1, 1, [0.02, 0.01, 0.005, 0.0025])):
    for dt in dts:
        r = loop_thirds(step, dt)
        r.update(method=name, dt=dt, rate_calls_per_unit_time=cost / dt)
        rows.append(r)
        res['integrators'] = dict(rows=rows)
        save()
        print(name, dt, r, round(time.time() - t0), flush=True)
rk = {r['dt']: r['T'] for r in rows if r['method'] == 'RK4'}
T_lim = rk[0.005] + (rk[0.005] - rk[0.01]) / 15     # Richardson, fourth order
for r in rows:
    r['T_minus_limit'] = r['T'] - T_lim
res['integrators'] = dict(rows=rows, T_limit=T_lim, ratio_rk4_halving=[(rk[0.04] - rk[0.02]) / (rk[0.02] - rk[0.01]), (rk[0.02] - rk[0.01]) / (rk[0.01] - rk[0.005])],
                          same_cost={'RK4': [r for r in rows if r['method'] == 'RK4' and r['dt'] == 0.02][0]['T_minus_limit'], 'Heun': [r for r in rows if r['method'] == 'Heun' and r['dt'] == 0.01][0]['T_minus_limit'], 'Euler': [r for r in rows if r['method'] == 'Euler' and r['dt'] == 0.005][0]['T_minus_limit']})
save()

# ---- the program with h = dt: frames land on multiples of dt


def simulate_fixed(q, t):
    steps = int(np.ceil(t / ta.dt))
    h = ta.dt
    for _ in range(steps):
        k1 = ta.rate(q)
        k2 = ta.rate(q + h / 2 * k1)
        k3 = ta.rate(q + h / 2 * k2)
        k4 = ta.rate(q + h * k3)
        q = q + h / 6 * (k1 + 2 * k2 + 2 * k3 + k4)
    return q


def film_fixed(seed, sweeps=60):
    q = rest + 0.1 * np.random.default_rng(seed).standard_normal((2, N, N))
    q = (q + ta.turn(q) + ta.turn(ta.turn(q))) / 3
    T = 6.355
    trace = []
    for sweep in range(1, sweeps + 1):
        q = simulate_fixed(q, T)
        third = simulate_fixed(q, T / 3)
        two_ = simulate_fixed(third, T / 3)
        lag = ta.slide(third) - q
        e = rms(lag)
        trace.append(e)
        if e < 1e-10:
            return dict(seed=seed, status='returned', sweeps=sweep, T=float(T), lag=e)
        speed = ta.rate(q)
        T -= np.clip(3 * np.sum(lag * speed) / np.sum(speed * speed), -0.1, 0.1)
        q = (q + ta.slide(third) + ta.slide(ta.slide(two_))) / 3
    return dict(seed=seed, status='not stopped', sweeps=sweeps, T=float(T), lag=e, least_lag=float(min(trace)), last10_least=float(min(trace[-10:])), last10_most=float(max(trace[-10:])))


rows = [film_fixed(s) for s in (1, 2)]
res['fixed_h'] = dict(rows=rows, least=min(r['least_lag'] for r in rows if 'least_lag' in r) if any('least_lag' in r for r in rows) else None)
save()
print('fixed', rows, round(time.time() - t0), flush=True)

# ---- two_thirds: from third against from q, over T
rows = []
for T in np.arange(6.30, 6.5001, 0.005):
    T = float(T)
    a1 = ta.simulate(fr, T / 3)
    chain = ta.simulate(a1, T / 3)
    direct = ta.simulate(fr, 2 * T / 3)
    rows.append(dict(T=round(T, 5), third=int(np.ceil(T / 3 / ta.dt)), direct=int(np.ceil(2 * T / 3 / ta.dt)), d=rms(chain - direct)))
at_star = [ta.simulate(ta.simulate(fr, T_STAR / 3), T_STAR / 3), ta.simulate(fr, 2 * T_STAR / 3)]
diffs = [r['d'] for r in rows if r['third'] * 2 != r['direct']]
res['two_thirds'] = dict(at_T_star=rms(at_star[0] - at_star[1]), differ_rms=dict(least=float(min(diffs)), most=float(max(diffs))), equal_counts_zero=all(r['d'] == 0 for r in rows if r['third'] * 2 == r['direct']), share_equal=sum(1 for r in rows if r['third'] * 2 == r['direct']) / len(rows))
res['page']['comb'] = rows
save()
print('done', round(time.time() - t0), flush=True)
