"""Give every paper in src/data/research.json its own Chladni figure and colour field.

Each paper gets `figure` (parameters for src/scripts/chladni.ts) and `field` (three colour tokens
and their positions), seeded from the paper id so a re-run gives the same result and a new paper
gets its own. Generation follows the rules learned while hand-tuning the first figures:

- plate windows stay clear of both axes and of any coordinate where n·t and m·t are both whole
  (the field is zero along a straight line there), plates are never mirrored (the seams read as
  straight lines), and the
  weights avoid a = ±b (which zeroes the diagonals u = ±v);
- hover keeps both plate terms in play (a single sin·sin term is a straight grid);
- source figures use three to six sources (two sources draw a straight bisector), spread over
  enough of a wavelength that they interfere (radius × frequency >= 0.6 for five or six sources,
  0.35 for three or four); packed tighter they collapse into plain concentric rings;
- one colour patch sits in the middle of the card, so no field is mostly black;
- line density, the share of grid cells a nodal line passes through, stays within the range of
  the hand-picked figures, so no card is near-empty or a scribble.

A paper that already has a figure keeps it unless --regenerate is passed, so hand edits survive.
Usage: python3 scripts/research-figures.py [--regenerate] [--report]
"""
import hashlib, json, math, random, sys

PATH = 'src/data/research.json'
ASPECT = 3  # the card canvas is 3:1
Q = 61      # grid for the density check (the site renders at 121)

COLOURS = [
    'logo-deep', 'logo-mid', 'logo-teal', 'logo-cyan',
    'field-indigo', 'field-petrol', 'field-sea', 'field-steel', 'field-dusk',
    'field-cobalt', 'field-ocean', 'field-glacier', 'field-aqua', 'field-jade', 'field-slate', 'field-plum',
]
# Light tones carry the glow; at most one per field, so every card keeps a dark side.
LIGHT = {'logo-cyan', 'field-glacier', 'field-aqua', 'logo-teal'}


def field_fn(f, shape=None):
    s = {**f, **(shape or {})}
    if f['mode'] == 'plate':
        a, b, n, m = s['a'], s['b'], s['n'], s['m']
        rot = s.get('rotation', 0)
        c, si = math.cos(rot), math.sin(rot)
        ox, oy = f['origin']
        def z(x, y):
            dx, dy = x - ox, y - oy
            u, v = ox + dx * c - dy * si, oy + dx * si + dy * c
            return a * math.sin(math.pi * n * u) * math.sin(math.pi * m * v) + b * math.sin(math.pi * m * u) * math.sin(math.pi * n * v)
        return z
    pts = []
    for i in range(f['sources']):
        t = i / f['sources'] * 2 * math.pi - math.pi / 2 + s.get('spin', 0)
        pts.append((f['origin'][0] + s['radius'] * math.cos(t), f['origin'][1] + s['radius'] * math.sin(t)))
    k = 2 * math.pi * s['frequency']
    inv = 1 / s['elasticity']
    return lambda x, y: sum(math.sin(k * (s['phase'] - inv * math.hypot(x - px, y - py))) for px, py in pts)


def density(f, shape=None):
    z = field_fn(f, shape)
    h = f['length']; w = h * ASPECT
    x0, y0 = f['origin'][0] - w / 2, f['origin'][1] - h / 2
    g = [[z(x0 + c * w / (Q - 1), y0 + r * h / (Q - 1)) > 0 for c in range(Q)] for r in range(Q)]
    cells = sum(1 for r in range(Q - 1) for c in range(Q - 1) if len({g[r][c], g[r][c + 1], g[r + 1][c], g[r + 1][c + 1]}) > 1)
    return cells / (Q - 1) ** 2


def straight_lines(n, m, origin, hx, hy):
    """True if the window crosses a coordinate where n·t and m·t are both whole: both terms of the
    plate vanish there for every value of the other coordinate, which draws a straight line."""
    for centre, half in ((origin[0], hx), (origin[1], hy)):
        steps = 400
        for i in range(steps + 1):
            t = centre - half + 2 * half * i / steps
            if abs(n * t - round(n * t)) < 0.03 and abs(m * t - round(m * t)) < 0.03:
                return True
    return False


def rnd(rng, lo, hi, step=0.01):
    return round(rng.uniform(lo, hi) / step) * step


def make_plate(rng, rotated):
    while True:
        n, m = rnd(rng, 1.1, 4.6), rnd(rng, 1.1, 4.6)
        if abs(n - m) < 0.35: continue
        length = rnd(rng, 1.0, 2.8)
        if not (2.4 <= max(n, m) * length <= 8.5): continue
        a = rnd(rng, 0.8, 1.7) * rng.choice([-1, 1])
        b = rnd(rng, 0.4, 1.5) * rng.choice([-1, 1])
        if abs(abs(a) - abs(b)) < 0.25: continue
        rotation = rnd(rng, 0.2, 1.3) if rotated else 0
        # Keep the whole (rotated) window off both axes.
        half_diag = math.hypot(length * ASPECT / 2, length / 2) if rotated else None
        hx = half_diag if rotated else length * ASPECT / 2
        hy = half_diag if rotated else length / 2
        origin = [-round(hx + rnd(rng, 0.3, 2.5), 2), round(hy + rnd(rng, 0.3, 2.5), 2)]
        f = {'mode': 'plate', 'a': a, 'b': b, 'n': n, 'm': m, 'origin': origin, 'length': length}
        if rotated: f['rotation'] = rotation
        if straight_lines(n, m, origin, hx, hy): continue
        # Hover: flip the dominant weight and bring it down to 40-75 % of the other. Never near zero
        # (a single sin·sin term draws a grid of straight lines) and never near a = ±b.
        ha = None
        for _ in range(20):
            cand = round(-math.copysign(1, a) * abs(b) * rng.uniform(0.4, 0.75), 2)
            if abs(abs(cand) - abs(b)) >= 0.2:
                ha = cand; break
        if ha is None: continue
        f['hover'] = {'a': ha}
        return f


def make_sources(rng):
    while True:
        count = rng.choice([3, 3, 4, 4, 5, 6])
        length = rnd(rng, 1.8, 2.8)
        f = {
            'mode': 'sources', 'sources': count,
            'frequency': rnd(rng, 1.0, 2.5), 'phase': rnd(rng, 0, 0.5), 'elasticity': 1,
            'radius': rnd(rng, 0.3, min(1.1, length / 2.2)),
            'origin': [rnd(rng, -1.3, 1.3), rnd(rng, -0.4, 0.4)], 'length': length,
            'spin': rnd(rng, 0, 2 * math.pi / count),
        }
        if f['radius'] * f['frequency'] < (0.6 if count >= 5 else 0.35): continue
        f['hover'] = {'phase': round(f['phase'] + rnd(rng, 0.35, 0.55), 2), 'spin': round(f['spin'] + rnd(rng, 0.35, 0.65), 2)}
        return f


def make_field(rng):
    while True:
        cols = rng.sample(COLOURS, 3)
        if sum(c in LIGHT for c in cols) <= 1: break
    pos = [[rnd(rng, 30, 70, 1), rnd(rng, 30, 70, 1)]] + [[rnd(rng, 5, 95, 1), rnd(rng, 5, 95, 1)] for _ in range(2)]
    return {'colors': cols, 'positions': pos}


def generate(pid, lo, hi):
    rng = random.Random(int(hashlib.sha256(pid.encode()).hexdigest(), 16))
    for _ in range(200):
        kind = rng.choices(['sources', 'plate', 'rotated'], [0.45, 0.35, 0.2])[0]
        f = make_sources(rng) if kind == 'sources' else make_plate(rng, kind == 'rotated')
        d0, d1 = density(f), density(f, f['hover'])
        if lo <= d0 <= hi and lo * 0.8 <= d1 <= hi * 1.2:
            return f, make_field(rng), d0
    raise SystemExit('no acceptable figure for ' + pid)


if __name__ == '__main__':
    data = json.load(open(PATH))
    # Density band, calibrated on the 18 hand-picked figures (0.24 to 0.51 on this grid), without
    # the two busiest, which read as scribbles at small card sizes.
    lo, hi = 0.23, 0.45
    regen = '--regenerate' in sys.argv
    for p in data['papers']:
        if 'figure' in p and not regen: continue
        p['figure'], p['field'], d = generate(p['id'], lo, hi)
        if '--report' in sys.argv: print(f"{d:.3f} {p['figure']['mode']:8} {p['id'][:50]}")
    json.dump(data, open(PATH, 'w'), indent=2, ensure_ascii=False)