intercept/utils/ground_station/meteor_backend.py

"""Meteor LRPT offline decode backend for ground-station observations."""

from __future__ import annotations

import json
import threading
import time
from datetime import datetime, timezone
from pathlib import Path

from utils.logging import get_logger
from utils.weather_sat import WeatherSatDecoder

logger = get_logger("intercept.ground_station.meteor_backend")

OUTPUT_ROOT = Path("instance/ground_station/weather_outputs")
DECODE_TIMEOUT_SECONDS = 30 * 60

_NORAD_TO_SAT_KEY = {
    57166: "METEOR-M2-3",
    59051: "METEOR-M2-4",
}


def resolve_meteor_satellite_key(norad_id: int, satellite_name: str) -> str | None:
    if norad_id in _NORAD_TO_SAT_KEY:
        return _NORAD_TO_SAT_KEY[norad_id]

    upper = str(satellite_name or "").upper()
    if "M2-4" in upper:
        return "METEOR-M2-4"
    if "M2-3" in upper or "METEOR" in upper:
        return "METEOR-M2-3"
    return None


def launch_meteor_decode(
    *,
    obs_db_id: int | None,
    norad_id: int,
    satellite_name: str,
    sample_rate: int,
    data_path: Path,
    emit_event,
    register_output,
) -> None:
    """Run Meteor LRPT offline decode in a background thread."""
    decode_job_id = _create_decode_job(
        observation_id=obs_db_id,
        norad_id=norad_id,
        backend="meteor_lrpt",
        input_path=data_path,
    )
    emit_event(
        {
            "type": "weather_decode_queued",
            "decode_job_id": decode_job_id,
            "norad_id": norad_id,
            "satellite": satellite_name,
            "backend": "meteor_lrpt",
            "input_path": str(data_path),
        }
    )
    t = threading.Thread(
        target=_run_decode,
        kwargs={
            "decode_job_id": decode_job_id,
            "obs_db_id": obs_db_id,
            "norad_id": norad_id,
            "satellite_name": satellite_name,
            "sample_rate": sample_rate,
            "data_path": data_path,
            "emit_event": emit_event,
            "register_output": register_output,
        },
        daemon=True,
        name=f"gs-meteor-decode-{norad_id}",
    )
    t.start()


def _run_decode(
    *,
    decode_job_id: int | None,
    obs_db_id: int | None,
    norad_id: int,
    satellite_name: str,
    sample_rate: int,
    data_path: Path,
    emit_event,
    register_output,
) -> None:
    latest_status: dict[str, str | int | None] = {
        "message": None,
        "status": None,
        "phase": None,
    }
    sat_key = resolve_meteor_satellite_key(norad_id, satellite_name)
    if not sat_key:
        _update_decode_job(
            decode_job_id,
            status="failed",
            error_message="No Meteor satellite mapping is available for this observation.",
            details={"reason": "unknown_satellite_mapping"},
            completed=True,
        )
        emit_event(
            {
                "type": "weather_decode_failed",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                "message": "No Meteor satellite mapping is available for this observation.",
            }
        )
        return

    output_dir = OUTPUT_ROOT / f"{norad_id}_{int(time.time())}"
    decoder = WeatherSatDecoder(output_dir=output_dir)
    if decoder.decoder_available is None:
        _update_decode_job(
            decode_job_id,
            status="failed",
            error_message="SatDump backend is not available for Meteor LRPT decode.",
            details={"reason": "backend_unavailable", "output_dir": str(output_dir)},
            completed=True,
        )
        emit_event(
            {
                "type": "weather_decode_failed",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                "message": "SatDump backend is not available for Meteor LRPT decode.",
            }
        )
        return

    def _progress_cb(progress):
        latest_status["message"] = progress.message or latest_status.get("message")
        latest_status["status"] = progress.status
        latest_status["phase"] = progress.capture_phase or latest_status.get("phase")
        progress_event = progress.to_dict()
        progress_event.pop("type", None)
        emit_event(
            {
                "type": "weather_decode_progress",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                **progress_event,
            }
        )

    decoder.set_callback(_progress_cb)
    _update_decode_job(
        decode_job_id,
        status="decoding",
        output_dir=output_dir,
        details={
            "sample_rate": sample_rate,
            "input_path": str(data_path),
            "satellite": satellite_name,
        },
        started=True,
    )
    emit_event(
        {
            "type": "weather_decode_started",
            "decode_job_id": decode_job_id,
            "norad_id": norad_id,
            "satellite": satellite_name,
            "backend": "meteor_lrpt",
            "input_path": str(data_path),
        }
    )

    ok, error = decoder.start_from_file(
        satellite=sat_key,
        input_file=data_path,
        sample_rate=sample_rate,
    )
    if not ok:
        details = _build_failure_details(
            data_path=data_path,
            sample_rate=sample_rate,
            decoder=decoder,
            latest_status=latest_status,
        )
        emit_event(
            {
                "type": "weather_decode_failed",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                "message": error or details["message"],
                "failure_reason": details["reason"],
                "details": details,
            }
        )
        _update_decode_job(
            decode_job_id,
            status="failed",
            error_message=error or details["message"],
            details=details,
            completed=True,
        )
        return

    started = time.time()
    while decoder.is_running and (time.time() - started) < DECODE_TIMEOUT_SECONDS:
        time.sleep(1.0)

    if decoder.is_running:
        decoder.stop()
        details = _build_failure_details(
            data_path=data_path,
            sample_rate=sample_rate,
            decoder=decoder,
            latest_status=latest_status,
            override_reason="timeout",
            override_message="Meteor decode timed out.",
        )
        emit_event(
            {
                "type": "weather_decode_failed",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                "message": details["message"],
                "failure_reason": details["reason"],
                "details": details,
            }
        )
        _update_decode_job(
            decode_job_id,
            status="failed",
            error_message=details["message"],
            details=details,
            completed=True,
        )
        return

    images = decoder.get_images()
    if not images:
        details = _build_failure_details(
            data_path=data_path,
            sample_rate=sample_rate,
            decoder=decoder,
            latest_status=latest_status,
        )
        emit_event(
            {
                "type": "weather_decode_failed",
                "decode_job_id": decode_job_id,
                "norad_id": norad_id,
                "satellite": satellite_name,
                "backend": "meteor_lrpt",
                "message": details["message"],
                "failure_reason": details["reason"],
                "details": details,
            }
        )
        _update_decode_job(
            decode_job_id,
            status="failed",
            error_message=details["message"],
            details=details,
            completed=True,
        )
        return

    outputs = []
    for image in images:
        metadata = {
            "satellite": image.satellite,
            "mode": image.mode,
            "frequency": image.frequency,
            "product": image.product,
            "timestamp": image.timestamp.isoformat(),
            "size_bytes": image.size_bytes,
        }
        output_id = register_output(
            observation_id=obs_db_id,
            norad_id=norad_id,
            output_type="image",
            backend="meteor_lrpt",
            file_path=image.path,
            preview_path=image.path,
            metadata=metadata,
        )
        outputs.append(
            {
                "id": output_id,
                "file_path": str(image.path),
                "filename": image.filename,
                "product": image.product,
            }
        )

    completion_details = {
        "sample_rate": sample_rate,
        "input_path": str(data_path),
        "output_dir": str(output_dir),
        "output_count": len(outputs),
    }
    _update_decode_job(
        decode_job_id,
        status="complete",
        details=completion_details,
        completed=True,
    )

    emit_event(
        {
            "type": "weather_decode_complete",
            "decode_job_id": decode_job_id,
            "norad_id": norad_id,
            "satellite": satellite_name,
            "backend": "meteor_lrpt",
            "outputs": outputs,
        }
    )


def _build_failure_details(
    *,
    data_path: Path,
    sample_rate: int,
    decoder: WeatherSatDecoder,
    latest_status: dict[str, str | int | None],
    override_reason: str | None = None,
    override_message: str | None = None,
) -> dict[str, str | int | None]:
    file_size = data_path.stat().st_size if data_path.exists() else 0
    status = decoder.get_status()
    last_error = str(status.get("last_error") or latest_status.get("message") or "").strip()
    return_code = status.get("last_returncode")

    if override_reason:
        reason = override_reason
    elif sample_rate < 200_000:
        reason = "sample_rate_too_low"
    elif not data_path.exists():
        reason = "missing_recording"
    elif file_size < 5_000_000:
        reason = "recording_too_small"
    elif return_code not in (None, 0):
        reason = "satdump_failed"
    elif "samplerate" in last_error.lower() or "sample rate" in last_error.lower():
        reason = "invalid_sample_rate"
    elif "not found" in last_error.lower():
        reason = "input_missing"
    elif "permission" in last_error.lower():
        reason = "permission_error"
    else:
        reason = "no_imagery_produced"

    if override_message:
        message = override_message
    elif reason == "sample_rate_too_low":
        message = f"Sample rate {sample_rate} Hz is too low for Meteor LRPT decoding."
    elif reason == "missing_recording":
        message = "The recording file was not found when decode started."
    elif reason == "recording_too_small":
        message = (
            f"Recording is very small ({_format_bytes(file_size)}); this usually means the pass "
            "ended early or little usable IQ was captured."
        )
    elif reason == "satdump_failed":
        message = last_error or f"SatDump exited with code {return_code}."
    elif reason == "invalid_sample_rate":
        message = last_error or "SatDump rejected the recording sample rate."
    elif reason == "input_missing":
        message = last_error or "Input recording was not accessible to the decoder."
    elif reason == "permission_error":
        message = last_error or "Decoder could not access the recording or output path."
    else:
        message = (
            last_error
            or "Decode completed without any image outputs. This usually indicates weak signal, "
            "incorrect sample rate, or a SatDump pipeline mismatch."
        )

    return {
        "reason": reason,
        "message": message,
        "sample_rate": sample_rate,
        "file_size_bytes": file_size,
        "file_size_human": _format_bytes(file_size),
        "last_error": last_error or None,
        "last_returncode": return_code,
        "capture_phase": status.get("capture_phase") or latest_status.get("phase"),
        "input_path": str(data_path),
    }


def _format_bytes(size_bytes: int) -> str:
    if size_bytes < 1024:
        return f"{size_bytes} B"
    if size_bytes < 1024 * 1024:
        return f"{size_bytes / 1024:.1f} KB"
    if size_bytes < 1024 * 1024 * 1024:
        return f"{size_bytes / (1024 * 1024):.1f} MB"
    return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"


def _create_decode_job(
    *,
    observation_id: int | None,
    norad_id: int,
    backend: str,
    input_path: Path,
) -> int | None:
    try:
        from utils.database import get_db

        with get_db() as conn:
            cur = conn.execute(
                """
                INSERT INTO ground_station_decode_jobs
                    (observation_id, norad_id, backend, status, input_path, created_at, updated_at)
                VALUES (?, ?, ?, ?, ?, ?, ?)
                """,
                (
                    observation_id,
                    norad_id,
                    backend,
                    "queued",
                    str(input_path),
                    _utcnow_iso(),
                    _utcnow_iso(),
                ),
            )
            return cur.lastrowid
    except Exception as e:
        logger.warning("Failed to create decode job: %s", e)
        return None


def _update_decode_job(
    decode_job_id: int | None,
    *,
    status: str,
    output_dir: Path | None = None,
    error_message: str | None = None,
    details: dict | None = None,
    started: bool = False,
    completed: bool = False,
) -> None:
    if decode_job_id is None:
        return
    try:
        from utils.database import get_db

        fields = ["status = ?", "updated_at = ?"]
        values: list[object] = [status, _utcnow_iso()]

        if output_dir is not None:
            fields.append("output_dir = ?")
            values.append(str(output_dir))
        if error_message is not None:
            fields.append("error_message = ?")
            values.append(error_message)
        if details is not None:
            fields.append("details_json = ?")
            values.append(json.dumps(details))
        if started:
            fields.append("started_at = ?")
            values.append(_utcnow_iso())
        if completed:
            fields.append("completed_at = ?")
            values.append(_utcnow_iso())

        values.append(decode_job_id)
        with get_db() as conn:
            conn.execute(
                f"""
                UPDATE ground_station_decode_jobs
                SET {", ".join(fields)}
                WHERE id = ?
                """,
                values,
            )
    except Exception as e:
        logger.warning("Failed to update decode job %s: %s", decode_job_id, e)


def _utcnow_iso() -> str:
    return datetime.now(timezone.utc).isoformat()