#!/usr/bin/env python3
"""
wsjt_bridge.py — WSJT-X → vushf.dk / oz7z.dk bro
==================================================
Modtager WSJT-X UDP QSO-pakker og videresender dem til serveren
via HTTP POST så loggeren (log2.html / zlog.html) kan hente dem.

Opsætning — skift de to linjer herunder:
    RELAY_URL — URL til wsjt_relay.php på din server
    MY_CALL   — dit callsign (bruges til at identificere din kø på serveren)

WSJT-X opsætning:
    File → Settings → Reporting
    UDP Server address : 127.0.0.1
    UDP Server port    : 2237
    Sæt kryds i "Accept UDP requests"

Brug:
    python wsjt_bridge.py
"""

import socket
import struct
import threading
import json
import sys
import urllib.request
import urllib.error
from http.server import HTTPServer, BaseHTTPRequestHandler

# ── Konfiguration ─────────────────────────────────────────────────────────────
RELAY_URL = 'https://oz7z.dk/wsjt_relay.php'   # ← skift hvis nødvendigt
MY_CALL   = 'OZ1ALS'                            # ← dit callsign

WSJT_UDP_PORT = 2237
HTTP_PORT      = 8237     # lokal HTTP-server (valgfri, bruges ikke ved server-relay)
MAGIC          = 0xADBCCBDA

pending      = []
pending_lock = threading.Lock()


# ── Binær parser ─────────────────────────────────────────────────────────────

class Parser:
    def __init__(self, data):
        self.data = data
        self.pos  = 0

    def u8(self):
        v = struct.unpack_from('>B', self.data, self.pos)[0]; self.pos += 1; return v

    def u32(self):
        v = struct.unpack_from('>I', self.data, self.pos)[0]; self.pos += 4; return v

    def i32(self):
        v = struct.unpack_from('>i', self.data, self.pos)[0]; self.pos += 4; return v

    def i64(self):
        v = struct.unpack_from('>q', self.data, self.pos)[0]; self.pos += 8; return v

    def u64(self):
        v = struct.unpack_from('>Q', self.data, self.pos)[0]; self.pos += 8; return v

    def utf8(self):
        """Qt QByteArray: uint32 length (0xFFFFFFFF=null) + UTF-8 bytes."""
        length = self.u32()
        if length == 0xFFFFFFFF:
            return ''
        s = self.data[self.pos:self.pos + length].decode('utf-8', errors='replace')
        self.pos += length
        return s

    def qdatetime(self):
        """Qt QDateTime → (date_YYMMDD, time_HHMM) strings."""
        jd  = self.i64()    # Julian Day Number
        ms  = self.u32()    # millisekunder siden midnat
        ts  = self.u8()     # timespec: 0=Local 1=UTC 2=OffsetFromUTC 3=TimeZone
        if ts == 2:
            self.i32()      # UTC offset i sekunder (spring over)
        if jd <= 0:
            return '', ''
        # Julian Day → Gregoriansk dato
        l     = jd + 68569
        n     = 4 * l // 146097
        l     = l - (146097 * n + 3) // 4
        i     = 4000 * (l + 1) // 1461001
        l     = l - 1461 * i // 4 + 31
        j     = 80 * l // 2447
        day   = l - 2447 * j // 80
        l     = j // 11
        month = j + 2 - 12 * l
        year  = 100 * (n - 49) + i + l
        h     = (ms // 1000) // 3600
        m     = ((ms // 1000) % 3600) // 60
        return f'{year % 100:02d}{month:02d}{day:02d}', f'{h:02d}{m:02d}'


# ── WSJT-X pakke-parser ───────────────────────────────────────────────────────

MODE_MAP = {
    'FT8':'7', 'FT4':'7', 'JT65':'7', 'JT9':'7',
    'MSK144':'7', 'FST4':'7', 'Q65':'7', 'JS8':'7',
    'SSB':'1', 'USB':'1', 'LSB':'1', 'AM':'1', 'FM':'6', 'CW':'2',
}

# Frekvensgrænser (Hz) → båndbogstav (samme koder som loggeren)
_FREQ_BANDS = [
    (60e6,      'A'),   # 50 MHz
    (80e6,      'B'),   # 70 MHz
    (300e6,     'C'),   # 144 MHz
    (600e6,     'E'),   # 432 MHz
    (1500e6,    'G'),   # 1.3 GHz
    (2500e6,    'I'),   # 2.3 GHz
    (6000e6,    'K'),   # 5.7 GHz
    (float('inf'), 'M'), # 10+ GHz
]

def freq_to_band(hz):
    for limit, letter in _FREQ_BANDS:
        if hz < limit:
            return letter
    return ''

def parse_packet(data):
    """Parser WSJT-X UDP pakke. Returnerer QSO-dict eller None."""
    if len(data) < 12:
        return None
    try:
        p = Parser(data)
        if p.u32() != MAGIC:
            return None
        schema = p.u32()
        ptype  = p.u32()
        _id    = p.utf8()           # stationens id (spring over)

        if ptype != 5:              # Type 5 = QSOLogged
            return None

        date_off, time_off = p.qdatetime()
        call    = p.utf8()          # DX call
        grid    = p.utf8()          # DX grid (Maidenhead)
        freq_hz = p.u64()           # TX frekvens i Hz
        mode    = p.utf8()          # mode (FT8, CW, SSB …)
        rst_snt = p.utf8()          # rapport sendt
        rst_rcv = p.utf8()          # rapport modtaget
        _power  = p.utf8()
        _comm   = p.utf8()
        _name   = p.utf8()
        date_on, time_on = p.qdatetime()

        # Brug DateTimeOn (QSO-start), fald tilbage på DateTimeOff
        date = date_on  or date_off
        time = time_on  or time_off

        if not call:
            return None

        edi_mode = MODE_MAP.get(mode.upper().strip(), '7')

        return {
            'call':    call.upper().strip(),
            'loc':     grid[:6].upper() if grid else '',
            'date':    date,
            'time':    time,
            'mode':    edi_mode,
            'rstSent': rst_snt.strip() or '59',
            'rstRcvd': rst_rcv.strip() or '59',
            '_band':   freq_to_band(freq_hz),
        }
    except Exception as e:
        print(f'[wsjt_bridge] Parse-fejl: {e}')
        return None


# ── Server-relay ─────────────────────────────────────────────────────────────

def relay_qso(qso):
    """POST QSO til wsjt_relay.php på serveren."""
    if not RELAY_URL or not MY_CALL:
        return
    try:
        payload = {**qso, '_mycall': MY_CALL.upper()}
        body = json.dumps(payload).encode('utf-8')
        req  = urllib.request.Request(
            RELAY_URL, data=body,
            headers={'Content-Type': 'application/json'},
            method='POST'
        )
        with urllib.request.urlopen(req, timeout=8) as r:
            resp = r.read().decode()
        print(f'[wsjt_bridge] Relay → server: {resp.strip()}')
    except urllib.error.URLError as e:
        print(f'[wsjt_bridge] Relay fejl: {e.reason}')
    except Exception as e:
        print(f'[wsjt_bridge] Relay fejl: {e}')


# ── UDP-lytter ────────────────────────────────────────────────────────────────

def udp_listen():
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        sock.bind(('', WSJT_UDP_PORT))
    except OSError as e:
        print(f'[wsjt_bridge] Kan ikke åbne UDP port {WSJT_UDP_PORT}: {e}')
        print('              Kører WSJT-X allerede, eller er porten optaget?')
        return
    print(f'[wsjt_bridge] Lytter på UDP port {WSJT_UDP_PORT} (WSJT-X output)')
    while True:
        try:
            data, _addr = sock.recvfrom(4096)
            qso = parse_packet(data)
            if qso:
                with pending_lock:
                    pending.append(qso)
                print(f'[wsjt_bridge] QSO logger: {qso["call"]:12s} '
                      f'{qso["loc"]:6s}  RST {qso["rstSent"]}/{qso["rstRcvd"]}  '
                      f'mode={qso["mode"]}  {qso["date"]} {qso["time"]}')
                threading.Thread(target=relay_qso, args=(qso,), daemon=True).start()
        except Exception as e:
            print(f'[wsjt_bridge] UDP fejl: {e}')


# ── HTTP-server ───────────────────────────────────────────────────────────────

class Handler(BaseHTTPRequestHandler):
    def log_message(self, *_):
        pass        # stille HTTP-log

    def do_OPTIONS(self):
        self.send_response(204)
        self._cors(); self.end_headers()

    def do_GET(self):
        if self.path == '/poll':
            with pending_lock:
                data = list(pending)
                pending.clear()
            body = json.dumps(data).encode('utf-8')
            self.send_response(200)
            self.send_header('Content-Type',   'application/json; charset=utf-8')
            self.send_header('Content-Length', str(len(body)))
            self._cors(); self.end_headers()
            self.wfile.write(body)
        elif self.path == '/ping':
            self.send_response(200)
            self._cors(); self.end_headers()
            self.wfile.write(b'ok')
        else:
            self.send_response(404); self.end_headers()

    def _cors(self):
        self.send_header('Access-Control-Allow-Origin',  '*')
        self.send_header('Access-Control-Allow-Methods', 'GET, OPTIONS')


def http_serve():
    try:
        srv = HTTPServer(('127.0.0.1', HTTP_PORT), Handler)
    except OSError as e:
        print(f'[wsjt_bridge] Kan ikke starte HTTP server på port {HTTP_PORT}: {e}')
        sys.exit(1)
    print(f'[wsjt_bridge] HTTP API klar på http://127.0.0.1:{HTTP_PORT}/poll')
    print( '[wsjt_bridge] Åbn log2.html i browseren og klik [WSJT-X]\n')
    srv.serve_forever()


# ── Start ─────────────────────────────────────────────────────────────────────

if __name__ == '__main__':
    print('wsjt_bridge.py — WSJT-X → server relay')
    if not MY_CALL:
        print('ADVARSEL: Sæt MY_CALL til dit callsign i toppen af dette script!\n')
    else:
        print(f'Callsign : {MY_CALL}')
        print(f'Relay    → {RELAY_URL}')
    print('Stop med Ctrl+C\n')
    threading.Thread(target=udp_listen, daemon=True).start()
    try:
        http_serve()
    except KeyboardInterrupt:
        print('\n[wsjt_bridge] Stoppet.')
