intercept/routes/sstv_general.py

"""General SSTV (Slow-Scan Television) decoder routes.

Provides endpoints for decoding terrestrial SSTV images on common HF/VHF/UHF
frequencies used by amateur radio operators worldwide.
"""

from __future__ import annotations

import contextlib
import queue
from pathlib import Path

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

import app as app_module
from utils.event_pipeline import process_event
from utils.logging import get_logger
from utils.responses import api_error
from utils.sse import sse_stream_fanout
from utils.sstv import (
    get_general_sstv_decoder,
)

logger = get_logger('intercept.sstv_general')

sstv_general_bp = Blueprint('sstv_general', __name__, url_prefix='/sstv-general')

# Queue for SSE progress streaming
_sstv_general_queue: queue.Queue = queue.Queue(maxsize=100)

# Track which device is being used
_sstv_general_active_device: int | None = None
_sstv_general_active_sdr_type: str = 'rtlsdr'

# Predefined SSTV frequencies
SSTV_FREQUENCIES = [
    {'band': '80 m', 'frequency': 3.845, 'modulation': 'lsb', 'notes': 'Common US SSTV calling frequency', 'type': 'Terrestrial HF'},
    {'band': '80 m', 'frequency': 3.730, 'modulation': 'lsb', 'notes': 'Europe primary (analog/digital variants)', 'type': 'Terrestrial HF'},
    {'band': '40 m', 'frequency': 7.171, 'modulation': 'lsb', 'notes': 'Common international/US/EU SSTV activity', 'type': 'Terrestrial HF'},
    {'band': '40 m', 'frequency': 7.040, 'modulation': 'lsb', 'notes': 'Alternative US/Europe calling', 'type': 'Terrestrial HF'},
    {'band': '30 m', 'frequency': 10.132, 'modulation': 'usb', 'notes': 'Narrowband SSTV (e.g., MP73-N digital)', 'type': 'Terrestrial HF'},
    {'band': '20 m', 'frequency': 14.230, 'modulation': 'usb', 'notes': 'Most popular international SSTV frequency', 'type': 'Terrestrial HF'},
    {'band': '20 m', 'frequency': 14.233, 'modulation': 'usb', 'notes': 'Digital SSTV calling / alternative activity', 'type': 'Terrestrial HF'},
    {'band': '20 m', 'frequency': 14.240, 'modulation': 'usb', 'notes': 'Europe alternative', 'type': 'Terrestrial HF'},
    {'band': '15 m', 'frequency': 21.340, 'modulation': 'usb', 'notes': 'International calling frequency', 'type': 'Terrestrial HF'},
    {'band': '10 m', 'frequency': 28.680, 'modulation': 'usb', 'notes': 'International calling frequency', 'type': 'Terrestrial HF'},
    {'band': '6 m', 'frequency': 50.950, 'modulation': 'usb', 'notes': 'SSTV calling (less common)', 'type': 'Terrestrial VHF'},
    {'band': '2 m', 'frequency': 145.500, 'modulation': 'fm', 'notes': 'Australia/common simplex (FM sometimes used)', 'type': 'Terrestrial VHF'},
    {'band': '70 cm', 'frequency': 433.775, 'modulation': 'fm', 'notes': 'Australia/common simplex', 'type': 'Terrestrial UHF'},
]

# Build a lookup for auto-detecting modulation from frequency
_FREQ_MODULATION_MAP = {entry['frequency']: entry['modulation'] for entry in SSTV_FREQUENCIES}


def _progress_callback(data: dict) -> None:
    """Callback to queue progress/scope updates for SSE stream."""
    try:
        _sstv_general_queue.put_nowait(data)
    except queue.Full:
        try:
            _sstv_general_queue.get_nowait()
            _sstv_general_queue.put_nowait(data)
        except queue.Empty:
            pass


@sstv_general_bp.route('/frequencies')
def get_frequencies():
    """Return the predefined SSTV frequency table."""
    return jsonify({
        'status': 'ok',
        'frequencies': SSTV_FREQUENCIES,
    })


@sstv_general_bp.route('/status')
def get_status():
    """Get general SSTV decoder status."""
    decoder = get_general_sstv_decoder()

    return jsonify({
        'available': decoder.decoder_available is not None,
        'decoder': decoder.decoder_available,
        'running': decoder.is_running,
        'image_count': len(decoder.get_images()),
    })


@sstv_general_bp.route('/start', methods=['POST'])
def start_decoder():
    """
    Start general SSTV decoder.

    JSON body:
        {
            "frequency": 14.230,     // Frequency in MHz (required)
            "modulation": "usb",     // fm, usb, or lsb (auto-detected from frequency table if omitted)
            "device": 0              // RTL-SDR device index
        }
    """
    decoder = get_general_sstv_decoder()

    if decoder.decoder_available is None:
        return api_error('SSTV decoder not available. Install numpy and Pillow: pip install numpy Pillow', 400)

    if decoder.is_running:
        return jsonify({
            'status': 'already_running',
        })

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

    data = request.get_json(silent=True) or {}
    sdr_type_str = data.get('sdr_type', 'rtlsdr')

    if sdr_type_str != 'rtlsdr':
        return api_error(f'{sdr_type_str.replace("_", " ").title()} is not yet supported for this mode. Please use an RTL-SDR device.', 400)

    frequency = data.get('frequency')
    modulation = data.get('modulation')
    device_index = data.get('device', 0)

    # Validate frequency
    if frequency is None:
        return api_error('Frequency is required', 400)

    try:
        frequency = float(frequency)
        if not (1 <= frequency <= 500):
            return api_error('Frequency must be between 1-500 MHz (HF requires upconverter for RTL-SDR)', 400)
    except (TypeError, ValueError):
        return api_error('Invalid frequency', 400)

    # Auto-detect modulation from frequency table if not specified
    if not modulation:
        modulation = _FREQ_MODULATION_MAP.get(frequency, 'usb')

    # Validate modulation
    if modulation not in ('fm', 'usb', 'lsb'):
        return api_error('Modulation must be fm, usb, or lsb', 400)

    # Claim SDR device
    global _sstv_general_active_device, _sstv_general_active_sdr_type
    device_int = int(device_index)
    error = app_module.claim_sdr_device(device_int, 'sstv_general', 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=frequency,
        device_index=device_index,
        modulation=modulation,
    )

    if success:
        _sstv_general_active_device = device_int
        _sstv_general_active_sdr_type = sdr_type_str
        return jsonify({
            'status': 'started',
            'frequency': frequency,
            'modulation': modulation,
            'device': device_index,
        })
    else:
        app_module.release_sdr_device(device_int, sdr_type_str)
        return api_error('Failed to start decoder', 500)


@sstv_general_bp.route('/stop', methods=['POST'])
def stop_decoder():
    """Stop general SSTV decoder."""
    global _sstv_general_active_device, _sstv_general_active_sdr_type
    decoder = get_general_sstv_decoder()
    decoder.stop()

    if _sstv_general_active_device is not None:
        app_module.release_sdr_device(_sstv_general_active_device, _sstv_general_active_sdr_type)
        _sstv_general_active_device = None

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


@sstv_general_bp.route('/images')
def list_images():
    """Get list of decoded SSTV images."""
    decoder = get_general_sstv_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),
    })


@sstv_general_bp.route('/images/<filename>')
def get_image(filename: str):
    """Get a decoded SSTV image file."""
    decoder = get_general_sstv_decoder()

    # Security: only allow alphanumeric filenames with .png extension
    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')


@sstv_general_bp.route('/images/<filename>/download')
def download_image(filename: str):
    """Download a decoded SSTV image file."""
    decoder = get_general_sstv_decoder()

    # Security: only allow alphanumeric filenames with .png extension
    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', as_attachment=True, download_name=filename)


@sstv_general_bp.route('/images/<filename>', methods=['DELETE'])
def delete_image(filename: str):
    """Delete a decoded SSTV image."""
    decoder = get_general_sstv_decoder()

    # Security: only allow alphanumeric filenames with .png extension
    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)


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


@sstv_general_bp.route('/stream')
def stream_progress():
    """SSE stream of SSTV decode progress."""
    def _on_msg(msg: dict[str, Any]) -> None:
        process_event('sstv_general', msg, msg.get('type'))

    response = Response(
        sse_stream_fanout(
            source_queue=_sstv_general_queue,
            channel_key='sstv_general',
            timeout=1.0,
            keepalive_interval=30.0,
            on_message=_on_msg,
        ),
        mimetype='text/event-stream',
    )
    response.headers['Cache-Control'] = 'no-cache'
    response.headers['X-Accel-Buffering'] = 'no'
    response.headers['Connection'] = 'keep-alive'
    return response


@sstv_general_bp.route('/decode-file', methods=['POST'])
def decode_file():
    """Decode SSTV from an uploaded audio file."""
    if 'audio' not in request.files:
        return api_error('No audio file provided', 400)

    audio_file = request.files['audio']

    if not audio_file.filename:
        return api_error('No file selected', 400)

    import tempfile
    with tempfile.NamedTemporaryFile(suffix='.wav', delete=False) as tmp:
        audio_file.save(tmp.name)
        tmp_path = tmp.name

    try:
        decoder = get_general_sstv_decoder()
        images = decoder.decode_file(tmp_path)

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

    except Exception as e:
        logger.error(f"Error decoding file: {e}")
        return api_error(str(e), 500)

    finally:
        with contextlib.suppress(Exception):
            Path(tmp_path).unlink()