"""Tests for WeFax auto-scheduler behavior and regressions."""

from __future__ import annotations

from datetime import datetime, timedelta, timezone
from unittest.mock import MagicMock, patch

from utils.wefax_scheduler import ScheduledBroadcast, WeFaxScheduler


class TestWeFaxScheduler:
    """WeFaxScheduler regression tests."""

    @patch("threading.Timer")
    def test_refresh_reschedules_same_utc_slot_next_day(self, mock_timer):
        """Completed broadcasts must not block the next day's same UTC slot."""
        scheduler = WeFaxScheduler()
        scheduler._enabled = True
        scheduler._station = "USCG Kodiak"
        scheduler._callsign = "NOJ"
        scheduler._frequency_khz = 4298.0

        now = datetime.now(timezone.utc)
        utc_time = (now - timedelta(hours=2)).strftime("%H:%M")
        today = now.date().isoformat()

        prior = ScheduledBroadcast(
            station="USCG Kodiak",
            callsign="NOJ",
            frequency_khz=4298.0,
            utc_time=utc_time,
            duration_min=20,
            content="Chart",
            occurrence_date=today,
        )
        prior.status = "complete"
        scheduler._broadcasts = [prior]

        mock_timer.return_value = MagicMock()

        with patch(
            "utils.wefax_scheduler.get_station",
            return_value={
                "name": "USCG Kodiak",
                "schedule": [
                    {
                        "utc": utc_time,
                        "duration_min": 20,
                        "content": "Chart",
                    }
                ],
            },
        ):
            scheduler._refresh_schedule()

        capture_calls = [
            c
            for c in mock_timer.call_args_list
            if len(c.args) >= 2 and getattr(c.args[1], "__name__", "") == "_execute_capture"
        ]
        assert capture_calls, "Expected a capture timer for the next-day occurrence"

        scheduled = [b for b in scheduler._broadcasts if b.status == "scheduled"]
        assert len(scheduled) == 1
        assert scheduled[0].occurrence_date != today

    def test_execute_capture_stops_immediately_if_window_elapsed(self):
        """If stop delay computes to <= 0, capture should close out immediately."""
        scheduler = WeFaxScheduler()
        scheduler._enabled = True
        scheduler._callsign = "NOJ"
        scheduler._frequency_khz = 4298.0
        scheduler._device = 0
        scheduler._gain = 40.0
        scheduler._ioc = 576
        scheduler._lpm = 120
        scheduler._direct_sampling = True

        now = datetime.now(timezone.utc)
        sb = ScheduledBroadcast(
            station="USCG Kodiak",
            callsign="NOJ",
            frequency_khz=4298.0,
            utc_time=now.strftime("%H:%M"),
            duration_min=0,
            content="Late chart",
            occurrence_date=now.date().isoformat(),
        )
        sb.status = "scheduled"

        mock_decoder = MagicMock()
        mock_decoder.is_running = False
        mock_decoder.start.return_value = True

        with (
            patch("utils.wefax_scheduler.get_wefax_decoder", return_value=mock_decoder),
            patch("utils.wefax_scheduler.WEFAX_CAPTURE_BUFFER_SECONDS", 0),
            patch("app.claim_sdr_device", return_value=None),
            patch.object(scheduler, "_stop_capture") as mock_stop_capture,
        ):
            scheduler._execute_capture_inner(sb)

        mock_stop_capture.assert_called_once()

    @patch("threading.Timer")
    def test_terminal_progress_releases_scheduler_device_early(self, mock_timer):
        """Scheduler captures must release SDR as soon as terminal progress arrives."""
        scheduler = WeFaxScheduler()
        scheduler._enabled = True
        scheduler._callsign = "NOJ"
        scheduler._frequency_khz = 4298.0
        scheduler._device = 0
        scheduler._gain = 40.0
        scheduler._ioc = 576
        scheduler._lpm = 120
        scheduler._direct_sampling = True

        sb = ScheduledBroadcast(
            station="USCG Kodiak",
            callsign="NOJ",
            frequency_khz=4298.0,
            utc_time="12:00",
            duration_min=20,
            content="Chart",
            occurrence_date="2026-01-01",
        )
        sb.status = "scheduled"

        mock_decoder = MagicMock()
        mock_decoder.is_running = False
        mock_decoder.start.return_value = True
        mock_timer.return_value = MagicMock()

        with (
            patch("utils.wefax_scheduler.get_wefax_decoder", return_value=mock_decoder),
            patch("app.claim_sdr_device", return_value=None),
            patch("app.release_sdr_device") as mock_release,
        ):
            scheduler._execute_capture_inner(sb)
            progress_cb = mock_decoder.set_callback.call_args[0][0]
            progress_cb(
                {
                    "type": "wefax_progress",
                    "status": "error",
                    "message": "rtl_fm failed",
                }
            )

        mock_release.assert_called_once_with(0)
        assert sb.status == "skipped"

    def test_stop_capture_non_capturing_only_releases(self):
        """_stop_capture should be idempotent when capture already ended."""
        scheduler = WeFaxScheduler()
        sb = ScheduledBroadcast(
            station="USCG Kodiak",
            callsign="NOJ",
            frequency_khz=4298.0,
            utc_time="12:00",
            duration_min=20,
            content="Chart",
            occurrence_date="2026-01-01",
        )
        sb.status = "complete"
        release_fn = MagicMock()

        with patch("utils.wefax_scheduler.get_wefax_decoder") as mock_get_decoder:
            scheduler._stop_capture(sb, release_fn)

        release_fn.assert_called_once()
        mock_get_decoder.assert_not_called()