intercept/routes/wefax.py

"""WeFax (Weather Fax) decoder routes.

Provides endpoints for decoding HF weather fax transmissions from
maritime/aviation weather services worldwide.
"""

from __future__ import annotations

import contextlib
import queue

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

import app as app_module
from utils.logging import get_logger
from utils.responses import api_error
from utils.sdr import SDRType
from utils.sse import sse_stream_fanout
from utils.validation import validate_frequency
from utils.wefax import get_wefax_decoder
from utils.wefax_stations import (
    WEFAX_USB_ALIGNMENT_OFFSET_KHZ,
    get_current_broadcasts,
    get_station,
    load_stations,
    resolve_tuning_frequency_khz,
)

logger = get_logger("intercept.wefax")

wefax_bp = Blueprint("wefax", __name__, url_prefix="/wefax")

# SSE progress queue
_wefax_queue: queue.Queue = queue.Queue(maxsize=100)

# Track active SDR device
wefax_active_device: int | None = None
wefax_active_sdr_type: str | None = None


def _progress_callback(data: dict) -> None:
    """Callback to queue progress updates for SSE stream."""
    global wefax_active_device, wefax_active_sdr_type

    try:
        _wefax_queue.put_nowait(data)
    except queue.Full:
        try:
            _wefax_queue.get_nowait()
            _wefax_queue.put_nowait(data)
        except queue.Empty:
            pass

    # Ensure manually claimed SDR devices are always released when a
    # decode session ends on its own (complete/error/stopped).
    if (
        isinstance(data, dict)
        and data.get("type") == "wefax_progress"
        and data.get("status") in ("complete", "error", "stopped")
        and wefax_active_device is not None
    ):
        app_module.release_sdr_device(wefax_active_device, wefax_active_sdr_type or "rtlsdr")
        wefax_active_device = None
        wefax_active_sdr_type = None


@wefax_bp.route("/status")
def get_status():
    """Get WeFax decoder status."""
    decoder = get_wefax_decoder()
    return jsonify(
        {
            "available": True,
            "running": decoder.is_running,
            "image_count": len(decoder.get_images()),
        }
    )


@wefax_bp.route("/start", methods=["POST"])
def start_decoder():
    """Start WeFax decoder.

    JSON body:
        {
            "frequency_khz": 4298,
            "station": "NOJ",
            "device": 0,
            "gain": 40,
            "ioc": 576,
            "lpm": 120,
            "direct_sampling": true,
            "frequency_reference": "auto"  // auto, carrier, or dial
        }
    """
    decoder = get_wefax_decoder()

    if decoder.is_running:
        return jsonify(
            {
                "status": "already_running",
                "message": "WeFax decoder is already running",
            }
        )

    # Clear queue
    while not _wefax_queue.empty():
        try:
            _wefax_queue.get_nowait()
        except queue.Empty:
            break

    data = request.get_json(silent=True) or {}

    # Validate frequency (required)
    frequency_khz = data.get("frequency_khz")
    if frequency_khz is None:
        return api_error("frequency_khz is required", 400)

    try:
        frequency_khz = float(frequency_khz)
        # WeFax operates on HF: 2-30 MHz (2000-30000 kHz)
        freq_mhz = frequency_khz / 1000.0
        validate_frequency(freq_mhz, min_mhz=2.0, max_mhz=30.0)
    except (TypeError, ValueError) as e:
        return api_error(f"Invalid frequency: {e}", 400)

    station = str(data.get("station", "")).strip()
    device_index = data.get("device", 0)
    gain = float(data.get("gain", 40.0))
    ioc = int(data.get("ioc", 576))
    lpm = int(data.get("lpm", 120))
    direct_sampling = bool(data.get("direct_sampling", True))
    frequency_reference = str(data.get("frequency_reference", "auto")).strip().lower()

    sdr_type_str = str(data.get("sdr_type", "rtlsdr")).lower()
    with contextlib.suppress(ValueError):
        SDRType(sdr_type_str)
    if not frequency_reference:
        frequency_reference = "auto"

    try:
        tuned_frequency_khz, resolved_reference, usb_offset_applied = resolve_tuning_frequency_khz(
            listed_frequency_khz=frequency_khz,
            station_callsign=station,
            frequency_reference=frequency_reference,
        )
        tuned_mhz = tuned_frequency_khz / 1000.0
        validate_frequency(tuned_mhz, min_mhz=2.0, max_mhz=30.0)
    except ValueError as e:
        return api_error(f"Invalid frequency settings: {e}", 400)

    # Validate IOC and LPM
    if ioc not in (288, 576):
        return api_error("IOC must be 288 or 576", 400)

    if lpm not in (60, 120):
        return api_error("LPM must be 60 or 120", 400)

    # Claim SDR device
    global wefax_active_device, wefax_active_sdr_type
    device_int = int(device_index)
    error = app_module.claim_sdr_device(device_int, "wefax", sdr_type_str)
    if error:
        return api_error(error, 409, error_type="DEVICE_BUSY")

    # Set callback and start
    decoder.set_callback(_progress_callback)
    success = decoder.start(
        frequency_khz=tuned_frequency_khz,
        station=station,
        device_index=device_int,
        gain=gain,
        ioc=ioc,
        lpm=lpm,
        direct_sampling=direct_sampling,
        sdr_type=sdr_type_str,
    )

    if success:
        wefax_active_device = device_int
        wefax_active_sdr_type = sdr_type_str
        return jsonify(
            {
                "status": "started",
                "frequency_khz": frequency_khz,
                "tuned_frequency_khz": tuned_frequency_khz,
                "frequency_reference": resolved_reference,
                "usb_offset_applied": usb_offset_applied,
                "usb_offset_khz": (WEFAX_USB_ALIGNMENT_OFFSET_KHZ if usb_offset_applied else 0.0),
                "station": station,
                "ioc": ioc,
                "lpm": lpm,
                "device": device_int,
            }
        )
    else:
        app_module.release_sdr_device(device_int, sdr_type_str)
        return api_error("Failed to start decoder", 500)


@wefax_bp.route("/stop", methods=["POST"])
def stop_decoder():
    """Stop WeFax decoder."""
    global wefax_active_device, wefax_active_sdr_type
    decoder = get_wefax_decoder()
    decoder.stop()

    if wefax_active_device is not None:
        app_module.release_sdr_device(wefax_active_device, wefax_active_sdr_type or "rtlsdr")
        wefax_active_device = None
        wefax_active_sdr_type = None

    return jsonify({"status": "stopped"})


@wefax_bp.route("/stream")
def stream_progress():
    """SSE stream of WeFax decode progress."""
    response = Response(
        sse_stream_fanout(
            source_queue=_wefax_queue,
            channel_key="wefax",
            timeout=1.0,
            keepalive_interval=30.0,
        ),
        mimetype="text/event-stream",
    )
    response.headers["Cache-Control"] = "no-cache"
    response.headers["X-Accel-Buffering"] = "no"
    response.headers["Connection"] = "keep-alive"
    return response


@wefax_bp.route("/images")
def list_images():
    """Get list of decoded WeFax images."""
    decoder = get_wefax_decoder()
    images = decoder.get_images()

    limit = request.args.get("limit", type=int)
    if limit and limit > 0:
        images = images[-limit:]

    return jsonify(
        {
            "status": "ok",
            "images": [img.to_dict() for img in images],
            "count": len(images),
        }
    )


@wefax_bp.route("/images/<filename>")
def get_image(filename: str):
    """Get a decoded WeFax image file."""
    decoder = get_wefax_decoder()

    if not filename.replace("_", "").replace("-", "").replace(".", "").isalnum():
        return api_error("Invalid filename", 400)

    if not filename.endswith(".png"):
        return api_error("Only PNG files supported", 400)

    image_path = decoder._output_dir / filename
    if not image_path.exists():
        return api_error("Image not found", 404)

    return send_file(image_path, mimetype="image/png")


@wefax_bp.route("/images/<filename>", methods=["DELETE"])
def delete_image(filename: str):
    """Delete a decoded WeFax image."""
    decoder = get_wefax_decoder()

    if not filename.replace("_", "").replace("-", "").replace(".", "").isalnum():
        return api_error("Invalid filename", 400)

    if not filename.endswith(".png"):
        return api_error("Only PNG files supported", 400)

    if decoder.delete_image(filename):
        return jsonify({"status": "ok"})
    else:
        return api_error("Image not found", 404)


@wefax_bp.route("/images", methods=["DELETE"])
def delete_all_images():
    """Delete all decoded WeFax images."""
    decoder = get_wefax_decoder()
    count = decoder.delete_all_images()
    return jsonify({"status": "ok", "deleted": count})


# ========================
# Auto-Scheduler Endpoints
# ========================


def _scheduler_event_callback(event: dict) -> None:
    """Forward scheduler events to the SSE queue."""
    try:
        _wefax_queue.put_nowait(event)
    except queue.Full:
        try:
            _wefax_queue.get_nowait()
            _wefax_queue.put_nowait(event)
        except queue.Empty:
            pass


@wefax_bp.route("/schedule/enable", methods=["POST"])
def enable_schedule():
    """Enable auto-scheduling of WeFax broadcast captures.

    JSON body:
        {
            "station": "NOJ",
            "frequency_khz": 4298,
            "device": 0,
            "gain": 40,
            "ioc": 576,
            "lpm": 120,
            "direct_sampling": true,
            "frequency_reference": "auto"  // auto, carrier, or dial
        }

    Returns:
        JSON with scheduler status.
    """
    from utils.wefax_scheduler import get_wefax_scheduler

    data = request.get_json(silent=True) or {}

    station = str(data.get("station", "")).strip()
    if not station:
        return api_error("station is required", 400)

    frequency_khz = data.get("frequency_khz")
    if frequency_khz is None:
        return api_error("frequency_khz is required", 400)

    try:
        frequency_khz = float(frequency_khz)
        freq_mhz = frequency_khz / 1000.0
        validate_frequency(freq_mhz, min_mhz=2.0, max_mhz=30.0)
    except (TypeError, ValueError) as e:
        return api_error(f"Invalid frequency: {e}", 400)

    device = int(data.get("device", 0))
    gain = float(data.get("gain", 40.0))
    ioc = int(data.get("ioc", 576))
    lpm = int(data.get("lpm", 120))
    direct_sampling = bool(data.get("direct_sampling", True))
    frequency_reference = str(data.get("frequency_reference", "auto")).strip().lower()
    if not frequency_reference:
        frequency_reference = "auto"

    try:
        tuned_frequency_khz, resolved_reference, usb_offset_applied = resolve_tuning_frequency_khz(
            listed_frequency_khz=frequency_khz,
            station_callsign=station,
            frequency_reference=frequency_reference,
        )
        tuned_mhz = tuned_frequency_khz / 1000.0
        validate_frequency(tuned_mhz, min_mhz=2.0, max_mhz=30.0)
    except ValueError as e:
        return api_error(f"Invalid frequency settings: {e}", 400)

    scheduler = get_wefax_scheduler()
    scheduler.set_callbacks(_progress_callback, _scheduler_event_callback)

    try:
        result = scheduler.enable(
            station=station,
            frequency_khz=tuned_frequency_khz,
            device=device,
            gain=gain,
            ioc=ioc,
            lpm=lpm,
            direct_sampling=direct_sampling,
        )
    except Exception:
        logger.exception("Failed to enable WeFax scheduler")
        return api_error("Failed to enable scheduler", 500)

    return jsonify(
        {
            "status": "ok",
            **result,
            "frequency_khz": frequency_khz,
            "tuned_frequency_khz": tuned_frequency_khz,
            "frequency_reference": resolved_reference,
            "usb_offset_applied": usb_offset_applied,
            "usb_offset_khz": (WEFAX_USB_ALIGNMENT_OFFSET_KHZ if usb_offset_applied else 0.0),
        }
    )


@wefax_bp.route("/schedule/disable", methods=["POST"])
def disable_schedule():
    """Disable auto-scheduling."""
    from utils.wefax_scheduler import get_wefax_scheduler

    scheduler = get_wefax_scheduler()
    result = scheduler.disable()
    return jsonify(result)


@wefax_bp.route("/schedule/status")
def schedule_status():
    """Get current scheduler state."""
    from utils.wefax_scheduler import get_wefax_scheduler

    scheduler = get_wefax_scheduler()
    return jsonify(scheduler.get_status())


@wefax_bp.route("/schedule/broadcasts")
def schedule_broadcasts():
    """List scheduled broadcasts."""
    from utils.wefax_scheduler import get_wefax_scheduler

    scheduler = get_wefax_scheduler()
    broadcasts = scheduler.get_broadcasts()
    return jsonify(
        {
            "status": "ok",
            "broadcasts": broadcasts,
            "count": len(broadcasts),
        }
    )


@wefax_bp.route("/schedule/skip/<broadcast_id>", methods=["POST"])
def skip_broadcast(broadcast_id: str):
    """Skip a scheduled broadcast."""
    from utils.wefax_scheduler import get_wefax_scheduler

    if not broadcast_id.replace("_", "").replace("-", "").isalnum():
        return api_error("Invalid broadcast ID", 400)

    scheduler = get_wefax_scheduler()
    if scheduler.skip_broadcast(broadcast_id):
        return jsonify({"status": "skipped", "broadcast_id": broadcast_id})
    else:
        return api_error("Broadcast not found or already processed", 404)


@wefax_bp.route("/stations")
def list_stations():
    """Get all WeFax stations from the database."""
    stations = load_stations()
    return jsonify(
        {
            "status": "ok",
            "stations": stations,
            "count": len(stations),
        }
    )


@wefax_bp.route("/stations/<callsign>")
def station_detail(callsign: str):
    """Get station detail including current schedule info."""
    station = get_station(callsign)
    if not station:
        return api_error(f"Station {callsign} not found", 404)

    current = get_current_broadcasts(callsign)

    return jsonify(
        {
            "status": "ok",
            "station": station,
            "current_broadcasts": current,
        }
    )