"""AIS dekooder aisscan.py purskefailidest (captures\\ais\\*_ais.npz: IQ 48 kHz, kanal keskel).
GMSK 9600 bd (5 sämplit/bitt): FM-diskriminaator → DC maha → sümbolifaas 0–4 × polaarsus ±1 → NRZI (1 = muutust pole) → HDLC lipp
01111110 → bit-stuffing maha (5×1 järel 0 välja) → CRC-16-CCITT (peegeldatud 0x8408, init 0xFFFF, jääk 0xF0B8) → baitide sees LSB-first →
sõnumibitid MSB-first → tüüp 1/2/3 (asukoht), 4 (baasjaam), 5 (staatiline: nimi, kutsung), 18 (klass B), 21 (navimärk).
Kasutus: python ais.py captures\\ais\\*.npz [--out captures\\ais\\laevad.csv]"""
import argparse, csv, glob, os, sys
import numpy as np

SPB = 5
FLAG = np.array([0, 1, 1, 1, 1, 1, 1, 0], np.uint8)


def crc_ok(bits):
    crc = 0xFFFF
    for b in bits:
        crc = ((crc >> 1) ^ 0x8408) if ((crc ^ int(b)) & 1) else (crc >> 1)
    return crc == 0xF0B8


def unstuff(bits):
    out = []; ones = 0
    for b in bits:
        if ones == 5:
            ones = 0
            if b == 0:
                continue                 # toppimisbitt
            return None                  # 6 ühte = lipp/viga
        out.append(int(b)); ones = ones + 1 if b else 0
    return out


def frames_from_bits(nrzi):
    """Kõik lippude vahelised raamid: (payload_bits MSB-first sõnumina, ok)."""
    b = np.array([1 if i == 0 or nrzi[i] == nrzi[i - 1] else 0 for i in range(len(nrzi))], np.uint8)   # NRZI decode
    idx = [i for i in range(len(b) - 8) if np.array_equal(b[i:i + 8], FLAG)]
    res = []
    for k, i in enumerate(idx):
        # järgmine lipp, mis on ≥ 184+ bitti eemal (168 andmed + 16 CRC + toppimine)
        for j in idx[k + 1:]:
            if j - i - 8 < 100:
                continue
            raw = b[i + 8:j]
            u = unstuff(raw)
            if u is None or len(u) % 8 != 0 or len(u) < 24:
                break
            if not crc_ok(u):
                break
            data = u[:-16]
            # baitide sees LSB-first → keera iga bait
            msg = []
            for o in range(0, len(data), 8):
                msg += data[o:o + 8][::-1]
            res.append(msg)
            break
    return res


def u(bits, a, n):
    v = 0
    for x in bits[a:a + n]:
        v = (v << 1) | x
    return v


def s(bits, a, n):
    v = u(bits, a, n)
    return v - (1 << n) if v & (1 << (n - 1)) else v


SIX = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_ !\"#$%&'()*+,-./0123456789:;<=>?"


def text(bits, a, n):
    return "".join(SIX[u(bits, a + 6 * i, 6)] for i in range(n // 6)).replace("@", "").strip()


def parse(m):
    t = u(m, 0, 6); mmsi = u(m, 8, 30); d = {"type": t, "mmsi": mmsi, "bits": len(m)}
    if t in (1, 2, 3) and len(m) >= 168:
        d.update(status=u(m, 38, 4), sog=u(m, 50, 10) / 10, lon=s(m, 61, 28) / 600000, lat=s(m, 89, 27) / 600000,
                 cog=u(m, 116, 12) / 10, hdg=u(m, 128, 9), ts=u(m, 137, 6))
    elif t == 4 and len(m) >= 168:
        d.update(lon=s(m, 79, 28) / 600000, lat=s(m, 107, 27) / 600000, kind="baasjaam")
    elif t == 5 and len(m) >= 424:
        d.update(callsign=text(m, 70, 42), name=text(m, 112, 120), shiptype=u(m, 232, 8), dest=text(m, 302, 120))
    elif t == 18 and len(m) >= 168:
        d.update(sog=u(m, 46, 10) / 10, lon=s(m, 57, 28) / 600000, lat=s(m, 85, 27) / 600000, cog=u(m, 112, 12) / 10, kind="klass B")
    elif t == 21 and len(m) >= 272:
        d.update(name=text(m, 43, 120), lon=s(m, 164, 28) / 600000, lat=s(m, 192, 27) / 600000, kind="navimärk")
    elif t == 24:
        d.update(name=text(m, 40, 120) if u(m, 38, 2) == 0 else "", kind="klass B staatiline")
    return d


def decode_burst(x, fs, fine=True):
    ph = np.angle(x[1:] * np.conj(x[:-1])); fi0 = ph * fs / (2 * np.pi)
    # kandja nihe: mediaan tugevate sämplite pealt; peenhäälestuseks ka ±150/±300 Hz kandidaadid
    amp = np.abs(x[1:]); strong = amp > np.percentile(amp, 50)
    base = np.median(fi0[strong])
    w = 3; fi0 = np.convolve(fi0, np.ones(w) / w, mode="same")
    # 2× interpolatsioon → 10 sümbolifaasi (fine)
    up = 2 if fine else 1
    if fine:
        t = np.arange(len(fi0)); fi_up = np.interp(np.arange(0, len(fi0) - 1, 0.5), t, fi0)
    else:
        fi_up = fi0
    found = []
    for dc in ([base] if not fine else [base, base - 150, base + 150, base - 300, base + 300]):
        fi = fi_up - dc
        for p in range(SPB * up):
            sym = fi[p::SPB * up]
            for pol in (1, -1):
                nrzi = (sym * pol > 0).astype(np.uint8)
                for msg in frames_from_bits(nrzi):
                    found.append(parse(msg))
    # duplikaadid (eri faasid annavad sama sõnumi)
    uniq = {}
    for d in found:
        uniq[(d["type"], d["mmsi"], d.get("lon"), d.get("lat"))] = d
    return list(uniq.values())


def main():
    ap = argparse.ArgumentParser(); ap.add_argument("pats", nargs="+"); ap.add_argument("--out")
    a = ap.parse_args()
    rows = []; nb = 0
    for pat in a.pats:
        for p in sorted(glob.glob(pat)):
            z = np.load(p); fs = float(z["fs"]); ch = float(z["ch"]); n = int(z["n"]); nb += n
            got = 0
            for i in range(n):
                for d in decode_burst(z[f"b{i}"], fs):
                    d["file"] = os.path.basename(p); d["ch"] = ch; d["burst"] = i; rows.append(d); got += 1
            print(f"{os.path.basename(p)}: {n} purset -> {got} sõnumit")
    print(f"\nkokku {nb} purset, {len(rows)} dekodeeritud sõnumit")
    for d in rows:
        if "lat" in d:
            print(f"  tüüp {d['type']:2d} MMSI {d['mmsi']:9d}  {d['lat']:.5f}N {d['lon']:.5f}E  SOG {d.get('sog','-')} kn  COG {d.get('cog','-')}  {d.get('kind','')}")
        else:
            print(f"  tüüp {d['type']:2d} MMSI {d['mmsi']:9d}  {d.get('name','')} {d.get('callsign','')} {d.get('dest','')} {d.get('kind','')}")
    if a.out and rows:
        keys = ["file", "ch", "burst", "type", "mmsi", "lat", "lon", "sog", "cog", "hdg", "status", "ts", "name", "callsign", "dest", "shiptype", "kind"]
        with open(a.out, "w", newline="", encoding="utf-8") as f:
            wr = csv.DictWriter(f, fieldnames=keys, extrasaction="ignore"); wr.writeheader(); wr.writerows(rows)
        print("->", a.out)


if __name__ == "__main__":
    main()
