"""DSC (mereside kanal 70, 156,525 MHz) dekooder: NFM → helis FSK 1200 bd, toonid 1300 (B) / 2100 (Y) Hz, 10-bitised sümbolid
(7 infobitti LSB-first + 3-bitine nullide loendur), DX/RX ajahajutus (RX = sama sümbol 5 hiljem? – DSC: 400 ms = 4 sümbolit... proovime mõlemat),
faasimine 125 (DX) + 111…104 (RX), siis formaat, aadress (5 sümbolit = 10 numbrit = MMSI), kategooria, oma ID, telekomand, EOS.
Kasutus: python dsc.py iq.wav [--mhz 156.525] [--thr 8]"""
import argparse, os, sys, wave
import numpy as np

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import iq as iqlib

SYM = {100: "<FMT-DIST>", 102: "<FMT-ALL>", 112: "<FMT-SEL>", 114: "<FMT-GRP>", 116: "<FMT-AREA>", 120: "<FMT-AUTO>",
       104: "<RX>", 105: "<RX>", 106: "<RX>", 107: "<RX>", 108: "<RX>", 109: "<RX>", 110: "<RX>", 111: "<RX>", 125: "<DX>",
       117: "<EOS-RQ>", 122: "<EOS-BQ>", 127: "<EOS>", 126: "<NOINFO>", 118: "<ACK-RQ>", 121: "<ACK>",
       103: "<CAT-URG>", 108 + 0: "<CAT-SAFE>", 110 + 0: "<CAT-URG?>", 100 + 0: "<CAT-DIST>"}


def decode_audio(x, fs2, invert=False):
    """x: kompleksne kanal (NFM enne). Diskriminaator → heli → kaks toonifiltrit → bitid 1200 bd."""
    ph = np.angle(x[1:] * np.conj(x[:-1])); audio = ph
    t = np.arange(len(audio)) / fs2
    def tone(f):
        y = audio * np.exp(-2j * np.pi * f * t); Y = np.fft.fft(y); fr = np.fft.fftfreq(len(y), 1 / fs2); Y[np.abs(fr) > 700] = 0
        return np.abs(np.fft.ifft(Y))
    soft = tone(2100) - tone(1300)                # >0 = Y (2100 Hz)
    if invert:
        soft = -soft
    sps = fs2 / 1200.0
    trans = np.abs(np.diff(soft)); nb = int(len(soft) / sps)
    best = max(range(int(sps)), key=lambda k: trans[np.clip((np.arange(nb - 1) * sps + k).astype(int), 0, len(trans) - 1)].sum())
    samp = (np.arange(nb) * sps + best + sps / 2).astype(int); samp = samp[samp < len(soft)]
    bits = (soft[samp] > 0).astype(np.uint8)
    return bits, soft[samp]


def symbols(bits):
    """Leia 10-bitine raamistus: 7 bitti LSB-first + 3 bitti nullide arv MSB-first; skoori kontrollbittide klappimine."""
    best = (-1, 0, [])
    for ph in range(10):
        ok = 0; syms = []
        for i in range(ph, len(bits) - 10, 10):
            b = bits[i:i + 10]; v = sum(int(b[k]) << k for k in range(7)); z = 7 - bin(v).count("1")
            chk = (int(b[7]) << 2) | (int(b[8]) << 1) | int(b[9])
            syms.append((v, chk == z)); ok += chk == z
        if ok > best[0]:
            best = (ok, ph, syms)
    return best


def main():
    ap = argparse.ArgumentParser(); ap.add_argument("wav"); ap.add_argument("--mhz", type=float, default=156.525); ap.add_argument("--thr", type=float, default=8)
    a = ap.parse_args()
    fc = iqlib.center_freq_from_name(a.wav)
    with wave.open(a.wav, "rb") as w:
        fs = w.getframerate(); total = w.getnframes() / fs
    xs = []
    for st in np.arange(0, total, 30.0):
        _, seg = iqlib.load_iq(a.wav, float(st), 30.0)
        if len(seg) < fs * 0.5:
            break
        x, fs2 = iqlib.extract_channel(seg, fs, a.mhz * 1e6 - fc, out_fs=24e3); xs.append(x); del seg
    x = np.concatenate(xs)
    bl = int(fs2 * 0.02); nb = len(x) // bl
    pw = 10 * np.log10((np.abs(x[: nb * bl].reshape(nb, bl)) ** 2).mean(1) + 1e-12); med = np.median(pw)
    on = pw > med + a.thr; ed = np.diff(np.concatenate([[0], on.astype(int), [0]])); s0 = np.where(ed == 1)[0]; e0 = np.where(ed == -1)[0]
    print(f"{os.path.basename(a.wav)} {a.mhz}: {len(s0)} purset üle {a.thr} dB")
    for s, e in zip(s0, e0):
        if (e - s) * 0.02 < 0.3:
            continue
        seg = x[max(0, (s - 2) * bl):(e + 2) * bl]
        print(f"--- {s*0.02:.1f}–{e*0.02:.1f} s ({(e-s)*0.02:.2f} s), {pw[s:e].max()-med:.0f} dB")
        for inv in (False, True):
            bits, soft = decode_audio(seg, fs2, inv)
            ok, ph, syms = symbols(bits)
            vals = [v for v, g in syms]
            good = [v if g else -1 for v, g in syms]
            print(f"   invert={inv}: {len(syms)} sümbolit, kontroll OK {ok} ({100*ok/max(1,len(syms)):.0f} %), faas {ph}")
            print("   ", " ".join(f"{v:3d}" if v >= 0 else "  ." for v in good[:60]))
            # dot-pattern kontroll: 1010… bitid alguses
            alt = np.mean(bits[:200:2] != bits[1:200:2]) if len(bits) > 200 else 0
            print(f"   punktimuster (bitid vahelduvad): {100*alt:.0f} %")


if __name__ == "__main__":
    main()
