"""DAB+ (ETSI EN 300 401, Mode I) dekooder puhtas numpy's – esimene verstapost: FIC ehk ansambli info (jaamade nimed).
Sisend: 2,4 MSPS IQ WAV (capture.ps1) ansambli keskel (nt 215.072 MHz = 10D).

Etapid:  1 resample 2,4 -> 2,048 MHz   2 null-sümboli otsing (energia miinimum, 96 ms kaader)   3 peen sagedus (kaitseintervalli
korrelatsioon)   4 OFDM demod: 2048-FFT iga sümboli kohta, 1536 kandjat   5 DQPSK (sümbol × conj(eelmine)) + sagedus-deinterleave
6 FIC: 3 sümbolit -> 4 plokki à 3072 bitti -> depunkteerimine -> Viterbi r=1/4 K=7 -> 768 bitti -> energia-dispersal -> 3 FIB à 32 B
(CRC16)   7 FIG-id: 0/0 ansambel, 1/0 ansambli silt, 1/1 teenuse silt, 0/1 alamkanalid, 0/2 teenused.

Kasutus: python dab.py recordings/baseband_215072000Hz_*.wav [--seconds 4] [--carrier-offset N]
"""
import argparse, os, sys, wave
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

FS = 2048000.0
TU, TG, TNULL = 2048, 504, 2656
TS = TU + TG                      # 2552
NSYM = 76                         # PRS + 3 FIC + 72 MSC
TF = TNULL + NSYM * TS            # 196608 = 96 ms
K = 1536


def load(path, seconds):
    with wave.open(path, "rb") as w:
        fs = w.getframerate(); n = min(w.getnframes(), int(seconds * fs))
        d = np.frombuffer(w.readframes(n), np.int16).astype(np.float32) / 32768
    return fs, (d[0::2] + 1j * d[1::2]).astype(np.complex64)


def resample(x, fs_in, fs_out=FS):
    """FFT-põhine ratsionaalne ümbersämplimine: lõika spekter fs_out laiuseks."""
    n = len(x); m = int(round(n * fs_out / fs_in))
    X = np.fft.fft(x)
    half = m // 2
    Y = np.zeros(m, np.complex64)
    Y[:half] = X[:half]; Y[-half:] = X[-half:]
    return (np.fft.ifft(Y) * (m / n)).astype(np.complex64)


def find_null(x):
    """Null-sümbol: 2656 sämplit peaaegu nulli. Liikuv energia TNULL aknas, miinimum kaadri (TF) sees."""
    p = np.abs(x) ** 2
    c = np.cumsum(np.concatenate([[0], p]))
    e = c[TNULL:] - c[:-TNULL]                      # energia aknas [i, i+TNULL)
    # esimese kaadri sees miinimum
    i0 = int(np.argmin(e[:TF]))
    # täpsusta: vali iga järgmise kaadri miinimum ±200 sämplit ümber ennustuse
    starts = [i0]
    while starts[-1] + 2 * TF < len(x):
        pred = starts[-1] + TF
        lo, hi = max(0, pred - 200), min(len(e), pred + 200)
        starts.append(lo + int(np.argmin(e[lo:hi])))
    depth = 10 * np.log10(np.median(e[[s + TNULL // 2 for s in starts[:-1]]] + 1e-12) / np.median(e) + 1e-12)
    return np.array(starts), depth


def fine_freq(x, start):
    """Kaitseintervalli korrelatsioon: sümboli viimased TG sämplit = esimesed TG (nihkega TU). Faas -> sageduse nihe."""
    acc = 0j
    for l in range(NSYM):
        a = start + TNULL + l * TS
        seg = x[a:a + TS]
        if len(seg) < TS:
            break
        acc += np.sum(seg[TU:TU + TG] * np.conj(seg[:TG]))
    return -np.angle(acc) / (2 * np.pi) * FS / TU     # Hz


def ofdm_symbols(x, start, foff, carrier_offset=0):
    """Tagastab (NSYM, K) kandjate väärtused (DC välja, k = -768..-1, 1..768)."""
    n = np.arange(len(x))
    xc = x * np.exp(-2j * np.pi * foff * n / FS).astype(np.complex64)
    out = np.zeros((NSYM, K), np.complex64)
    for l in range(NSYM):
        a = start + TNULL + l * TS + TG            # jäta kaitseintervall vahele (algus + TG..., aga võta natuke varem ISI vastu)
        a -= TG // 4
        seg = xc[a:a + TU]
        if len(seg) < TU:
            break
        X = np.fft.fft(seg)
        X = np.roll(X, -carrier_offset)
        neg = X[TU - 768:TU]; pos = X[1:769]
        out[l] = np.concatenate([neg, pos])
    return out


def freq_interleaver():
    """EN 300 401 §14.6: R(i) = (13 R(i-1) + 511) mod 2048; jäta 256..1792 sees, ≠ 1024; k = R - 1024 -> kandja indeks."""
    R = 0; idx = []
    for i in range(2048):
        R = (13 * R + 511) % 2048 if i > 0 else 0
        if 256 <= R <= 1792 and R != 1024:
            idx.append(R - 1024)
    idx = np.array(idx)                                # 1536 väärtust k ∈ [-768, 768] \ {0}
    col = np.where(idx < 0, idx + 768, idx + 767)      # kandja k -> veerg 0..1535 ofdm_symbols väljundis
    return col


def dqpsk_bits(sym, col):
    """DQPSK: q = z_l * conj(z_{l-1}); pehmed bitid: reaalosa -> bitt n, imaginaarosa -> bitt n+1536 (n = interleaveri järjekord).
    Tagastab (NSYM-1, 3072) pehmed bitid (positiivne = 0)."""
    soft = np.zeros((NSYM - 1, 2 * K), np.float32)
    for l in range(1, NSYM):
        q = sym[l] * np.conj(sym[l - 1])
        v = q[col]                                     # interleaveri järjekorda
        soft[l - 1, :K] = v.real; soft[l - 1, K:] = v.imag
    soft /= (np.mean(np.abs(soft)) + 1e-9)
    return soft


# --- Viterbi r=1/4 K=7 (0o133, 0o171, 0o145, 0o133), punkteerimine EN 300 401 §11
POLYS = (0o133, 0o171, 0o145, 0o133)
def _pi_vectors():
    """EN 300 401 tabel 29: 32-bitine vektor = 8 rühma à 4 (üks rühm = ühe infobiti 4 väljundit). PI 1..24 = 8+PI bitti saadetud.
    Struktuur: kõigepealt lisandub 2. väljund rühmadesse 0,4,2,6,1,5,3,7, siis 3. samas järjekorras, siis 4."""
    order = [0, 4, 2, 6, 1, 5, 3, 7]
    vec = {}
    for pi in range(1, 25):
        g = [[1, 0, 0, 0] for _ in range(8)]
        n = pi
        for level in (1, 2, 3):
            for grp in order:
                if n == 0:
                    break
                g[grp][level] = 1; n -= 1
        vec[pi] = "".join(str(b) for grp in g for b in grp)
    return vec


PI_VEC = _pi_vectors()

def parity(v):
    return bin(v).count("1") & 1


def viterbi_r14(soft, pattern):
    """soft: pehmed kodeeritud bitid (positiivne = 0), pattern: sama pikk 0/1 maskiga (0 = punkteeritud, kasutame 0 metrikat).
    Tagastab info bitid (len = len(pattern)//4 - 6 ... täpsemalt N kus 4*(N+6) = len(pattern))."""
    n_out = len(pattern); N = n_out // 4 - 6
    r = np.zeros(n_out, np.float32); r[:len(soft)] = soft
    r = r * pattern
    r = r.reshape(-1, 4)                               # (N+6, 4)
    s = np.arange(64)
    nxt = np.zeros((64, 2), int); outs = np.zeros((64, 2, 4), np.float32)
    for b in (0, 1):
        enc = (s << 1) | b
        nxt[:, b] = enc & 0x3F
        for j, p in enumerate(POLYS):
            outs[:, b, j] = 1 - 2 * np.array([parity(e & p) for e in enc])
    pred = np.zeros((64, 2), int); pb = np.zeros((64, 2), int)
    for nn in range(64):
        ps = [(p, b) for p in range(64) for b in (0, 1) if nxt[p, b] == nn]
        pred[nn] = [ps[0][0], ps[1][0]]; pb[nn] = [ps[0][1], ps[1][1]]
    po = outs[pred, pb]                                # (64, 2, 4)
    T = r.shape[0]
    metric = np.full(64, -1e9, np.float32); metric[0] = 0
    dec = np.zeros((T, 64), bool)
    for t in range(T):
        bm = po @ r[t]                                 # (64, 2)
        c0 = metric[pred[:, 0]] + bm[:, 0]; c1 = metric[pred[:, 1]] + bm[:, 1]
        d = c1 > c0; dec[t] = d; metric = np.where(d, c1, c0)
    st = 0                                             # lõpetatakse olekus 0 (6 sabab bitti)
    bits = np.zeros(T, np.uint8)
    for t in range(T - 1, -1, -1):
        bits[t] = st & 1
        st = pred[st, 1] if dec[t, st] else pred[st, 0]
    return bits[:N]


def fic_pattern():
    """Mode I FIC plokk: 768 info bitti + 6 saba -> 3096 emabitti -> 3072 saadetud: 21 plokki PI=16, 3 plokki PI=15 (128 bitti igas), + 24 saba (VT)."""
    pat = []
    for _ in range(21):
        pat += [int(c) for c in PI_VEC[16]] * 4       # plokk = 32 infobitti = 128 emabitti = 4× 32-bitine vektor (24/32 saadetud)
    for _ in range(3):
        pat += [int(c) for c in PI_VEC[15]] * 4       # 23/32
    pat += [1, 1, 0, 0] * 6                            # saba: VT = 1100 1100 1100 1100 1100 1100 (12/24)
    assert len(pat) == (768 + 6) * 4 and sum(pat) == 2304, (len(pat), sum(pat))
    return np.array(pat, np.float32)


def energy_dispersal(bits):
    """PRBS x^9 + x^5 + 1, alg 111111111 – XOR."""
    reg = 0x1FF; out = bits.copy()
    for i in range(len(bits)):
        b = ((reg >> 8) ^ (reg >> 4)) & 1
        out[i] ^= b
        reg = ((reg << 1) | b) & 0x1FF
    return out


def crc16(data):
    """CCITT: poly 0x1021, init 0xFFFF, tulemus inverteeritud."""
    c = 0xFFFF
    for b in data:
        c ^= int(b) << 8
        for _ in range(8):
            c = ((c << 1) ^ 0x1021) & 0xFFFF if c & 0x8000 else (c << 1) & 0xFFFF
    return c ^ 0xFFFF


def parse_fibs(fibs):
    """FIB = 30 baiti FIG-e + 2 CRC. Tagastab loetud tekstid ja struktuurid."""
    info = {"ensemble": None, "services": {}, "subch": {}, "labels": {}, "fibs_ok": 0, "fibs_bad": 0}
    for fib in fibs:
        if crc16(fib[:30]) != ((int(fib[30]) << 8) | int(fib[31])):
            info["fibs_bad"] += 1; continue
        info["fibs_ok"] += 1
        i = 0
        while i < 30:
            hdr = fib[i]
            if hdr == 0xFF:
                break
            ftype, flen = hdr >> 5, hdr & 0x1F
            body = fib[i + 1:i + 1 + flen]; i += 1 + flen
            if flen == 0:
                continue
            if ftype == 1 and len(body) >= 18:        # sildid
                ext = body[0] & 0x07; charset = body[0] >> 4
                label = bytes(body[-18:-2]).decode("latin-1", "replace").rstrip()
                if ext == 0:
                    eid = (body[1] << 8) | body[2]; info["labels"][("ens", eid)] = label
                elif ext == 1:
                    sid = (body[1] << 8) | body[2]; info["labels"][("srv", sid)] = label
            elif ftype == 0:
                ext = body[0] & 0x1F; pd = (body[0] >> 5) & 1
                d = body[1:]
                if ext == 0 and len(d) >= 4:
                    eid = (d[0] << 8) | d[1]; info["ensemble"] = {"eid": eid, "change": d[2] >> 6, "cif": ((d[2] & 0x1F) << 8) | d[3]}
                elif ext == 1:                        # alamkanalid
                    j = 0
                    while j + 3 <= len(d):
                        scid = d[j] >> 2; sa = ((d[j] & 0x03) << 8) | d[j + 1]; sf = d[j + 2] >> 7
                        if sf == 0:
                            tab = d[j + 2] & 0x3F; info["subch"][scid] = {"start": sa, "short_table": tab}; j += 3
                        else:
                            if j + 4 > len(d):
                                break
                            opt = (d[j + 2] >> 4) & 0x07; prot = (d[j + 2] >> 2) & 0x03; size = ((d[j + 2] & 0x03) << 8) | d[j + 3]
                            info["subch"][scid] = {"start": sa, "opt": opt, "prot": prot, "size_cu": size}; j += 4
                elif ext == 2:                        # teenused
                    j = 0
                    while j < len(d):
                        if pd == 0:
                            if j + 3 > len(d):
                                break
                            sid = (d[j] << 8) | d[j + 1]; ncomp = d[j + 2] & 0x0F; j += 3
                        else:
                            if j + 5 > len(d):
                                break
                            sid = (d[j] << 24) | (d[j + 1] << 16) | (d[j + 2] << 8) | d[j + 3]; ncomp = d[j + 4] & 0x0F; j += 5
                        comps = []
                        for _ in range(ncomp):
                            if j + 2 > len(d):
                                break
                            tmid = d[j] >> 6
                            if tmid == 0:
                                comps.append({"ascty": d[j] & 0x3F, "subchid": d[j + 1] >> 2, "primary": (d[j + 1] >> 1) & 1})
                            j += 2
                        info["services"][sid] = comps
    return info


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("wav"); ap.add_argument("--seconds", type=float, default=4.0)
    ap.add_argument("--carrier-offset", type=int, default=None, help="täisarvuline kandjanihe; vaikimisi proovitakse -3..3")
    a = ap.parse_args()
    fs, x = load(a.wav, a.seconds)
    x = resample(x, fs)
    starts, depth = find_null(x)
    print(f"null-sümbolid: {len(starts)} kaadrit, esimene {starts[0]} ({starts[0]/FS*1e3:.1f} ms), sügavus {depth:.1f} dB, vahed {np.unique(np.diff(starts))}")
    foff = np.mean([fine_freq(x, s) for s in starts[:3]])
    print(f"peen sagedusnihe {foff:+.0f} Hz")
    col = freq_interleaver()
    pat = fic_pattern()
    best = None
    offsets = [a.carrier_offset] if a.carrier_offset is not None else [0, 1, -1, 2, -2, 3, -3]
    for co in offsets:
        ok = bad = 0; fibs_all = []
        for s in starts[:min(len(starts), 8)]:
            sym = ofdm_symbols(x, s, foff, co)
            soft = dqpsk_bits(sym, col)
            fic = soft[0:3].reshape(-1)               # sümbolid 1..3 (PRS-i järel) = 9216 bitti = 4 × 2304? -> 4 plokki à 2304 saadetud biti... vt allpool
            # Mode I: FIC 3 sümbolit = 9216 bitti = 4 plokki à 2304 (768 info)
            for b in range(4):
                blk = fic[b * 2304:(b + 1) * 2304]
                # depunkteerimine: pattern (3096) märgib, millised emabitid on saadetud (2304 tk)
                full = np.zeros(len(pat), np.float32); full[pat > 0] = blk[: int(pat.sum())]
                bits = viterbi_r14(full, pat)
                bits = energy_dispersal(bits)
                by = np.packbits(bits[:768])
                for f in range(3):
                    fib = by[f * 32:(f + 1) * 32]
                    fibs_all.append(fib)
                    if crc16(fib[:30]) == ((int(fib[30]) << 8) | int(fib[31])):
                        ok += 1
                    else:
                        bad += 1
        print(f"kandjanihe {co:+d}: FIB CRC korras {ok}/{ok+bad}")
        if best is None or ok > best[0]:
            best = (ok, co, fibs_all)
    ok, co, fibs_all = best
    if ok == 0:
        print("ühtegi FIB-i ei tulnud läbi – vaata sünkrot"); return
    info = parse_fibs(fibs_all)
    print(f"\nkandjanihe {co:+d}; FIB-e korras {info['fibs_ok']}, vigaseid {info['fibs_bad']}")
    if info["ensemble"]:
        e = info["ensemble"]; print(f"Ansambel EId 0x{e['eid']:04X}, CIF loendur {e['cif']}")
    for key, lab in sorted(info["labels"].items()):
        print(f"  {'ANSAMBEL' if key[0]=='ens' else 'teenus  '} 0x{key[1]:04X}: '{lab}'")
    for sid, comps in sorted(info["services"].items()):
        print(f"  teenus 0x{sid:04X}: komponendid {comps}")
    for scid, sc in sorted(info["subch"].items()):
        print(f"  alamkanal {scid}: {sc}")


if __name__ == "__main__":
    main()
