"""Meteor-M2 LRPT dekooder (72 kSym/s QPSK, r=1/2 K=7 Viterbi, CCSDS CADU) puhtas numpy's.
Sisend: satrec.py 250 kHz IQ-wav. Iga etapp kirjutab vahetulemused (npy + SVG/PNG) kausta captures/lrpt/<nimi>/,
et blogis saaks näidata pooleldi dekodeeritud andmeid.

Kasutus:
  python lrpt.py rec.wav [--start s --dur s] [--stage 1..6] [--sym 72000] [--alpha 0.6]
Etapid:
  1 signaal ajas: ribavõimsus 1 s kaupa (kus satelliit üldse kuulda on)
  2 Doppler: kandja jääk + x^4 spektrijoon, sagedusparandus
  3 RRC-filter + sümbolikell (|x|^2 spektrijoon 72 kHz) -> sümbolid, silmadiagramm
  4 kandjafaas (x^4, ploki kaupa) -> konstellatsioon
  5 Viterbi (vektoriseeritud, 8 konfiguratsiooni proovi) -> bitid, sünkrosõna 1ACFFC1D
  6 CADU: derandomiseerimine, RS-deinterleave, VCDU/M-PDU, APID-id, pildiplokid
"""
import argparse, os, re, sys, time, wave
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from svgplot import Fig, constellation
from specgram import write_png

SYNC = 0x1ACFFC1D
G1, G2 = 0x4F, 0x6D            # CCSDS K=7 polünoomid (libfec järjekord, uusim bitt LSB)


def log(*a):
    print(time.strftime("%H:%M:%S"), *a, flush=True)


# ---------------------------------------------------------------- 0 laadimine
def load(path, start=0.0, dur=None):
    with wave.open(path, "rb") as w:
        fs, n = w.getframerate(), w.getnframes()
        s0 = int(start * fs); n1 = n - s0 if dur is None else min(int(dur * fs), n - s0)
        w.setpos(s0)
        d = np.frombuffer(w.readframes(n1), dtype=np.int16).astype(np.float32) / 32768
    return fs, (d[0::2] + 1j * d[1::2]).astype(np.complex64)


# ---------------------------------------------------------------- 1 ribavõimsus ajas
def stage1(x, fs, out):
    n = int(fs); nb = len(x) // n
    t = np.arange(nb) * 1.0
    inb, outb = np.empty(nb), np.empty(nb)
    f = np.fft.fftshift(np.fft.fftfreq(4096, 1 / fs))
    for i in range(nb):
        seg = x[i * n:(i + 1) * n][: (n // 4096) * 4096].reshape(-1, 4096)
        P = np.fft.fftshift(np.abs(np.fft.fft(seg * np.hanning(4096), axis=1)) ** 2, axes=1).mean(0)
        band = (np.abs(f) < 60e3) & (np.abs(f) > 500)
        ref = (np.abs(f) > 90e3)
        inb[i] = 10 * np.log10(P[band].mean()); outb[i] = 10 * np.log10(P[ref].mean())
    snr = inb - outb
    Fig(720, 300, "1. LRPT riba (±60 kHz) võimsus müra suhtes, 1 s kaupa", "aeg salvestise algusest (s)", "SNR (dB)") \
        .axes(0, nb, min(-1, snr.min() - 0.5), snr.max() + 1).line(t, snr).hline(3, "#27ae60", label="3 dB").save(os.path.join(out, "1_ribavoimsus.svg"))
    np.save(os.path.join(out, "1_snr.npy"), snr)
    good = np.where(snr > 3)[0]
    log(f"etapp 1: {nb} s, max SNR {snr.max():.1f} dB kl {snr.argmax()} s; >3 dB {len(good)} s ({good.min() if len(good) else '-'}–{good.max() if len(good) else '-'})")
    return snr


# ---------------------------------------------------------------- 2 Doppler
def stage2(x, fs, out, t0=0.0):
    """Kaks sõltumatut hinnangut 1 s kaupa: (a) jääkkandja tipp ±6 kHz, (b) x^4 joon /4."""
    n = int(fs); nb = len(x) // n
    fa, fb, snrb = np.full(nb, np.nan), np.full(nb, np.nan), np.zeros(nb)
    N = 1 << 18
    f = np.fft.fftshift(np.fft.fftfreq(N, 1 / fs))
    win = np.hanning(N).astype(np.float32)
    for i in range(nb):
        seg = x[i * n:i * n + N] if i * n + N <= len(x) else None
        if seg is None:
            break
        P = np.abs(np.fft.fftshift(np.fft.fft(seg * win))) ** 2
        m = (np.abs(f) < 6e3) & (np.abs(f) > 200)
        k = np.argmax(np.where(m, P, 0)); fa[i] = f[k]
        s4 = (seg ** 4)                     # QPSK -> joon 4*f_off
        P4 = np.abs(np.fft.fftshift(np.fft.fft(s4 * win))) ** 2
        m4 = (np.abs(f) < 24e3)
        k4 = np.argmax(np.where(m4, P4, 0)); fb[i] = f[k4] / 4
        snrb[i] = 10 * np.log10(P4[k4] / np.median(P4[m4]))
    t = t0 + np.arange(nb)
    ok = snrb > 12
    F = Fig(720, 320, "2. Doppler: jääkkandja vs QPSK x⁴ joon", "aeg (s)", "sageduse nihe (Hz)") \
        .axes(t[0], t[-1] + 1, -5000, 5000)
    F.dots(t, fa, "#2980b9", r=2, label="kandja tipp").dots(t[ok], fb[ok], "#c0392b", r=2, label="x⁴/4 (SNR>12 dB)")
    F.save(os.path.join(out, "2_doppler.svg"))
    np.save(os.path.join(out, "2_doppler.npy"), np.stack([t, fa, fb, snrb]))
    log(f"etapp 2: x^4 lukk {ok.sum()}/{nb} s; kandja {np.nanmedian(fa):+.0f} Hz, x^4 {np.nanmedian(fb[ok]) if ok.any() else float('nan'):+.0f} Hz")
    return t, fa, fb, ok


def doppler_model(t, f, ok):
    """Silutud f(t): lukustunud 1 s punktid -> mediaanfilter (5) -> lineaarne interpolatsioon (otstes konstant)."""
    if ok.sum() >= 3:
        tt, ff = t[ok], f[ok]
        fm = np.array([np.median(ff[max(0, i - 2):i + 3]) for i in range(len(ff))])
        return lambda x: np.interp(np.asarray(x, float), tt + 0.5, fm)
    med = np.nanmedian(f[ok]) if ok.any() else 0.0
    return lambda x: np.full_like(np.asarray(x, float), med)


def mix_down(x, fs, fmodel, t0):
    """Korrutab välja ajas muutuva nihke: faas = 2π ∫ f dt (kumulatiivne summa tükiti)."""
    y = np.empty_like(x)
    ch = 1 << 20
    phase = 0.0
    for s in range(0, len(x), ch):
        n = min(ch, len(x) - s)
        tt = t0 + (s + np.arange(n)) / fs
        finst = fmodel(tt)
        ph = phase + 2 * np.pi * np.cumsum(finst) / fs
        y[s:s + n] = x[s:s + n] * np.exp(-1j * ph).astype(np.complex64)
        phase = ph[-1]
    return y


# ---------------------------------------------------------------- 3 RRC + sümbolikell
def rrc(alpha, sps, span=8):
    n = np.arange(-span * sps, span * sps + 1e-6, 1.0)
    t = n / sps
    h = np.zeros_like(t)
    for i, ti in enumerate(t):
        if abs(ti) < 1e-9:
            h[i] = 1 - alpha + 4 * alpha / np.pi
        elif abs(abs(4 * alpha * ti) - 1) < 1e-9:
            h[i] = alpha / np.sqrt(2) * ((1 + 2 / np.pi) * np.sin(np.pi / (4 * alpha)) + (1 - 2 / np.pi) * np.cos(np.pi / (4 * alpha)))
        else:
            h[i] = (np.sin(np.pi * ti * (1 - alpha)) + 4 * alpha * ti * np.cos(np.pi * ti * (1 + alpha))) / (np.pi * ti * (1 - (4 * alpha * ti) ** 2))
    return (h / np.sqrt(np.sum(h ** 2))).astype(np.float32)


def fft_filter(x, h):
    """Overlap-save konvolutsioon, viivitus (len(h)-1)//2 eemaldatud."""
    M = len(h); N = 1 << 17; L = N - M + 1
    H = np.fft.fft(h, N)
    y = np.empty(len(x), dtype=np.complex64)
    pad = np.concatenate([np.zeros(M - 1, np.complex64), x, np.zeros(N, np.complex64)])
    for s in range(0, len(x), L):
        blk = pad[s:s + N]
        if len(blk) < N:
            blk = np.concatenate([blk, np.zeros(N - len(blk), np.complex64)])
        Y = np.fft.ifft(np.fft.fft(blk) * H)[M - 1:]
        n = min(L, len(x) - s)
        y[s:s + n] = Y[:n]
    d = (M - 1) // 2
    return np.concatenate([y[d:], np.zeros(d, np.complex64)])


def symbol_timing(y, fs, sym, out, blk_s=0.1):
    """|y|^2 spektrijoon sümbolisagedusel: (1) täpne sümbolikiirus 10 s aknast, (2) faas ploki kaupa -> kella faas."""
    p = (np.abs(y) ** 2).astype(np.float32)
    p -= p.mean()
    # 1) peen sagedus: DFT ruudustikul sym±4 Hz sammuga 0.05 Hz, 10 s akna peal (keskelt)
    n10 = min(len(p), int(10 * fs)); s0 = (len(p) - n10) // 2
    seg = p[s0:s0 + n10]; tt = np.arange(n10) / fs
    grid = sym + np.arange(-4, 4.001, 0.05)
    # tükiti, et mälu ei lõhkeks
    acc = np.zeros(len(grid), complex)
    for a in range(0, n10, 1 << 16):
        b = min(a + (1 << 16), n10)
        acc += np.exp(-2j * np.pi * np.outer(grid, tt[a:b])) @ seg[a:b]
    fsym = grid[np.argmax(np.abs(acc))]
    line_db = 10 * np.log10(np.abs(acc).max() ** 2 / np.median(np.abs(acc) ** 2))
    # 2) faas plokkides
    nb = int(blk_s * fs); nblk = len(p) // nb
    tb = np.arange(nb) / fs
    e = np.exp(-2j * np.pi * fsym * tb)
    ph = np.empty(nblk); mag = np.empty(nblk)
    for i in range(nblk):
        c = np.dot(p[i * nb:(i + 1) * nb], e) * np.exp(-2j * np.pi * fsym * i * nb / fs)
        ph[i] = np.angle(c); mag[i] = np.abs(c)
    phu = np.unwrap(ph)
    tblk = (np.arange(nblk) + 0.5) * nb / fs
    # kella faas kogu ajas: theta(t) = 2π fsym t - phu(t)  (kus |y|^2 tipp -> sümboli keskkoht)
    Fig(720, 300, f"3b. Sümbolikella faas (|y|² joon {fsym:.2f} Hz), 0,1 s plokid", "aeg (s)", "faas (tsüklit)") \
        .axes(0, tblk[-1], (phu / 2 / np.pi).min() - 0.1, (phu / 2 / np.pi).max() + 0.1).line(tblk, phu / 2 / np.pi).save(os.path.join(out, "3b_kellafaas.svg"))
    log(f"etapp 3: sümbolikiirus {fsym:.2f} Hz (joon {line_db:.1f} dB üle põhja), kella faas triivib {(phu[-1]-phu[0])/2/np.pi:+.2f} tsüklit {tblk[-1]:.0f} s jooksul")
    return fsym, tblk, phu


def sample_symbols(y, fs, fsym, tblk, phu):
    """Sümbolite hetked: theta(t)=2π fsym t + phu(t) (interp.), sümbol kus theta = 2πk + c. Kuupinterpolatsioon (Catmull-Rom)."""
    n = len(y); t = np.arange(n) / fs
    off = np.interp(t, tblk, phu)                 # radiaanides
    # |y|^2 tipp asub sümboli keskel: x^2 komponent ~ cos(2π fsym t + ph) -> maksimum kui 2π fsym t + ph = 2πk
    theta = 2 * np.pi * fsym * t + off
    k0, k1 = np.ceil(theta[0] / 2 / np.pi), np.floor(theta[-1] / 2 / np.pi)
    ks = np.arange(k0, k1 + 1) * 2 * np.pi
    tk = np.interp(ks, theta, t)                  # theta on monotoonne
    pos = tk * fs
    i = np.floor(pos).astype(np.int64); mu = (pos - i).astype(np.float32)
    ok = (i >= 1) & (i + 2 < n); i, mu = i[ok], mu[ok]
    p0, p1, p2, p3 = y[i - 1], y[i], y[i + 1], y[i + 2]
    s = 0.5 * (2 * p1 + (-p0 + p2) * mu + (2 * p0 - 5 * p1 + 4 * p2 - p3) * mu ** 2 + (-p0 + 3 * p1 - 3 * p2 + p3) * mu ** 3)
    return s.astype(np.complex64), tk[ok]


def eye_diagram(y, fs, fsym, tblk, phu, out, nsym=400):
    """Silmadiagramm: 2 sümboli pikkused lõigud, joondatud kella faasi järgi, reaalosa."""
    s0 = len(y) // 2
    t = np.arange(s0, s0 + int(nsym * fs / fsym)) / fs
    theta = 2 * np.pi * fsym * t + np.interp(t, tblk, phu)
    frac = (theta / 2 / np.pi) % 2.0             # 0..2 sümbolit
    seg = y[s0:s0 + len(t)].real
    F = Fig(720, 300, "3a. Silmadiagramm (I-haru, 400 sümbolit, 2 sümboli aken)", "aeg (sümbolit)", "I").axes(0, 2, -np.percentile(np.abs(seg), 99.5) * 1.1, np.percentile(np.abs(seg), 99.5) * 1.1)
    F.dots(frac, seg, "#2c3e50", r=0.8, opacity=0.35)
    F.vline(0.0, "#c0392b", label="sümboli kese"); F.vline(1.0, "#c0392b")
    F.save(os.path.join(out, "3a_silm.svg"))


# ---------------------------------------------------------------- 3/4 OQPSK: x² jooned ±Rs annavad korraga kella JA kandjafaasi
def oqpsk_sync(y, fs, fmodel, t0, sym, fc, out, win_s=0.5, hop_s=0.125):
    """OQPSK/MSK: I² ja Q² on perioodilised (Rs), pooleteise sümboli nihkega -> y² = e^{j2θ}(I²-Q²+2jIQ) sisaldab
    jooni ±Rs juures: arg L+ = 2θ - φ + π, arg L- = 2θ + φ + π. Sellest φ (kella faas) ja θ (kandja faas mod π).
    Nominaalne kell ψ(t)=2π∫Rs(1+f_dop/fc)dt (Doppler mõjutab ka sümbolikiirust). Tagastab I_k, Q_k (ajaline järjekord Q,I)."""
    n = len(y); t = t0 + np.arange(n) / fs
    rs_t = sym * (1 + fmodel(t) / fc)
    psi = 2 * np.pi * np.cumsum(rs_t) / fs
    y2 = y * y
    W, H = int(win_s * fs), int(hop_s * fs)
    nb = (n - W) // H + 1
    N = 1 << 18
    fgrid = np.fft.fftfreq(N, 1 / fs)
    m = np.abs(fgrid) < 80                     # joone nihe 2δ: jääk-kandja δ < ±40 Hz
    win = np.hanning(W).astype(np.float32)
    Lp, Lm, delta, strength = np.empty(nb, complex), np.empty(nb, complex), np.empty(nb), np.empty(nb)
    for i in range(nb):
        a = i * H; seg = y2[a:a + W] * win; e = np.exp(-1j * psi[a:a + W])
        Fp = np.fft.fft(seg * e, N); Fm = np.fft.fft(seg * np.conj(e), N)
        P = np.abs(Fp) ** 2 + np.abs(Fm) ** 2
        k = np.argmax(np.where(m, P, 0))
        ref = np.exp(2j * np.pi * k * (W - 1) / 2 / N)      # faas akna keskele (Hann'i spekter on seal reaalne); k = indeks!
        # tipu parabool-interpolatsioon (δ täpsus ≪ FFT samm, muidu 4θ unwrap ei tööta)
        pm, p0, pp = np.log(P[k - 1] + 1e-30), np.log(P[k] + 1e-30), np.log(P[(k + 1) % N] + 1e-30)
        frac = 0.5 * (pm - pp) / (pm - 2 * p0 + pp) if (pm - 2 * p0 + pp) != 0 else 0.0
        fk = (k + frac) * fs / N
        if fk > fs / 2:
            fk -= fs
        # faas TÄPSEL sagedusel fk (mitte lähimal binil – muidu kuni ±π·Δ viga) ja akna keskele viidatuna
        nc = np.arange(W) - (W - 1) / 2
        ec = np.exp(-2j * np.pi * fk * nc / fs)
        Lp[i], Lm[i], delta[i] = np.dot(seg * e, ec), np.dot(seg * np.conj(e), ec), fk / 2
        strength[i] = 10 * np.log10(P[k] / np.median(P[m]))
    edge = np.mean(np.abs(delta) > 36)
    log(f"   jääk-δ akende kaupa: min {delta.min():+.1f}, mediaan {np.median(delta):+.1f}, max {delta.max():+.1f} Hz; otsinguserval {100*edge:.0f} %; joon min/med {strength.min():.1f}/{np.median(strength):.1f} dB")
    # 2φ = arg L- - arg L+ (mod 2π) -> unwrap; 4θ = arg L+ + arg L- (mod 2π) -> unwrap ennustusega (δ teada)
    D = np.angle(Lm) - np.angle(Lp)
    phi = np.unwrap(D) / 2
    S = np.angle(Lp) + np.angle(Lm)
    four = np.empty(nb); four[0] = S[0]
    for i in range(1, nb):
        pred = four[i - 1] + 4 * 2 * np.pi * delta[i - 1] * H / fs
        four[i] = pred + ((S[i] - pred + np.pi) % (2 * np.pi) - np.pi)
    theta = four / 4                                                    # 4θ = arg L+ + arg L- ; mod π/2 (kvadrant jääb lahtiseks)
    tc = np.arange(nb) * H + (W - 1) / 2                                # faasid viitavad akna keskele
    # Jämedast jälgijast kasutatakse edasi AINULT sagedust (δ akna kaupa, interpoleeritud ja integreeritud): akendevaheline
    # faasi unwrap libises aeg-ajalt 90°/pool sümbolit ja rikkus bittide tähenduse. Absoluutne faas ja kell tulevad
    # allpool peenjälgijast plokk-plokilt. φ/θ jäävad ainult graafikuteks.
    phi_s = np.zeros(n)
    # δ on akna kaupa ±1–2 Hz müraga; integreerituna annaks see 0,1 s plokkides ±40–70° faasihüppeid -> silu (mediaan 9 + keskmine 9 ≈ 2 s)
    dm = np.array([np.median(delta[max(0, i - 4):i + 5]) for i in range(nb)])
    ds = np.convolve(np.pad(dm, 4, mode="edge"), np.ones(9) / 9, "valid")
    th_s = 2 * np.pi * np.cumsum(np.interp(np.arange(n), tc, ds)) / fs
    # sämplihetked: Q-kese ψ-φ = 2πk, I-kese ψ-φ = π+2πk
    _ps = float(os.environ.get("LRPT_PHISIGN", "-1")); _ts = float(os.environ.get("LRPT_THSIGN", "1"))
    th_s = th_s * _ts
    u = psi + _ps * phi_s
    k0, k1 = np.ceil(u[2] / 2 / np.pi), np.floor(u[-3] / 2 / np.pi) - 1
    ks = np.arange(k0, k1 + 1)
    def interp_at(uk):
        lo = max(0, np.searchsorted(u, uk[0]) - 8); hi = min(n, np.searchsorted(u, uk[-1]) + 8)   # ainult vajalik lõik (kiirus)
        pos = np.interp(uk, u[lo:hi], np.arange(lo, hi))
        i = np.floor(pos).astype(np.int64); mu = (pos - i).astype(np.float32)
        p0, p1, p2, p3 = y[i - 1], y[i], y[i + 1], y[i + 2]
        v = 0.5 * (2 * p1 + (-p0 + p2) * mu + (2 * p0 - 5 * p1 + 4 * p2 - p3) * mu ** 2 + (-p0 + 3 * p1 - 3 * p2 + p3) * mu ** 3)
        th = th_s[i] + (th_s[i + 1] - th_s[i]) * mu           # lineaarne, ilma np.arange(n) massiivita (see oli 100× aeglasem)
        return v * np.exp(-1j * th), pos
    # diagnostika: bimodaalsus sämplifaasi funktsioonina (õige kell -> Re tipp ühel, Im tipp vastasfaasil)
    bim = lambda v: float(np.mean(np.abs(v)) ** 2 / np.mean(v ** 2))
    sub = ks[::max(1, len(ks) // 100000)]
    scan = []
    for frac in np.arange(0, 1, 0.125):
        v, _ = interp_at(sub * 2 * np.pi + frac * 2 * np.pi)
        scan.append((frac, bim(v.real), bim(v.imag)))
    log("   sämplifaas -> bimod(Re), bimod(Im): " + "  ".join(f"{f:.3f}:{a:.2f}/{b:.2f}" for f, a, b in scan))
    v, _ = interp_at(sub * 2 * np.pi + np.pi)
    rot = [(d, bim((v * np.exp(-1j * np.deg2rad(d))).real)) for d in range(0, 90, 10)]
    log("   I-hetkel lisapööre -> bimod(Re): " + "  ".join(f"{d}°:{b:.2f}" for d, b in rot))
    # kumb komponent on kummal hetkel 'oma': φ on määratud mod π ja θ mod π/2 -> otsustame andmete järgi
    s0, s1 = scan[0], scan[4]                      # frac 0 ja 0.5
    if s0[1] + s1[2] >= s0[2] + s1[1]:
        ui, uq, order = ks * 2 * np.pi, ks * 2 * np.pi + np.pi, "I,Q"
    else:
        uq, ui, order = ks * 2 * np.pi, ks * 2 * np.pi + np.pi, "Q,I"
    log(f"   ajaline järjekord: {order}")
    # --- peenhäälestus (otsuse-juhitud): iga 0,1 s ploki kohta otsi kella nihe (±0,2 sümbolit) ja lisapööre (±40°),
    # mis annab kõige kahetipulisema I ja Q jaotuse. Jämedad y²-hinnangud 0,5 s akendest jätavad ~0,84; lokaalselt on 0,96 võimalik.
    # Jälgimine plokk-plokilt: kell = 9-punktiline otsing eelmise ümber (±0,1 sümb), pööre = otsene hinnang
    # ε = arg(Σvi² − Σvq²)/2 (I-hetkel on E[v²] ∝ +e^{2jε}, Q-hetkel ∝ −e^{2jε}), kumulatiivselt eelmise peale.
    blk = int(0.1 * sym); nblk = max(1, len(ks) // blk)
    best_d, best_r, best_q = np.zeros(nblk), np.zeros(nblk), np.zeros(nblk)
    # algpunkt: täisotsing esimeses tugevas plokis (d ∈ [−0,5; 0,5), r ∈ [−90°; 90°)), et jälgija ei alustaks valest orust
    b0 = int(np.argmax([np.mean(np.abs(interp_at(ui[b * blk:(b + 1) * blk])[0])) for b in range(0, nblk, max(1, nblk // 40))]) * max(1, nblk // 40))
    sl0 = slice(b0 * blk, (b0 + 1) * blk); top0 = (-1, 0.0, 0.0)
    for d in np.arange(-0.5, 0.5, 0.05):
        vi, _ = interp_at(ui[sl0] + 2 * np.pi * d); vq, _ = interp_at(uq[sl0] + 2 * np.pi * d)
        for r in np.deg2rad(np.arange(-90, 90, 7.5)):
            w = np.exp(-1j * r); m = bim((vi * w).real) + bim((vq * w).imag)
            if m > top0[0]:
                top0 = (m, d, r)
    d_prev, r_prev = top0[1], top0[2]
    log(f"   algpunkt plokis {b0} (kl {t0 + b0*blk/sym:.0f} s): kella nihe {d_prev:+.2f} sümb, pööre {np.rad2deg(r_prev):+.0f}°, kvaliteet {top0[0]/2:.3f}")
    # Iga plokk ABSOLUUTSELT jämeda hinnangu suhtes (mitte kumulatiivselt – kumulatiivne jälgija libises I/Q-vahetuse orgu):
    # kell d ∈ [−0,25; 0,25], pööre ε otse hinnangust, piiratud ±45°. Jämeda jälgija harv 90°-libisemine jääb sisse
    # (sünkrojada katkeb seal, kaadrivõrk alustab uut jada).
    # Sildistuse järjepidevus: (d, r) ≡ (d + 0,5k, r + 90°k) on sama lahendus vahetatud I/Q rollidega. Plokis leitakse
    # parim lahendus absoluutselt (d ∈ [−0,5; 0,5), ε mod 180°), siis valitakse ekvivalentidest see, mis on eelmisele
    # plokile lähim – nii jääb bittide tähendus samaks ka siis, kui jäme jälgija libiseb poole sümboli / 90° võrra.
    d_prev, r_prev = 0.0, 0.0
    for b in range(nblk):
        sl = slice(b * blk, (b + 1) * blk)
        top = (-1, 0.0, 0.0, None, None)
        # kella mõõdik: |Σvi² − Σvq²| on suurim, kui I-hetkel on Q üleminekul ja vastupidi (bimodaalsus üksi on
        # laiade impulsside puhul lame – I ja Q on peaaegu igal hetkel ±1 – ja ei erista 90° pööret)
        grid = np.arange(-0.5, 0.5, 0.05); mm = np.zeros(len(grid))
        for gi, d in enumerate(grid):
            vi, _ = interp_at(ui[sl] + 2 * np.pi * d); vq, _ = interp_at(uq[sl] + 2 * np.pi * d)
            D = np.sum(vi ** 2) - np.sum(vq ** 2)
            mm[gi] = np.abs(D) / (np.sum(np.abs(vi) ** 2) + np.sum(np.abs(vq) ** 2))
        gi = int(np.argmax(mm)); a_, b_, c_ = mm[gi - 1], mm[gi], mm[(gi + 1) % len(grid)]
        d = grid[gi] + (0.05 * 0.5 * (a_ - c_) / (a_ - 2 * b_ + c_) if (a_ - 2 * b_ + c_) != 0 else 0)   # parabool: peen kell
        vi, _ = interp_at(ui[sl] + 2 * np.pi * d); vq, _ = interp_at(uq[sl] + 2 * np.pi * d)
        D = np.sum(vi ** 2) - np.sum(vq ** 2); eps = np.angle(D) / 2
        wi = vi * np.exp(-1j * eps); wq = vq * np.exp(-1j * eps)
        m = bim(wi.real) + bim(wq.imag)
        # ε on mod 180° (polaarsus ei loe pärast diff-dekodeerimist) -> ekvivalendid (d + 0,5k, ε + 90°k + 180°m)
        kb = int(round((d_prev - d) / 0.5)); mb = int(round((r_prev - eps - np.pi / 2 * kb) / np.pi))
        cands = [(d + 0.5 * k, eps + np.pi / 2 * k + np.pi * mm_) for k in range(kb - 2, kb + 3) for mm_ in range(mb - 2, mb + 3)]
        d_b, r_b = min(cands, key=lambda c: abs(c[0] - d_prev) + abs(c[1] - r_prev) / np.pi)
        best_q[b] = m / 2; best_d[b] = d_b; best_r[b] = r_b
        d_prev, r_prev = d_b, r_b
    with open(os.path.join(out, "4d_peenhaalestus.csv"), "w", encoding="utf-8") as fcsv:
        fcsv.write("plokk,t_s,kell_symb,poore_deg,kvaliteet\n")
        for b in range(nblk):
            fcsv.write(f"{b},{t0 + (b + 0.5) * blk / sym:.2f},{best_d[b]:+.3f},{np.rad2deg(best_r[b]):+.1f},{best_q[b]:.3f}\n")
    # interpoleeri igale sümbolile (plokkide keskpunktid)
    kc = (np.arange(nblk) + 0.5) * blk
    dk = np.interp(np.arange(len(ks)), kc, best_d); rk = np.interp(np.arange(len(ks)), kc, best_r)
    zi, posi = interp_at(ui + 2 * np.pi * dk); zq, posq = interp_at(uq + 2 * np.pi * dk)
    zi = zi * np.exp(-1j * rk); zq = zq * np.exp(-1j * rk)
    log(f"   peenhäälestus: kella nihe mediaan {np.median(best_d):+.3f} sümb (min {best_d.min():+.2f} max {best_d.max():+.2f}), "
        f"pööre lõpus {np.rad2deg(best_r[-1]):+.0f}° (min {np.rad2deg(best_r.min()):+.0f} max {np.rad2deg(best_r.max()):+.0f}), kvaliteet mediaan {np.median(best_q):.3f}")
    tq = t0 + kc / sym
    F = Fig(720, 300, "4d. Peenhäälestus 0,1 s plokkides: kella nihe, lisapööre ja luku kvaliteet", "aeg (s)", "")
    lo_, hi_ = min(-1, best_d.min() * 2, best_r.min() / np.pi), max(1, best_d.max() * 2, best_r.max() / np.pi)
    F.axes(tq[0], tq[-1], lo_, hi_).line(tq, best_d * 2, "#c0392b", label="kella nihe ×2 (sümbolit)")
    F.line(tq, best_r / np.pi, "#2980b9", 1, label="lisapööre / 180°").line(tq, best_q * 2 - 1, "#27ae60", 1, label="kvaliteet (0,64…1 → 0,3…1)")
    F.save(os.path.join(out, "4d_peenhaalestus.svg"))
    # graafikud
    tb = t0 + tc / fs
    F = Fig(720, 300, "3. OQPSK: y² jooned ±72 kHz – tugevus ja kella faas (0,5 s aknad)", "aeg (s)", "")
    F.axes(tb[0], tb[-1], -1, max(strength.max() + 1, 10)).line(tb, strength, "#27ae60", label="joone tugevus (dB üle müra)")
    F.line(tb, (phi / 2 / np.pi - phi[0] / 2 / np.pi), "#c0392b", label="kella faas φ (tsüklit, suhteline)")
    F.save(os.path.join(out, "3_oqpsk_kell.svg"))
    F = Fig(720, 300, "4. Kandja jääkfaas θ (y² joonte summast), unwrap", "aeg (s)", "θ (rad)")
    F.axes(tb[0], tb[-1], theta.min() - 0.5, theta.max() + 0.5).line(tb, theta, "#2980b9").save(os.path.join(out, "4_kandjafaas.svg"))
    resid = np.polyfit(tb, theta, 1)[0] / 2 / np.pi
    I, Q = zi.real, zq.imag
    log(f"etapp 3/4 OQPSK: joon mediaan {np.median(strength):.1f} dB, kella triiv {(phi[-1]-phi[0])/2/np.pi:+.2f} tsüklit, "
        f"jääk kandja {resid:+.2f} Hz; bimodaalsus I {bim(I):.3f} Q {bim(Q):.3f} (Gauss 0,64, ideaal 1,0); {len(ks)} sümbolit")
    # kõrvalsaadus: 'valed' harud (Q-hetkel I, I-hetkel Q) peaksid olema ~0 / Gauss
    log(f"   kontroll: I Q-hetkel bimod {bim(zq.real):.3f}, Q I-hetkel {bim(zi.imag):.3f}")
    soft = (np.stack([I, Q], 1) if order == "I,Q" else np.stack([Q, I], 1)).reshape(-1).astype(np.float32)
    np.save(os.path.join(out, "3_oqpsk_soft.npy"), soft)
    constellation(I + 1j * Q, os.path.join(out, "4c_konst_oqpsk.svg"), "4c. OQPSK sümbolid (I omal hetkel, Q pool sümbolit hiljem)")
    constellation(zi, os.path.join(out, "4a_konst_I_hetkel.svg"), "4a. Sämplid I-hetkel (Q on üleminekul)")
    return soft, strength, tb


# ---------------------------------------------------------------- 4 kandjafaas
def carrier_phase(s, out, blk=16384, hop=8192, sym=72000.0):
    """Kandja jääksagedus+faas: z^4 FFT 16384-sümboli akendes (50 % ülekate). Iga aken annab f (=tipp/4) ja
    faasi akna alguses (mod π/2); faas jätkatakse akna kaupa ennustuse abil (unwrap) ja interpoleeritakse."""
    n = len(s); nb = (n - blk) // hop + 1
    N = 4 * blk
    freqs = np.fft.fftfreq(N)                      # tsüklit/sümbol
    win = np.hanning(blk).astype(np.float32)
    f4 = np.empty(nb); ph = np.empty(nb); q = np.empty(nb)
    for i in range(nb):
        seg = s[i * hop:i * hop + blk]
        X = np.fft.fft((seg ** 4) * win, N)
        m = np.abs(freqs) < 0.02                   # ±0.02*72k/4 = ±360 Hz kandjanihe
        P = np.abs(X) ** 2; P[~m] = 0
        k = np.argmax(P)
        f4[i] = freqs[k]; ph[i] = np.angle(X[k]); q[i] = 10 * np.log10(P[k] / np.median(np.abs(X[m]) ** 2))
    fcar = f4 / 4                                  # tsüklit/sümbol
    # sile sagedus (mediaanfilter 5 akent), siis faasi jätkamine
    fs_ = np.array([np.median(fcar[max(0, i - 2):i + 3]) for i in range(nb)])
    theta = np.empty(nb)
    theta[0] = ph[0] / 4
    for i in range(1, nb):
        pred = theta[i - 1] + 2 * np.pi * fs_[i - 1] * hop
        meas = ph[i] / 4
        d = (meas - pred + np.pi / 4) % (np.pi / 2) - np.pi / 4
        theta[i] = pred + d
    # akna alguse faasid -> igale sümbolile (hanning-aken: faas viitab akna keskele? FFT viitab n=0 = akna algus)
    idx = np.arange(nb) * hop
    corr = np.interp(np.arange(n), idx, theta)
    z = s * np.exp(-1j * corr).astype(np.complex64)
    tb = idx / sym
    F = Fig(720, 300, "4b. Kandja jääk: sagedus (z⁴ tipp/4) ja spektrijoone kõrgus akna kaupa", "aeg (s)", "Hz")
    F.axes(0, tb[-1], min(-20, (fcar * sym).min() - 5), max(20, (fcar * sym).max() + 5)).line(tb, fcar * sym, "#c0392b", label="jääksagedus (Hz)")
    F.line(tb, q, "#27ae60", 1, label="z⁴ joon (dB üle põhja)")
    F.save(os.path.join(out, "4b_kandjafaas.svg"))
    lock = q
    log(f"etapp 4: jääksagedus mediaan {np.median(fcar)*sym:+.2f} Hz (min {fcar.min()*sym:+.1f}, max {fcar.max()*sym:+.1f}), z⁴ joon mediaan {np.median(q):.1f} dB")
    return z, lock


# ---------------------------------------------------------------- 5 Viterbi
def _parity(v):
    v = np.asarray(v); r = np.zeros_like(v)
    for b in range(8):
        r ^= (v >> b) & 1
    return r


def trellis(g1=G1, g2=G2):
    s = np.arange(64)
    nxt, o1, o2 = np.zeros((64, 2), int), np.zeros((64, 2)), np.zeros((64, 2))
    for b in (0, 1):
        enc = ((s << 1) | b) & 0x7F
        nxt[:, b] = enc & 0x3F
        o1[:, b] = 1 - 2 * _parity(enc & g1)       # bitt 0 -> +1, bitt 1 -> -1
        o2[:, b] = 1 - 2 * _parity(enc & g2)
    # eelkäijad iga järgmise oleku jaoks
    pred = np.zeros((64, 2), int); pb = np.zeros((64, 2), int)
    for n in range(64):
        ps = [(p, b) for p in range(64) for b in (0, 1) if nxt[p, b] == n]
        pred[n] = [ps[0][0], ps[1][0]]; pb[n] = [ps[0][1], ps[1][1]]
    po1 = o1[pred, pb]; po2 = o2[pred, pb]        # (64,2) väljundid iga eelkäija-haru jaoks
    return pred, po1, po2


def viterbi(r1, r2, L=8192, O=96, g2_inv=False):
    """r1,r2: pehmed sümbolid (float, ±1 skaala) paaris (c1,c2). Tükeldab L-pikkusteks (ülekattega O) ja
    dekodeerib kõik tükid korraga numpy-massiividena (N tükki x 64 olekut)."""
    pred, po1, po2 = trellis()
    if g2_inv:
        po2 = -po2
    T = len(r1)
    nchunk = int(np.ceil(T / L))
    # tükid: [k*L - O, (k+1)*L + O)
    idx = (np.arange(nchunk)[:, None] * L - O + np.arange(L + 2 * O)[None, :])
    valid = (idx >= 0) & (idx < T)
    R1 = np.where(valid, r1[np.clip(idx, 0, T - 1)], 0).astype(np.float32)
    R2 = np.where(valid, r2[np.clip(idx, 0, T - 1)], 0).astype(np.float32)
    N, TT = R1.shape
    metric = np.zeros((N, 64), np.float32)
    dec = np.zeros((TT, N, 64), np.bool_)
    p0, p1 = pred[:, 0], pred[:, 1]
    a0, b0 = po1[:, 0].astype(np.float32), po2[:, 0].astype(np.float32)
    a1, b1 = po1[:, 1].astype(np.float32), po2[:, 1].astype(np.float32)
    for t in range(TT):
        x1, x2 = R1[:, t:t + 1], R2[:, t:t + 1]
        c0 = metric[:, p0] + x1 * a0 + x2 * b0
        c1 = metric[:, p1] + x1 * a1 + x2 * b1
        d = c1 > c0
        dec[t] = d
        metric = np.where(d, c1, c0)
        if t % 64 == 0:
            metric -= metric.max(1, keepdims=True)
    # tagasikäik
    st = metric.argmax(1)
    bits = np.zeros((TT, N), np.uint8)
    ar = np.arange(N)
    for t in range(TT - 1, -1, -1):
        bits[t] = st & 1
        d = dec[t, ar, st]
        st = np.where(d, p1[st], p0[st])
    b = bits[O:O + L].T.reshape(-1)[:T]
    return b


def reencode_agreement(bits, r1, r2, g2_inv=False):
    """Kodeerib Viterbi väljundi uuesti ja võrdleb kõvade otsustega: kui vool ON selle koodiga kodeeritud, on
    kokkulangevus selgelt üle juhusliku (~78 %), sõltumata sünkrosõnast/randomiseerimisest."""
    enc = np.zeros(len(bits) + 6, np.int64)
    for k in range(7):
        enc[k:k + len(bits)] |= bits.astype(np.int64) << k           # enc[i] = bitid i-6..i, uusim LSB
    enc = enc[: len(bits)]
    c1 = _parity(enc & G1); c2 = _parity(enc & G2)
    if g2_inv:
        c2 ^= 1
    h1 = (r1 < 0).astype(int); h2 = (r2 < 0).astype(int)
    return 0.5 * (np.mean(c1 == h1) + np.mean(c2 == h2))


def bits_to_bytes(b):
    n = len(b) // 8 * 8
    return np.packbits(b[:n].reshape(-1, 8), axis=1).reshape(-1)


def find_sync(bits):
    """Korrelatsioon 32-bitise sünkrosõnaga: tagastab (positsioonid, polaarsus) kus ≥30/32 bitti klapib."""
    pat = np.array([(SYNC >> (31 - i)) & 1 for i in range(32)])
    p = 1 - 2 * pat.astype(np.float32); x = 1 - 2 * bits.astype(np.float32)
    c = np.correlate(x, p, mode="valid")
    pos = np.where(np.abs(c) >= 28)[0]
    return pos, c[pos]


def _pairs(soft, offset, flip):
    s = soft[offset:]
    s = s[: len(s) // 2 * 2].reshape(-1, 2).copy()
    if flip:
        s[:, 1] *= -1
    return s[:, 0], s[:, 1]


def stage5(soft, out, test_s=2.0, test_at=None):
    """soft: pehmed kodeeritud bitid ajalises järjekorras (Q0,I0,Q1,I1,... OQPSK puhul). Proovib 8 konfiguratsiooni
    (paari algus 0/1, teise biti märk, G2 inversioon) 2 s lõigul, valib sünkrosõnade arvu järgi, dekodeerib kogu voo."""
    n = int(test_s * 144000)
    s0 = len(soft) // 2 if test_at is None else int(test_at * 144000)
    s0 -= s0 % 2                                   # paarsus peab olema sama mis terve voo alguses (muidu vale offset)
    seg = soft[s0:s0 + n]
    seg = seg / np.sqrt(np.mean(seg ** 2))
    best = None
    log(f"etapp 5: konfiguratsioonide proov 2 s lõigul (kl {s0/144000:.0f} s, 144k kodeeritud bitti):")
    for offset in (0, 1):
        for flip in (0, 1):
            for g2i in (0, 1):
                r1, r2 = _pairs(seg, offset, flip)
                b = viterbi(r1, r2, g2_inv=bool(g2i))
                pos, c = find_sync(b)
                per = int(np.sum(np.diff(pos) == 8192)) if len(pos) > 1 else 0
                agree = reencode_agreement(b, r1, r2, bool(g2i))
                log(f"   offset={offset} flip={flip} g2inv={g2i}: sync {len(pos)} (perioodilisi {per}), polaarsus {'+' if (c > 0).sum() >= (c < 0).sum() else '-'}, koodi sobivus {100*agree:.1f} %")
                if best is None or (per, len(pos)) > best[0]:
                    best = ((per, len(pos)), (offset, flip, g2i), (c > 0).sum() >= (c < 0).sum())
    (per, cnt), cfg, positive = best
    log(f"   valitud {cfg}, polaarsus {'+' if positive else '- (bitid inverteeritud)'}")
    offset, flip, g2i = cfg
    ss = soft / np.sqrt(np.mean(soft ** 2))
    r1, r2 = _pairs(ss, offset, flip)
    log(f"   Viterbi kogu voole: {len(r1)} sümbolit ...")
    bits = viterbi(r1, r2, g2_inv=bool(g2i))
    if not positive:
        bits ^= 1
    np.save(os.path.join(out, "5_bits.npy"), bits)
    pos, c = find_sync(bits)
    good = pos[c > 0]
    # Teine paarsus (I/Q rollid vahetatud): kus peenjälgija on 90° võrra libisenud, on õige hoopis see. Mõlemad
    # dekodeeritakse, kaadrid liidetakse 6. etapis (dubleerivad kaadrid VCDU loenduri järgi välja).
    r1b, r2b = _pairs(ss, 1 - offset, flip)
    bits_b = viterbi(r1b, r2b, g2_inv=bool(g2i))
    pos_b, c_b = find_sync(bits_b)
    if (c_b < 0).sum() > (c_b > 0).sum():
        bits_b ^= 1; c_b = -c_b
    good_b = pos_b[c_b > 0]
    np.save(os.path.join(out, "5_bits_b.npy"), bits_b)
    log(f"   teine paarsus (offset {1-offset}): sünkrosõnu {len(good_b)}")
    # aja-telg: mõlema voo sünkrod
    good_all = np.concatenate([good, good_b + 1])          # +1 bitt = pool sümbolit, ei loe
    # kaadrite ajajaotus
    nb = int(np.ceil(len(bits) / 72000)) if len(bits) else 1
    hist, _ = np.histogram(good / 72000.0, bins=nb, range=(0, nb))
    hist_b, _ = np.histogram(good_b / 72000.0, bins=nb, range=(0, nb))
    F = Fig(720, 300, "5. Leitud CADU sünkrosõnu (1ACFFC1D) sekundis; teoreetiline max 8,8", "aeg (s)", "kaadreid/s").axes(0, nb, 0, 10)
    F.line(np.arange(nb) + 0.5, hist, "#8e44ad", label="paarsus A").line(np.arange(nb) + 0.5, hist_b, "#e67e22", 1, label="paarsus B (I/Q vahetus)")
    F.hline(72000 / 8192, "#27ae60", label="8,79/s").save(os.path.join(out, "5_kaadrid.svg"))
    log(f"   sünkrosõnu {len(good)} ({len(good)/max(nb,1):.2f}/s), perioodilisi {int(np.sum(np.diff(good) == 8192))}; kokku kahe paarsusega {len(good_all)}")
    return [(bits, good), (bits_b, good_b)], cfg


# ---------------------------------------------------------------- 6 CADU
def pn_sequence(n=1020):
    """CCSDS pseudojuhuslik jada x^8+x^7+x^5+x^3+1, alg 0xFF, baitide kaupa."""
    reg = 0xFF; out = np.zeros(n, np.uint8)
    for i in range(n):
        b = 0
        for _ in range(8):
            bit = reg & 1
            nb_ = ((reg >> 7) ^ (reg >> 5) ^ (reg >> 3) ^ (reg >> 0)) & 1
            b = (b << 1) | bit
            reg = ((reg >> 1) | (nb_ << 7)) & 0xFF
        out[i] = b
    return out


# --- Reed-Solomon (255,223) CCSDS, duaalbaas -> konventsionaalne teisendus
def _gf_tables(prim=0x187):
    exp = np.zeros(512, np.int32); logt = np.zeros(256, np.int32)
    x = 1
    for i in range(255):
        exp[i] = x; logt[x] = i
        x <<= 1
        if x & 0x100:
            x ^= prim
    exp[255:510] = exp[:255]
    return exp, logt


EXP, LOG = _gf_tables()


def gf_mul(a, b):
    if a == 0 or b == 0:
        return 0
    return int(EXP[LOG[a] + LOG[b]])


def _trace(z):
    s, p = 0, z
    for _ in range(8):
        s ^= p; p = gf_mul(p, p)
    return s


def _dual_tables():
    """CCSDS RS duaalbaas (Berlekamp): z_i = Tr(z·β^i), β = α^117; bitt i=0 on MSB. Lineaarne -> tabel 256 baiti."""
    basis = []
    for j in range(8):                           # dual(α^j)
        z = EXP[j]
        bits = [_trace(gf_mul(z, EXP[(117 * i) % 255])) for i in range(8)]
        basis.append(sum(b << (7 - i) for i, b in enumerate(bits)))
    tal = np.zeros(256, np.uint8)
    for v in range(256):
        acc = 0
        for j in range(8):
            if (v >> j) & 1:
                acc ^= basis[j]
        tal[v] = acc
    tal1 = np.zeros(256, np.uint8); tal1[tal] = np.arange(256, dtype=np.uint8)
    return tal, tal1


TALTAB, TAL1TAB = _dual_tables()          # konventsionaalne -> duaal, duaal -> konventsionaalne

RS_FCR, RS_PRIM_STEP, RS_NROOTS = 112, 11, 32


def rs_decode(block):
    """RS(255,223), juured α^(11*(112..143)), konventsionaalses baasis. Tagastab (parandatud block, parandusi | -1 kui ei suutnud)."""
    n = 255
    # sündroomid S_i = r(α^(11*(112+i)))
    syn = []
    for i in range(RS_NROOTS):
        root = (RS_PRIM_STEP * (RS_FCR + i)) % 255
        s = 0
        for c in block:
            s = gf_mul(s, EXP[root]) ^ int(c)
        syn.append(s)
    if not any(syn):
        return block, 0
    # Berlekamp-Massey
    C = [1] + [0] * RS_NROOTS; B = [1] + [0] * RS_NROOTS
    L, m, b = 0, 1, 1
    for nn in range(RS_NROOTS):
        d = syn[nn]
        for i in range(1, L + 1):
            d ^= gf_mul(C[i], syn[nn - i])
        if d == 0:
            m += 1
        elif 2 * L <= nn:
            T = C[:]
            coef = gf_mul(d, EXP[255 - LOG[b]] if b else 0)
            for i in range(RS_NROOTS + 1 - m):
                C[i + m] ^= gf_mul(coef, B[i])
            L = nn + 1 - L; B = T; b = d; m = 1
        else:
            coef = gf_mul(d, EXP[255 - LOG[b]] if b else 0)
            for i in range(RS_NROOTS + 1 - m):
                C[i + m] ^= gf_mul(coef, B[i])
            m += 1
    if L > RS_NROOTS // 2:
        return block, -1
    # Chien: juured lambda(x); vea asukoht j kui lambda(α^(-11 j)) = 0
    err_pos = []
    for j in range(n):
        xinv = EXP[(255 - (RS_PRIM_STEP * j) % 255) % 255]
        v = 0; xp = 1
        for i in range(L + 1):
            v ^= gf_mul(C[i], xp); xp = gf_mul(xp, xinv)
        if v == 0:
            err_pos.append(j)
    if len(err_pos) != L:
        return block, -1
    # Forney: omega = S(x) * C(x) mod x^32
    S = syn
    omega = [0] * RS_NROOTS
    for i in range(RS_NROOTS):
        v = 0
        for k in range(min(i, L) + 1):
            v ^= gf_mul(C[k], S[i - k])
        omega[i] = v
    # lambda'
    Cd = [C[i] if i % 2 == 1 else 0 for i in range(L + 1)]
    out = np.array(block, np.int32)
    for j in err_pos:
        xj = EXP[(RS_PRIM_STEP * j) % 255]; xinv = EXP[(255 - (RS_PRIM_STEP * j) % 255) % 255]
        num = 0; xp = 1
        for i in range(RS_NROOTS):
            num ^= gf_mul(omega[i], xp); xp = gf_mul(xp, xinv)
        den = 0; xp = 1
        for i in range(1, L + 1):
            if i % 2 == 1:
                den ^= gf_mul(C[i], xp)
            xp = gf_mul(xp, xinv)
        # ühtlustus fcr jaoks: e_j = X_j^(1-fcr) * omega(X_j^-1) / lambda'(X_j^-1)
        if den == 0:
            return block, -1
        xf = EXP[(LOG[xj] * (1 - RS_FCR)) % 255]
        e = gf_mul(gf_mul(num, EXP[255 - LOG[den]]), xf)
        out[254 - j] ^= e                        # Horner: block[k] on aste 254-k
    return out.astype(np.uint8), L


def frame_grid(syncpos, nbits, extend=2):
    """Kaadrilukk: sünkroleiud rühmitatakse jadadeks, kus vahe on täpselt k*8192; iga jada sees võetakse KÕIK
    kaadrid (ka need, mille sünkrosõnas on >2 viga), pluss `extend` kaadrit kummalegi poole."""
    pos = np.sort(np.asarray(syncpos))
    runs = []
    for p in pos:
        if runs and (p - runs[-1][-1]) % 8192 == 0 and p - runs[-1][-1] <= 8192 * 40:
            runs[-1].append(p)
        else:
            runs.append([p])
    starts = []
    for r in runs:
        if len(r) < 2:
            continue
        a, b = r[0] - extend * 8192, r[-1] + extend * 8192
        starts.extend(range(max(a, 0), b + 1, 8192))
    starts = sorted(set(s for s in starts if s + 8192 <= nbits))
    return starts, len([r for r in runs if len(r) >= 2])


def stage6(streams, out, do_rs=True, dual=False):
    """streams: [(bits, syncpos), ...] – mitu paarsust; kaadrid liidetakse, dubleerivad (sama VCID+loendur) välja."""
    pn = pn_sequence(1020)
    frames = []; nsync = 0; nruns = 0
    for bits, syncpos in streams:
        starts, nr = frame_grid(syncpos, len(bits)); nsync += len(syncpos); nruns += nr
        for p in starts:
            fb = bits_to_bytes(bits[p:p + 8192])
            frames.append((p, fb[4:] ^ pn))
    frames.sort(key=lambda f: f[0])
    seen = set(); uniq = []
    for p, data in frames:
        key = (int(data[1]) & 0x3F, (int(data[2]) << 16) | (int(data[3]) << 8) | int(data[4]))   # NB enne RS-i, aga päised on enamasti terved
        if key in seen:
            continue
        seen.add(key); uniq.append((p, data))
    log(f"etapp 6: {nsync} sünkroleidu ({len(streams)} paarsust) -> {nruns} lukustunud jada -> {len(frames)} kaadrit, unikaalseid {len(uniq)}")
    frames = uniq
    if not frames:
        return []
    vcdus = []; rs_ok = rs_fail = rs_corr = 0
    for k, (p, data) in enumerate(frames):
        # deinterleave 4 RS-koodisõna (bait j -> koodisõna j%4)
        blocks = data.reshape(255, 4).T          # (4,255)
        ok = True; corrected = 0
        outb = np.zeros((4, 223), np.uint8)
        for i in range(4):
            cw = TAL1TAB[blocks[i]] if dual else blocks[i]   # Meteor: baidid ON juba konventsionaalses baasis (mõõdetud: 156/160 korras ilma teisenduseta, 0/160 duaaliga)
            if do_rs:
                fixed, ne = rs_decode(cw)
                if ne < 0:
                    ok = False
                else:
                    corrected += ne
                outb[i] = (TALTAB[np.asarray(fixed)[:223]] if dual else np.asarray(fixed)[:223]).astype(np.uint8)
            else:
                outb[i] = blocks[i][:223]
        if ok:
            rs_ok += 1; rs_corr += corrected
        else:
            rs_fail += 1
        vc = outb.T.reshape(-1)                  # tagasi baitide järjekorda: 892 baiti
        vcdus.append((p, ok, corrected, vc))
    log(f"   RS: korras {rs_ok}, parandusi kokku {rs_corr}, ebaõnnestus {rs_fail}")
    # VCDU päis + loenduri järjepidevus
    rows = []
    for p, ok, corrected, vc in vcdus:
        vcid = int(vc[1]) & 0x3F
        cnt = (int(vc[2]) << 16) | (int(vc[3]) << 8) | int(vc[4])
        fhp = ((int(vc[8]) & 0x07) << 8) | int(vc[9])      # Meteor: 6 B VCDU + 2 B insert + 2 B M-PDU päis -> osuti baitides 8-9
        rows.append((p, vcid, cnt, fhp, ok, corrected))
    vcids = {}
    for r in rows:
        vcids[r[1]] = vcids.get(r[1], 0) + 1
    log(f"   VCID jaotus: {dict(sorted(vcids.items(), key=lambda kv: -kv[1])[:5])}  (Meteor LRPT = 5)")
    for r in rows[:6]:
        log(f"   kaader @bit {r[0]}: VCID {r[1]}, loendur {r[2]}, FHP {r[3]}, RS {'ok' if r[4] else 'VIGA'} ({r[5]} par.)")
    # kaadrite ajajoon: loendur vs aeg (kui sirge, on kell täpne)
    cnts = np.array([r[2] for r in rows if r[1] == 5], float); tt = np.array([r[0] for r in rows if r[1] == 5]) / 72000.0
    if len(cnts) > 3:
        med = np.median(cnts)
        keep = np.abs(cnts - med) < 5000
        F = Fig(720, 300, "6. VCDU loendur vs aeg (VCID 5) – iga punkt on üks vastu võetud kaader", "aeg (s)", "loendur - min")
        F.axes(0, tt.max() + 1, 0, max(1, (cnts[keep] - cnts[keep].min()).max() + 1))
        F.dots(tt[keep], cnts[keep] - cnts[keep].min(), "#8e44ad", r=2.5, opacity=0.8)
        F.save(os.path.join(out, "6_loendur.svg"))
    with open(os.path.join(out, "6_kaadrid.csv"), "w", encoding="utf-8") as f:
        f.write("bit_pos,t_s,vcid,loendur,fhp,rs_ok,rs_parandusi\n")
        for r in rows:
            f.write(f"{r[0]},{r[0]/72000:.3f},{r[1]},{r[2]},{r[3]},{int(r[4])},{r[5]}\n")
    np.save(os.path.join(out, "6_vcdu.npy"), np.stack([v[3] for v in vcdus]))
    np.save(os.path.join(out, "6_vcdu_meta.npy"), np.array([[r[0], r[1], r[2], int(r[4])] for r in rows]))
    return vcdus, rows


def stage7(vcdus, rows, out):
    from lrpt_image import packets_from_vcdus, build_images
    sel = [(r[2], r[4], v[3]) for r, v in zip(rows, vcdus) if r[1] == 5]
    sel.sort(key=lambda x: x[0])
    pkts = packets_from_vcdus(sel)
    apids = {}
    for apid, seq, data in pkts:
        apids[apid] = apids.get(apid, 0) + 1
    log(f"etapp 7: {len(pkts)} paketti; APID-id: {dict(sorted(apids.items(), key=lambda kv: -kv[1])[:8])}  (64..69 pilt, 70 telemeetria)")
    stats = build_images(pkts, out)
    for apid, (n, info) in sorted(stats.items()):
        if info:
            rows_, good, bad, path = info
            log(f"   APID {apid}: {n} paketti, {rows_} rida (8 px), MCU-plokke dekodeeritud {good}, katki {bad} -> {os.path.basename(path)}")
    with open(os.path.join(out, "7_paketid.csv"), "w", encoding="utf-8") as f:
        f.write("apid,seq,pikkus,mcun,qf\n")
        for apid, seq, data in pkts:
            f.write(f"{apid},{seq},{len(data)},{data[8] if len(data) > 13 else ''},{data[13] if len(data) > 13 else ''}\n")
    return pkts


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("wav"); ap.add_argument("--start", type=float, default=0); ap.add_argument("--dur", type=float)
    ap.add_argument("--sym", type=float, default=72000); ap.add_argument("--alpha", type=float, default=0.6)
    ap.add_argument("--stage", type=int, default=7); ap.add_argument("--out"); ap.add_argument("--no-rs", action="store_true")
    ap.add_argument("--dual", action="store_true", help="RS duaalbaasi teisendus (CCSDS vaikimisi; Meteor EI kasuta)")
    ap.add_argument("--from-bits", action="store_true", help="jätka salvestatud 5_bits.npy pealt (etapid 6-7)")
    ap.add_argument("--from-symbols", action="store_true", help="jätka salvestatud 3_oqpsk_IQ.npy pealt (etapid 5-6)")
    ap.add_argument("--qpsk", action="store_true", help="vana QPSK-rada (silmadiagramm, x⁴ faas) – ainult võrdluseks")
    ap.add_argument("--fc", type=float, default=137.9e6)
    ap.add_argument("--offset", type=float, default=0.0, help="signaali nihe faili keskmest (Hz), nt 137.5 salvestisel 137.9 jaoks +400000")
    ap.add_argument("--no-diff", action="store_true", help="ilma haru-kaupa diferentsiaaldekodeerimiseta (vana Meteor-M2)")
    ap.add_argument("--pulse", default="rrc", choices=["rrc", "halfsine"], help="sobitusfilter: rrc (alpha) või halfsine (-alpha = pikkus sümbolites, nt -1)")
    a = ap.parse_args()
    name = re.sub(r"_\d+Hz_.*", "", os.path.basename(a.wav))
    out = a.out or os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "captures", "lrpt", name)
    os.makedirs(out, exist_ok=True)
    sym_cache = os.path.join(out, "3_oqpsk_soft.npy")
    bits_cache = os.path.join(out, "5_bits.npy")
    if a.from_bits and os.path.exists(bits_cache):
        soft = None; strength = None
    elif a.from_symbols and os.path.exists(sym_cache):
        soft = np.load(sym_cache); log(f"laetud pehmed bitid {sym_cache}: {len(soft)}")
        strength = None
    else:
        fs, x = load(a.wav, a.start, a.dur)
        log(f"laetud {len(x)/fs:.0f} s @ {fs/1e3:.0f} kHz, algus {a.start:.0f} s -> {out}")
        if a.offset != 0 or fs > 300e3:              # lai salvestis (nt 1 MHz 137.5 ümber): võta kanal välja, 250 kHz
            from iq import extract_channel
            x, fs = extract_channel(x, fs, a.offset, out_fs=250e3)     # tükkhaaval, et mälu ei lõhkeks
            log(f"   kanal nihkega {a.offset/1e3:+.0f} kHz -> {len(x)/fs:.0f} s @ {fs/1e3:.0f} kHz")
        snr = stage1(x, fs, out)
        if a.stage < 2:
            return
        t, fa, fb, ok = stage2(x, fs, out, a.start)
        fm = doppler_model(t, fb, ok)
        y = mix_down(x, fs, fm, a.start)
        del x
        if a.stage < 3:
            return
        sps = fs / a.sym
        if a.pulse == "halfsine":                    # MSK-laadne poolsiinus-impulss pikkusega L sümbolit (8× ülesämplitud, siis 250k-le)
            L = abs(a.alpha) if a.alpha < 0 else 1.0
            n = int(round(L * sps * 8)); hh = np.sin(np.pi * np.arange(n) / n)
            h = np.interp(np.arange(0, n, 8), np.arange(n), hh).astype(np.float32); h /= np.sqrt(np.sum(h ** 2))
        elif a.alpha < 0:                            # ristkülikimpulsi sobitusfilter: integreeri L sämplit (murdosa otstesse)
            L = -a.alpha; nf = int(np.floor(L)); e = (L - nf) / 2
            h = np.concatenate([[e], np.ones(nf), [e]]).astype(np.float32); h /= np.sqrt(np.sum(h ** 2))
        else:
            h = rrc(a.alpha, sps)
        y = fft_filter(y, h)
        if a.qpsk:                                   # vana QPSK-rada (ei tööta Meteori OQPSK-ga, jäetud võrdluseks)
            fsym, tblk, phu = symbol_timing(y, fs, a.sym, out)
            eye_diagram(y, fs, fsym, tblk, phu, out)
            s, tk = sample_symbols(y, fs, fsym, tblk, phu)
            constellation(s, os.path.join(out, "4a_konst_enne.svg"), "4a. Sümbolid enne kandjafaasi lukku")
            z, lock = carrier_phase(s, out)
            constellation(z, os.path.join(out, "4c_konst_parast.svg"), "4c. Sümbolid pärast kandjafaasi lukku")
            return
        soft, strength, tb = oqpsk_sync(y, fs, fm, a.start, a.sym, a.fc, out)
        del y
    if a.stage < 5:
        return
    if soft is not None and not a.no_diff:
        # Meteor-M2 x: NRZ-M diferentsiaalkodeering kummalgi harul eraldi (I_k = c_k xor c_{k-1}); pehmelt: korrutis
        # sama haru eelmise sämpliga (voos on harud vaheldumisi -> nihe 2), magnituud juurest, et skaala püsiks
        p = soft[2:] * soft[:-2]
        soft = (np.sign(p) * np.sqrt(np.abs(p))).astype(np.float32)
    test_at = None
    if strength is not None and len(strength) > 10:
        i = np.argmax(np.convolve(strength, np.ones(8) / 8, "valid"))
        test_at = (tb[i] - a.start)
    if soft is None:
        streams = []
        for bc in (bits_cache, os.path.join(out, "5_bits_b.npy")):
            if os.path.exists(bc):
                bits = np.load(bc); sync, c = find_sync(bits); streams.append((bits, sync[c > 0]))
                log(f"laetud bitid {bc}: {len(bits)}, sünkrosõnu {len(sync[c > 0])}")
    else:
        streams, cfg = stage5(soft, out, test_at=test_at)
    if a.stage < 6:
        return
    vcdus, rows = stage6(streams, out, do_rs=not a.no_rs, dual=a.dual)
    if a.stage < 7 or not vcdus:
        return
    stage7(vcdus, rows, out)


if __name__ == "__main__":
    main()
