intercept/routes/websdr.py

"""HF/Shortwave WebSDR Integration - KiwiSDR network access."""

from __future__ import annotations

import json
import math
import queue
import re
import struct
import threading
import time

from flask import Blueprint, Flask, Response, jsonify, request

from utils.responses import api_error, api_success

try:
    from flask_sock import Sock

    WEBSOCKET_AVAILABLE = True
except ImportError:
    WEBSOCKET_AVAILABLE = False

import contextlib

from utils.kiwisdr import KIWI_SAMPLE_RATE, VALID_MODES, KiwiSDRClient, parse_host_port
from utils.logging import get_logger

logger = get_logger("intercept.websdr")

websdr_bp = Blueprint("websdr", __name__, url_prefix="/websdr")

# ============================================
# RECEIVER CACHE
# ============================================

_receiver_cache: list[dict] = []
_cache_lock = threading.Lock()
_cache_timestamp: float = 0
CACHE_TTL = 3600  # 1 hour


def _parse_gps_coord(coord_str: str) -> float | None:
    """Parse a GPS coordinate string like '51.5074' or '(-33.87)' into a float."""
    if not coord_str:
        return None
    # Remove parentheses and whitespace
    cleaned = coord_str.strip().strip("()").strip()
    try:
        return float(cleaned)
    except (ValueError, TypeError):
        return None


def _haversine(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
    """Calculate distance in km between two GPS coordinates."""
    R = 6371  # Earth radius in km
    dlat = math.radians(lat2 - lat1)
    dlon = math.radians(lon2 - lon1)
    a = math.sin(dlat / 2) ** 2 + math.cos(math.radians(lat1)) * math.cos(math.radians(lat2)) * math.sin(dlon / 2) ** 2
    c = 2 * math.asin(math.sqrt(a))
    return R * c


KIWI_DATA_URLS = [
    "https://rx.skywavelinux.com/kiwisdr_com.js",
    "http://rx.linkfanel.net/kiwisdr_com.js",
]


def _fetch_kiwi_receivers() -> list[dict]:
    """Fetch the KiwiSDR receiver list from the public directory."""
    import json
    import urllib.request

    receivers = []
    raw = None

    # Try each data source until one works
    for data_url in KIWI_DATA_URLS:
        try:
            req = urllib.request.Request(
                data_url,
                headers={
                    "User-Agent": "INTERCEPT-SIGINT/1.0",
                },
            )
            with urllib.request.urlopen(req, timeout=20) as resp:
                raw = resp.read().decode("utf-8", errors="replace")
            if raw and len(raw) > 100:
                logger.info(f"Fetched KiwiSDR data from {data_url}")
                break
            raw = None
        except Exception as e:
            logger.warning(f"Failed to fetch from {data_url}: {e}")
            continue

    if not raw:
        logger.error("All KiwiSDR data sources failed")
        return receivers

    # The JS file contains: var kiwisdr_com = [ {...}, {...}, ... ];
    # Extract the JSON array
    match = re.search(r"var\s+kiwisdr_com\s*=\s*(\[.*\])\s*;?", raw, re.DOTALL)
    if not match:
        # Try bare array
        match = re.search(r"(\[\s*\{.*\}\s*\])", raw, re.DOTALL)
        if not match:
            logger.warning("Could not find receiver array in KiwiSDR data")
            return receivers

    arr_str = match.group(1)

    # Parse JSON
    try:
        raw_list = json.loads(arr_str)
    except json.JSONDecodeError:
        # Fix common JS → JSON issues (trailing commas)
        fixed = re.sub(r",\s*}", "}", arr_str)
        fixed = re.sub(r",\s*]", "]", fixed)
        try:
            raw_list = json.loads(fixed)
        except json.JSONDecodeError:
            logger.error("Failed to parse KiwiSDR JSON")
            return receivers

    for entry in raw_list:
        if not isinstance(entry, dict):
            continue

        # Skip offline receivers
        if entry.get("offline") == "yes" or entry.get("status") != "active":
            continue

        name = entry.get("name", "Unknown")
        url = entry.get("url", "")
        gps = entry.get("gps", "")
        antenna = entry.get("antenna", "")
        location = entry.get("loc", "")

        # Parse users (strings in actual data)
        try:
            users = int(entry.get("users", 0))
        except (ValueError, TypeError):
            users = 0
        try:
            users_max = int(entry.get("users_max", 4))
        except (ValueError, TypeError):
            users_max = 4

        # Parse bands field: "0-30000000" (Hz) → freq_lo/freq_hi in kHz
        bands_str = entry.get("bands", "0-30000000")
        freq_lo = 0
        freq_hi = 30000
        if bands_str and "-" in str(bands_str):
            try:
                parts = str(bands_str).split("-")
                freq_lo = int(parts[0]) / 1000  # Hz to kHz
                freq_hi = int(parts[1]) / 1000  # Hz to kHz
            except (ValueError, IndexError):
                pass

        # Parse GPS: "(51.317266, -2.950479)" format
        lat, lon = None, None
        if gps:
            parts = str(gps).replace("(", "").replace(")", "").split(",")
            if len(parts) >= 2:
                lat = _parse_gps_coord(parts[0])
                lon = _parse_gps_coord(parts[1])

        if not url:
            continue

        # Ensure URL has protocol
        if not url.startswith("http"):
            url = "http://" + url

        receivers.append(
            {
                "name": name,
                "url": url.rstrip("/"),
                "lat": lat,
                "lon": lon,
                "location": location,
                "users": users,
                "users_max": users_max,
                "antenna": antenna,
                "bands": bands_str,
                "freq_lo": freq_lo,
                "freq_hi": freq_hi,
                "available": users < users_max,
            }
        )

    return receivers


def get_receivers(force_refresh: bool = False) -> list[dict]:
    """Get cached receiver list, refreshing if stale."""
    global _receiver_cache, _cache_timestamp

    with _cache_lock:
        now = time.time()
        if force_refresh or not _receiver_cache or (now - _cache_timestamp) > CACHE_TTL:
            logger.info("Refreshing KiwiSDR receiver list...")
            _receiver_cache = _fetch_kiwi_receivers()
            _cache_timestamp = now
            logger.info(f"Loaded {len(_receiver_cache)} KiwiSDR receivers")

    return _receiver_cache


# ============================================
# API ENDPOINTS
# ============================================


@websdr_bp.route("/receivers")
def list_receivers() -> Response:
    """List KiwiSDR receivers, with optional filters."""
    freq_khz = request.args.get("freq_khz", type=float)
    available = request.args.get("available", type=str)
    refresh = request.args.get("refresh", type=str)

    receivers = get_receivers(force_refresh=(refresh == "true"))

    filtered = receivers
    if available == "true":
        filtered = [r for r in filtered if r.get("available", True)]

    if freq_khz is not None:
        filtered = [r for r in filtered if r.get("freq_lo", 0) <= freq_khz <= r.get("freq_hi", 30000)]

    return api_success(
        data={
            "receivers": filtered[:100],
            "total": len(filtered),
            "cached_total": len(receivers),
        }
    )


@websdr_bp.route("/receivers/nearest")
def nearest_receivers() -> Response:
    """Find receivers nearest to a given location."""
    lat = request.args.get("lat", type=float)
    lon = request.args.get("lon", type=float)
    freq_khz = request.args.get("freq_khz", type=float)

    if lat is None or lon is None:
        return api_error("lat and lon are required", 400)

    receivers = get_receivers()

    # Filter by frequency if specified
    if freq_khz is not None:
        receivers = [r for r in receivers if r.get("freq_lo", 0) <= freq_khz <= r.get("freq_hi", 30000)]

    # Calculate distances and sort
    with_distance = []
    for r in receivers:
        if r.get("lat") is not None and r.get("lon") is not None:
            dist = _haversine(lat, lon, r["lat"], r["lon"])
            entry = dict(r)
            entry["distance_km"] = round(dist, 1)
            with_distance.append(entry)

    with_distance.sort(key=lambda x: x["distance_km"])

    return api_success(data={"receivers": with_distance[:10]})


@websdr_bp.route("/spy-station/<station_id>/receivers")
def spy_station_receivers(station_id: str) -> Response:
    """Find receivers that can tune to a spy station's frequency."""
    try:
        from routes.spy_stations import STATIONS
    except ImportError:
        return api_error("Spy stations module not available", 503)

    # Find the station
    station = None
    for s in STATIONS:
        if s.get("id") == station_id:
            station = s
            break

    if not station:
        return api_error("Station not found", 404)

    # Get primary frequency
    freq_khz = None
    for f in station.get("frequencies", []):
        if f.get("primary"):
            freq_khz = f.get("freq_khz")
            break
    if freq_khz is None and station.get("frequencies"):
        freq_khz = station["frequencies"][0].get("freq_khz")

    if freq_khz is None:
        return api_error("No frequency found for station", 404)

    receivers = get_receivers()

    # Filter receivers that cover this frequency and are available
    matching = [
        r for r in receivers if r.get("freq_lo", 0) <= freq_khz <= r.get("freq_hi", 30000) and r.get("available", True)
    ]

    return api_success(
        data={
            "station": {
                "id": station["id"],
                "name": station.get("name", ""),
                "nickname": station.get("nickname", ""),
                "freq_khz": freq_khz,
                "mode": station.get("mode", "USB"),
            },
            "receivers": matching[:20],
            "total": len(matching),
        }
    )


@websdr_bp.route("/status")
def websdr_status() -> Response:
    """Get WebSDR connection and cache status."""
    return jsonify(
        {
            "status": "ok",
            "cached_receivers": len(_receiver_cache),
            "cache_age_seconds": round(time.time() - _cache_timestamp, 0) if _cache_timestamp > 0 else None,
            "cache_ttl": CACHE_TTL,
            "audio_connected": _kiwi_client is not None and _kiwi_client.connected if _kiwi_client else False,
        }
    )


# ============================================
# KIWISDR AUDIO PROXY
# ============================================

_kiwi_client: KiwiSDRClient | None = None
_kiwi_lock = threading.Lock()
_kiwi_audio_queue: queue.Queue = queue.Queue(maxsize=200)


def _disconnect_kiwi() -> None:
    """Disconnect active KiwiSDR client."""
    global _kiwi_client
    with _kiwi_lock:
        if _kiwi_client:
            _kiwi_client.disconnect()
            _kiwi_client = None
    # Drain audio queue
    while not _kiwi_audio_queue.empty():
        try:
            _kiwi_audio_queue.get_nowait()
        except queue.Empty:
            break


def _handle_kiwi_command(ws, cmd: str, data: dict) -> None:
    """Handle a command from the browser client."""
    global _kiwi_client

    if cmd == "connect":
        receiver_url = data.get("url", "")
        host = data.get("host", "")
        port = int(data.get("port", 8073))
        freq_khz = float(data.get("freq_khz", 7000))
        mode = data.get("mode", "am").lower()
        password = data.get("password", "")

        # Parse host/port from URL if provided
        if receiver_url and not host:
            host, port = parse_host_port(receiver_url)

        if mode not in VALID_MODES:
            ws.send(json.dumps({"type": "error", "message": f"Invalid mode: {mode}"}))
            return

        if not host or ";" in host or "&" in host or "|" in host:
            ws.send(json.dumps({"type": "error", "message": "Invalid host"}))
            return

        _disconnect_kiwi()

        def on_audio(pcm_bytes, smeter):
            # Package: 2 bytes smeter (big-endian int16) + PCM data
            header = struct.pack(">h", smeter)
            try:
                _kiwi_audio_queue.put_nowait(header + pcm_bytes)
            except queue.Full:
                with contextlib.suppress(queue.Empty):
                    _kiwi_audio_queue.get_nowait()
                with contextlib.suppress(queue.Full):
                    _kiwi_audio_queue.put_nowait(header + pcm_bytes)

        def on_error(msg):
            with contextlib.suppress(Exception):
                ws.send(json.dumps({"type": "error", "message": msg}))

        def on_disconnect():
            with contextlib.suppress(Exception):
                ws.send(json.dumps({"type": "disconnected"}))

        with _kiwi_lock:
            _kiwi_client = KiwiSDRClient(
                host=host,
                port=port,
                on_audio=on_audio,
                on_error=on_error,
                on_disconnect=on_disconnect,
                password=password,
            )
            success = _kiwi_client.connect(freq_khz, mode)

        if success:
            ws.send(
                json.dumps(
                    {
                        "type": "connected",
                        "host": host,
                        "port": port,
                        "freq_khz": freq_khz,
                        "mode": mode,
                        "sample_rate": KIWI_SAMPLE_RATE,
                    }
                )
            )
        else:
            ws.send(json.dumps({"type": "error", "message": "Connection to KiwiSDR failed"}))
            _disconnect_kiwi()

    elif cmd == "tune":
        freq_khz = float(data.get("freq_khz", 0))
        mode = data.get("mode", "").lower() or None

        with _kiwi_lock:
            if _kiwi_client and _kiwi_client.connected:
                success = _kiwi_client.tune(freq_khz, mode or _kiwi_client.mode)
                if success:
                    ws.send(
                        json.dumps(
                            {
                                "type": "tuned",
                                "freq_khz": freq_khz,
                                "mode": mode or _kiwi_client.mode,
                            }
                        )
                    )
                else:
                    ws.send(json.dumps({"type": "error", "message": "Retune failed"}))
            else:
                ws.send(json.dumps({"type": "error", "message": "Not connected"}))

    elif cmd == "disconnect":
        _disconnect_kiwi()
        ws.send(json.dumps({"type": "disconnected"}))


def init_websdr_audio(app: Flask) -> None:
    """Initialize WebSocket audio proxy for KiwiSDR. Called from app.py."""
    if not WEBSOCKET_AVAILABLE:
        logger.warning("flask-sock not installed, KiwiSDR audio proxy disabled")
        return

    sock = Sock(app)

    @sock.route("/ws/kiwi-audio")
    def kiwi_audio_stream(ws):
        """WebSocket endpoint: proxy audio between browser and KiwiSDR."""
        logger.info("KiwiSDR audio client connected")

        try:
            while True:
                # Check for commands from browser
                try:
                    msg = ws.receive(timeout=0.005)
                    if msg:
                        data = json.loads(msg)
                        cmd = data.get("cmd", "")
                        _handle_kiwi_command(ws, cmd, data)
                except TimeoutError:
                    pass
                except Exception as e:
                    if "closed" in str(e).lower():
                        break
                    if "timed out" not in str(e).lower():
                        logger.error(f"KiwiSDR WS receive error: {e}")

                # Forward audio from KiwiSDR to browser
                try:
                    audio_data = _kiwi_audio_queue.get_nowait()
                    ws.send(audio_data)
                except queue.Empty:
                    time.sleep(0.005)

        except Exception as e:
            logger.info(f"KiwiSDR WS closed: {e}")
        finally:
            _disconnect_kiwi()
            logger.info("KiwiSDR audio client disconnected")