#!/usr/bin/env python3
"""eeter-rx – dongli AINUS omanik (asendab SDR++-i: IQ Exporter + rigctl + Recorder).

Pordid (kõik 127.0.0.1):
  1234  IQ int16 I/Q vaheldumisi, ilma päiseta, 2.4 MSPS – sama mis SDR++ IQ Exporter, aga MITU klienti korraga
  1235  rtl_tcp-ühilduv (uint8 + 12-baidine "RTL0" päis; käsud 0x01 sagedus, 0x03 gain-režiim, 0x04 gain, 0x08 AGC)
        -> SDR++ / rtl_433 / dump1090 jms saavad vaadata ilma donglit endale võtmata
  4532  rigctl (tekst, rida = käsk):
          F <Hz> / f          tuuni / loe sagedus
          M <mode> <bw> / m   režiim ainult meelde (ühilduvus vanade skriptidega)
          AOS / LOS           baseband-salvestus recordings/baseband_<Hz>Hz_HH-MM-SS_DD-MM-YYYY.wav algab / lõpeb
          L RFGAIN <dB|auto>  gain (dB, lähim toetatud); "auto" = tuuneri AGC
          l RFGAIN            loe gain (dB; auto = -1)
          BIAST 0|1           bias-T
          STATUS              JSON: sagedus, gain, kliendid, kadunud plokid, salvestus
          q                   sulge ühendus
Käivitus: eeter_rx.py [--mhz 101.6] [--gain 37.2] [--fs 2400000]; systemd: ~/.config/systemd/user/eeter-rx.service.
Kodusagedus: SDR/home_mhz.txt (kui olemas), muidu --mhz. USB-katkestusel väljub koodiga 1 -> systemd taaskäivitab.
"""
import argparse, ctypes, ctypes.util, datetime as dt, json, os, queue, signal, socket, socketserver, struct, sys, threading, time, wave
from pathlib import Path

import numpy as np

ROOT = Path(__file__).resolve().parent.parent
BUF_LEN = 16 * 16384            # baiti ühe USB-ploki kohta (55 ms 2.4 MSPS-il)
CLIENT_QUEUE = 100              # plokki (~5 s) kliendi järjekorras; täis -> vanim visatakse


def log(msg):
    print(f"[{dt.datetime.now():%H:%M:%S}] {msg}", flush=True)


# ------------------------------------------------------------------ librtlsdr (rtl-sdr-blog, /usr/local/lib)

def load_lib():
    for p in ("/usr/local/lib/librtlsdr.so", "/usr/local/lib/librtlsdr.so.0", ctypes.util.find_library("rtlsdr")):
        if p and (not p.startswith("/") or os.path.exists(p)):
            try:
                return ctypes.CDLL(p)
            except OSError:
                pass
    sys.exit("librtlsdr puudub (rtl-sdr-blog draiver, vt docs/01)")


LIB = load_lib()
CB = ctypes.CFUNCTYPE(None, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_uint32, ctypes.c_void_p)
LIB.rtlsdr_read_async.argtypes = [ctypes.c_void_p, CB, ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32]
for fn in ("rtlsdr_open",):
    getattr(LIB, fn).argtypes = [ctypes.POINTER(ctypes.c_void_p), ctypes.c_uint32]
for fn in ("rtlsdr_set_sample_rate", "rtlsdr_set_center_freq", "rtlsdr_set_tuner_gain_mode", "rtlsdr_set_tuner_gain",
           "rtlsdr_set_agc_mode", "rtlsdr_set_bias_tee"):
    getattr(LIB, fn).argtypes = [ctypes.c_void_p, ctypes.c_int]
for fn in ("rtlsdr_reset_buffer", "rtlsdr_cancel_async", "rtlsdr_close", "rtlsdr_get_center_freq", "rtlsdr_get_tuner_type"):
    getattr(LIB, fn).argtypes = [ctypes.c_void_p]
LIB.rtlsdr_get_center_freq.restype = ctypes.c_uint32
LIB.rtlsdr_get_tuner_gains.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_int)]
LIB.rtlsdr_get_device_name.restype = ctypes.c_char_p


class Dongle:
    def __init__(self, fs, freq, gain):
        self.dev = ctypes.c_void_p()
        if LIB.rtlsdr_get_device_count() < 1:
            sys.exit("donglit pole (lsusb: 0bda:2838?)")
        log(f"seade: {LIB.rtlsdr_get_device_name(0).decode()}")
        if LIB.rtlsdr_open(ctypes.byref(self.dev), 0) != 0:
            sys.exit("rtlsdr_open ebaõnnestus (kas keegi teine hoiab donglit? dvb_usb_rtl28xxu?)")
        n = LIB.rtlsdr_get_tuner_gains(self.dev, None)
        arr = (ctypes.c_int * n)()
        LIB.rtlsdr_get_tuner_gains(self.dev, arr)
        self.gains = [g / 10 for g in arr]
        self.tuner = LIB.rtlsdr_get_tuner_type(self.dev)
        self.lock = threading.Lock()
        self.fs = fs
        LIB.rtlsdr_set_sample_rate(self.dev, fs)
        LIB.rtlsdr_set_agc_mode(self.dev, 0)
        self.freq = self.gain = None; self.bias = 0
        self.set_freq(freq); self.set_gain(gain)
        LIB.rtlsdr_reset_buffer(self.dev)

    def set_freq(self, hz):
        with self.lock:
            r = LIB.rtlsdr_set_center_freq(self.dev, int(hz))
            self.freq = LIB.rtlsdr_get_center_freq(self.dev)
        return r

    def set_gain(self, db):
        """db=None -> tuuneri AGC; muidu lähim toetatud väärtus."""
        with self.lock:
            if db is None:
                LIB.rtlsdr_set_tuner_gain_mode(self.dev, 0)
                self.gain = None
            else:
                g = min(self.gains, key=lambda x: abs(x - db))
                LIB.rtlsdr_set_tuner_gain_mode(self.dev, 1)
                LIB.rtlsdr_set_tuner_gain(self.dev, int(round(g * 10)))
                self.gain = g
        return 0

    def set_bias(self, on):
        with self.lock:
            self.bias = int(on)
            return LIB.rtlsdr_set_bias_tee(self.dev, self.bias)


# ------------------------------------------------------------------ kliendid

class Client:
    def __init__(self, sock, kind, name):
        self.sock, self.kind, self.name = sock, kind, name
        self.q = queue.Queue(CLIENT_QUEUE)
        self.dropped = 0
        self.alive = True
        threading.Thread(target=self.sender, daemon=True).start()

    def push(self, data):
        try:
            self.q.put_nowait(data)
        except queue.Full:
            try: self.q.get_nowait()
            except queue.Empty: pass
            self.dropped += 1
            self.q.put_nowait(data)

    def sender(self):
        try:
            while self.alive:
                try:
                    self.sock.sendall(self.q.get(timeout=1))
                except queue.Empty:
                    pass
        except OSError:
            pass
        self.alive = False
        try: self.sock.close()
        except OSError: pass


class Recorder:
    """AOS/LOS baseband-salvestus (SDR++ Recorderi asendus)."""
    def __init__(self, freq, fs):
        now = dt.datetime.now()
        self.path = ROOT / "recordings" / f"baseband_{freq}Hz_{now:%H-%M-%S_%d-%m-%Y}.wav"
        self.w = wave.open(str(self.path), "wb")
        self.w.setnchannels(2); self.w.setsampwidth(2); self.w.setframerate(fs)
        self.q = queue.Queue(400)
        self.alive = True
        self.t = threading.Thread(target=self.run, daemon=True); self.t.start()

    def run(self):
        while True:
            d = self.q.get()
            if d is None: break
            self.w.writeframes(d)
        self.w.close()

    def stop(self):
        self.alive = False
        self.q.put(None); self.t.join(10)
        return self.path


class Hub:
    def __init__(self, dongle):
        self.d = dongle
        self.clients = []
        self.lock = threading.Lock()
        self.rec = None
        self.mode = ["WFM", "200000"]
        self.blocks = 0
        self.lost = 0

    def add(self, c):
        with self.lock:
            self.clients.append(c)
        log(f"klient {c.kind} {c.name} ühendus ({len(self.clients)} klienti)")

    def on_samples(self, buf, n, _ctx):
        u8 = np.ctypeslib.as_array(buf, shape=(n,))
        raw = u8.tobytes()
        i16 = ((u8.astype(np.float32) - 127.4) * 256).astype(np.int16).tobytes()
        self.blocks += 1
        with self.lock:
            dead = [c for c in self.clients if not c.alive]
            for c in dead:
                self.clients.remove(c); self.lost += c.dropped
                log(f"klient {c.kind} {c.name} lahkus (kadunud plokke {c.dropped})")
            for c in self.clients:
                c.push(raw if c.kind == "rtl_tcp" else i16)
        if self.rec:
            try: self.rec.q.put_nowait(i16)
            except queue.Full: log("HOIATUS: salvestus ei jõua kettale – plokk kadus")

    def status(self):
        with self.lock:
            cl = [{"kind": c.kind, "name": c.name, "queue": c.q.qsize(), "dropped": c.dropped} for c in self.clients]
        return {"freq": self.d.freq, "gain": self.d.gain, "gains": self.d.gains, "fs": self.d.fs, "bias": self.d.bias,
                "mode": self.mode, "blocks": self.blocks, "clients": cl,
                "recording": str(self.rec.path.name) if self.rec else None}


# ------------------------------------------------------------------ serverid

class Server(socketserver.ThreadingTCPServer):
    allow_reuse_address = True
    daemon_threads = True


def make_iq_handler(hub):
    class H(socketserver.BaseRequestHandler):
        def handle(self):
            self.request.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            c = Client(self.request, "iq16", f"{self.client_address[1]}")
            hub.add(c)
            try:
                while c.alive and self.request.recv(1024):     # kliendi saadetu ignoreeritakse; tühi = sulges
                    pass
            except OSError:
                pass
            c.alive = False
    return H


def make_rtltcp_handler(hub):
    class H(socketserver.BaseRequestHandler):
        def handle(self):
            s = self.request
            s.sendall(b"RTL0" + struct.pack(">II", hub.d.tuner, len(hub.d.gains)))
            c = Client(s, "rtl_tcp", f"{self.client_address[1]}")
            hub.add(c)
            buf = b""
            try:
                while c.alive:
                    data = s.recv(64)
                    if not data: break
                    buf += data
                    while len(buf) >= 5:
                        cmd, val = struct.unpack(">BI", buf[:5]); buf = buf[5:]
                        if cmd == 0x01: hub.d.set_freq(val); log(f"rtl_tcp: F {hub.d.freq}")
                        elif cmd == 0x03 and val == 0: hub.d.set_gain(None)
                        elif cmd == 0x04: hub.d.set_gain(val / 10)
                        elif cmd == 0x0d: hub.d.set_gain(hub.d.gains[min(val, len(hub.d.gains) - 1)])
                        elif cmd == 0x0e: hub.d.set_bias(val)
                        # 0x02 sample rate jm eiratakse – kõik kliendid jagavad sama voogu
            except OSError:
                pass
            c.alive = False
    return H


def rig_cmd(hub, line):
    p = line.split()
    if not p: return None
    c = p[0]
    d = hub.d
    if c == "F" and len(p) > 1:
        r = d.set_freq(int(float(p[1])))
        log(f"rigctl: F {d.freq}")
        return f"RPRT {0 if r == 0 else -1}"
    if c == "f": return str(d.freq)
    if c == "M" and len(p) > 1: hub.mode = [p[1], p[2] if len(p) > 2 else "0"]; return "RPRT 0"
    if c == "m": return "\n".join(hub.mode)
    if c == "L" and len(p) > 2 and p[1].upper() == "RFGAIN":
        d.set_gain(None if p[2].lower() in ("auto", "agc", "-1") else float(p[2]))
        log(f"rigctl: gain {d.gain if d.gain is not None else 'AGC'}")
        return "RPRT 0"
    if c == "l" and len(p) > 1 and p[1].upper() == "RFGAIN": return str(d.gain if d.gain is not None else -1)
    if c == "BIAST" and len(p) > 1: return f"RPRT {d.set_bias(int(p[1]))}"
    if c == "AOS":
        if not hub.rec:
            hub.rec = Recorder(d.freq, d.fs); log(f"salvestus algas: {hub.rec.path.name}")
        return "RPRT 0"
    if c == "LOS":
        if hub.rec:
            r, hub.rec = hub.rec, None
            log(f"salvestus lõppes: {r.stop().name}")
        return "RPRT 0"
    if c == "STATUS": return json.dumps(hub.status(), ensure_ascii=False)
    return "RPRT -11"


def make_rig_handler(hub):
    class H(socketserver.StreamRequestHandler):
        def handle(self):
            for raw in self.rfile:
                line = raw.decode(errors="ignore").strip()
                if line == "q": break
                try:
                    out = rig_cmd(hub, line)
                except Exception as e:
                    out = f"RPRT -1 {e}"
                if out is not None:
                    self.wfile.write((out + "\n").encode()); self.wfile.flush()
    return H


# ------------------------------------------------------------------ main

def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--mhz", type=float, default=101.6)
    ap.add_argument("--gain", default="33.8", help="dB või 'auto' (FM pikendatud dipooliga 26.09: 37.2 klipib piiril, 33.8 sama SNR)")
    ap.add_argument("--fs", type=int, default=2400000)
    ap.add_argument("--bind", default="127.0.0.1")
    a = ap.parse_args()
    home = ROOT / "home_mhz.txt"
    mhz = float(home.read_text().strip()) if home.exists() else a.mhz
    gain = None if a.gain == "auto" else float(a.gain)

    d = Dongle(a.fs, int(round(mhz * 1e6)), gain)
    hub = Hub(d)
    log(f"tuuner {d.tuner}, {d.fs} S/s, {d.freq} Hz, gain {d.gain}")
    for port, handler in ((1234, make_iq_handler), (1235, make_rtltcp_handler), (4532, make_rig_handler)):
        srv = Server((a.bind, port), handler(hub))
        threading.Thread(target=srv.serve_forever, daemon=True).start()
    log("kuulan: IQ 1234, rtl_tcp 1235, rigctl 4532")

    stop = {"sig": False}
    def on_sig(*_):
        stop["sig"] = True
        LIB.rtlsdr_cancel_async(d.dev)
    signal.signal(signal.SIGTERM, on_sig); signal.signal(signal.SIGINT, on_sig)

    cb = CB(hub.on_samples)
    r = LIB.rtlsdr_read_async(d.dev, cb, None, 15, BUF_LEN)     # blokeerib kuni cancel või USB viga
    if hub.rec:
        hub.rec.stop()
    LIB.rtlsdr_close(d.dev)
    if not stop["sig"]:
        log(f"read_async lõppes ootamatult ({r}) – USB katkes? väljun, systemd taaskäivitab")
        sys.exit(1)
    log("peatatud")


if __name__ == "__main__":
    main()
