"""FT8 dekooder (puhas numpy). Sisend: IQ-fail + dial-sagedus (USB, nt 14.074) või 12 kHz heli-wav.
8-FSK, 6,25 Hz toonivahe, 79 sümbolit × 160 ms, Costas 7×3 (sümbolid 0–6, 36–42, 72–78), 58 andmesümbolit = 174 bitti (Gray),
LDPC(174,91) min-sum, CRC-14 (0x2757), 77-bit sõnum tüüp 1/2 (c28 r1 c28 r1 R1 g15 i3). Tabelid data\\ft8_ldpc.json (ft8_lib).
Kasutus: python ft8.py iq.wav --dial 14.074 [--out captures\\ft8\\x.txt]   või   python ft8.py heli.wav --audio
"""
import argparse, json, os, sys, wave
import numpy as np

HERE = os.path.dirname(os.path.abspath(__file__)); ROOT = os.path.dirname(HERE)
sys.path.insert(0, HERE)
T = json.load(open(os.path.join(ROOT, "data", "ft8_ldpc.json")))
NM = [[v - 1 for v in row if v > 0] for row in T["Nm"]]          # kontroll -> bitid (0-based)
MN = [[v - 1 for v in row] for row in T["Mn"]]                    # bitt -> kontrollid
COSTAS = [3, 1, 4, 0, 6, 5, 2]
GRAY = [0, 1, 3, 2, 5, 6, 4, 7]                                   # sümbol (3 bitti) -> toon
INV_GRAY = {t: s for s, t in enumerate(GRAY)}
FS = 12000; SYM_S = 0.16; NSYM = 79
NTOKENS = 2063592; MAX22 = 4194304
A1 = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; A2 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"; A3 = "0123456789"; A4 = " ABCDEFGHIJKLMNOPQRSTUVWXYZ"


def crc14(bits77):
    bits = list(bits77) + [0] * 5                               # 82 bitti
    nbytes = (len(bits) + 7) // 8; msg = [0] * nbytes
    for i, b in enumerate(bits):
        if b: msg[i // 8] |= 0x80 >> (i % 8)
    rem = 0                                                       # ft8_lib: 14-bit register, bait << 6, TOPBIT 0x2000
    for i in range(len(bits)):
        if i % 8 == 0:
            rem ^= msg[i // 8] << 6
        rem = ((rem << 1) ^ 0x2757) if (rem & 0x2000) else (rem << 1)
        rem &= 0x3FFF
    return rem


def ldpc_decode(llr, iters=30):
    """min-sum BP. llr: 174 (positiivne = bitt 0). Tagastab (bitid, parity_ok)."""
    n = len(llr); m = len(NM)
    msg_cv = {}                                                   # (check, var) -> sõnum
    for c in range(m):
        for v in NM[c]:
            msg_cv[(c, v)] = 0.0
    for it in range(iters):
        # var -> check
        tot = llr.copy()
        for (c, v), val in msg_cv.items():
            tot[v] += val
        hard = (tot < 0).astype(np.uint8)
        ok = all((sum(hard[v] for v in NM[c]) % 2) == 0 for c in range(m))
        if ok:
            return hard, True
        # check -> var (min-sum, 0.8 normaliseerimine)
        new = {}
        for c in range(m):
            vs = NM[c]
            vc = [tot[v] - msg_cv[(c, v)] for v in vs]
            for i, v in enumerate(vs):
                others = [vc[j] for j in range(len(vs)) if j != i]
                sgn = np.prod(np.sign(others)) if all(o != 0 for o in others) else 0.0
                new[(c, v)] = 0.8 * sgn * min(abs(o) for o in others)
        msg_cv = new
    tot = llr.copy()
    for (c, v), val in msg_cv.items():
        tot[v] += val
    return (tot < 0).astype(np.uint8), False


def unpack_c28(n, r1=0):
    if n < NTOKENS:
        if n == 0: return "DE"
        if n == 1: return "QRZ"
        if n == 2: return "CQ"
        if n <= 1002: return f"CQ {n-3:03d}"
        if n <= 532443 + 1003:
            n -= 1003; s = ""
            for _ in range(4):
                s = A4[n % 27] + s; n //= 27
            return "CQ " + s.strip()
        return "?"
    n -= NTOKENS
    if n < MAX22:
        return f"<{n:07d}>"                                       # räsitud kutsung
    n -= MAX22
    c6 = A4[n % 27]; n //= 27; c5 = A4[n % 27]; n //= 27; c4 = A4[n % 27]; n //= 27
    c3 = A3[n % 10]; n //= 10; c2 = A2[n % 36]; n //= 36; c1 = A1[n % 37] if n < 37 else "?"
    call = (c1 + c2 + c3 + c4 + c5 + c6).strip()
    return call + ("/R" if r1 else "")


def unpack_g15(g, R):
    if g < 32400:
        d4 = g % 10; g //= 10; d3 = g % 10; g //= 10; d2 = g % 18; g //= 18; d1 = g
        return chr(65 + d1) + chr(65 + d2) + str(d3) + str(d4)
    r = g - 32400
    if r == 0: return ""
    if r == 1: return "RRR"
    if r == 2: return "RR73"
    if r == 3: return "73"
    v = r - 35
    return ("R" if R else "") + f"{v:+03d}"


def unpack77(b):
    def u(a, n):
        v = 0
        for x in b[a:a + n]: v = (v << 1) | int(x)
        return v
    i3 = u(74, 3); n3 = u(71, 3)
    if i3 in (1, 2):
        c1 = unpack_c28(u(0, 28), u(28, 1)); c2 = unpack_c28(u(29, 28), u(57, 1)); R = u(58, 1); g = unpack_g15(u(59, 15), R)
        return f"{c1} {c2} {g}".strip(), i3
    if i3 == 0 and n3 == 0:
        # vaba tekst 71 bitti, 13 märki base-42
        A = " 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ+-./?"; v = u(0, 71); s = ""
        for _ in range(13):
            s = A[v % 42] + s; v //= 42
        return s.strip(), 0
    if i3 == 4:
        return "<mittestandardne kutsung>", 4
    return f"<tüüp {i3}.{n3}>", i3


def spectrogram(x, fs):
    """Kompleksne baseband (dial = 0 Hz). Bins 3,125 Hz (N = fs/3,125), hop 80 ms. Tagastab log-võimsus [aeg, bin], f0-bin skaala."""
    N = int(round(fs / 3.125)); hop = int(round(fs * 0.08))
    win = np.hanning(N).astype(np.float32)
    nt = (len(x) - N) // hop
    S = np.empty((nt, N // 2), np.float32)                        # ainult positiivsed sagedused (USB)
    for i in range(nt):
        X = np.fft.fft(x[i * hop:i * hop + N] * win)
        S[i] = np.abs(X[: N // 2]) ** 2
    return np.log(S + 1e-12), hop, N


def sync_candidates(L, fmin_hz=200, fmax_hz=3000, top=40):
    """Costas-korrelatsioon: iga (t0, f0) kohta summa 3×7 sümbolite log-võimsus miinus sama akna keskmine. Sümbol = 2 hopi, toon = 2 bini."""
    nt, nf = L.shape
    b0 = int(fmin_hz / 3.125); b1 = int(fmax_hz / 3.125)
    score = np.full((nt, nf), -np.inf, np.float32)
    tmax = nt - 2 * NSYM
    if tmax <= 0:
        return []
    acc = np.zeros((tmax, b1 - b0), np.float32); base = np.zeros((tmax, b1 - b0), np.float32)
    for blk in (0, 36, 72):
        for i, tone in enumerate(COSTAS):
            ts = 2 * (blk + i)
            acc += L[ts:ts + tmax, b0 + 2 * tone: b1 + 2 * tone]
            for k in range(8):                                    # 8 tooni keskmine samas sümbolis
                base += L[ts:ts + tmax, b0 + 2 * k: b1 + 2 * k] / 8
    sc = acc - base
    # tipud: sorteeri, väldi lähedasi (±3 bini, ±4 hopi)
    idx = np.argsort(sc, axis=None)[::-1]
    out = []
    for flat in idx[:top * 40]:
        t, f = divmod(int(flat), sc.shape[1])
        if any(abs(t - t2) <= 4 and abs(f - f2) <= 3 for t2, f2, _ in out):
            continue
        out.append((t, f + b0, float(sc[t, f])))
        if len(out) >= top:
            break
    return out


def symbols_llr(L, t0, fb):
    """79 sümbolit × 8 tooni log-võimsus → 174 LLR (3 bitti sümboli kohta, Gray, max-log)."""
    P = np.array([[L[t0 + 2 * s, fb + 2 * k] for k in range(8)] for s in range(NSYM)])   # (79, 8)
    data = [s for s in range(NSYM) if not (s < 7 or 36 <= s < 43 or s >= 72)]
    llr = []
    for s in data:
        p = P[s]                                                  # log-võimsus tooni kohta ~ log-likelihood
        for bit in range(3):
            m1 = max(p[GRAY[sym]] for sym in range(8) if (sym >> (2 - bit)) & 1)
            m0 = max(p[GRAY[sym]] for sym in range(8) if not (sym >> (2 - bit)) & 1)
            llr.append(m0 - m1)
    llr = np.array(llr, np.float64)
    llr = llr / (np.std(llr) + 1e-9) * 2.0                        # skaala
    return llr


def decode_cycle(x, fs, t_offset_s=0.0, top=40, verbose=False):
    L, hop, N = spectrogram(x, fs)
    cands = sync_candidates(L, top=top)
    results = {}
    for t0, fb, sc in cands:
        llr = symbols_llr(L, t0, fb)
        bits, ok = ldpc_decode(llr)
        if not ok:
            continue
        msg77 = bits[:77]; crc = bits[77:91]
        c = 0
        for b in crc: c = (c << 1) | int(b)
        if crc14(msg77) != c:
            continue
        text, i3 = unpack77(msg77)
        f_hz = fb * 3.125; t_s = t0 * 0.08 + t_offset_s
        key = text
        if key not in results:
            results[key] = (f_hz, t_s, sc)
    return [(t, f, s, txt) for txt, (f, t, s) in results.items()]


def main():
    ap = argparse.ArgumentParser(); ap.add_argument("wav"); ap.add_argument("--dial", type=float, default=None)
    ap.add_argument("--audio", action="store_true"); ap.add_argument("--top", type=int, default=40); ap.add_argument("--out")
    a = ap.parse_args()
    if a.audio:
        with wave.open(a.wav, "rb") as w:
            fs0 = w.getframerate(); d = np.frombuffer(w.readframes(w.getnframes()), np.int16).astype(np.float32) / 32768
        # reaalne heli → analüütiline (USB = positiivsed sagedused)
        X = np.fft.fft(d); f = np.fft.fftfreq(len(d), 1 / fs0); X[f < 0] = 0; x = np.fft.ifft(X).astype(np.complex64); fs = fs0
    else:
        import iq as iqlib
        fc = iqlib.center_freq_from_name(a.wav); fs0, d = iqlib.load_iq(a.wav)
        x, fs = iqlib.extract_channel(d, fs0, int(round(a.dial * 1e6)) - fc, out_fs=FS); del d
        x = x * np.exp(-2j * np.pi * (-1500) * np.arange(len(x)) / fs) * 0 + x   # kese jääb dial'ile
    print(f"{os.path.basename(a.wav)}: {len(x)/fs:.1f} s, fs {fs:.0f}")
    res = decode_cycle(x, fs, top=a.top)
    res.sort()
    lines = [f"{t:6.1f} s  {f:7.1f} Hz  sünk {s:5.1f}  {txt}" for t, f, s, txt in res]
    print(f"dekodeeritud {len(res)} sõnumit:"); print("\n".join(lines))
    if a.out:
        open(a.out, "w", encoding="utf-8").write("\n".join(lines) + "\n")


if __name__ == "__main__":
    main()
