"""Tests for WeFax (Weather Fax) routes, decoder, and station loader."""

from __future__ import annotations

import json
import math
from pathlib import Path
from unittest.mock import MagicMock, patch

import numpy as np


def _login_session(client) -> None:
    """Mark the Flask test session as authenticated."""
    with client.session_transaction() as sess:
        sess['logged_in'] = True
        sess['username'] = 'test'
        sess['role'] = 'admin'


# ---------------------------------------------------------------------------
# Station database tests
# ---------------------------------------------------------------------------

class TestWeFaxStations:
    """WeFax station database tests."""

    def test_load_stations_returns_list(self):
        """load_stations() should return a non-empty list."""
        from utils.wefax_stations import load_stations
        stations = load_stations()
        assert isinstance(stations, list)
        assert len(stations) >= 10

    def test_station_has_required_fields(self):
        """Each station must have required fields."""
        from utils.wefax_stations import load_stations
        required = {'name', 'callsign', 'country', 'city', 'coordinates',
                     'frequencies', 'ioc', 'lpm', 'schedule'}
        for station in load_stations():
            missing = required - set(station.keys())
            assert not missing, f"Station {station.get('callsign', '?')} missing: {missing}"

    def test_get_station_by_callsign(self):
        """get_station() should return correct station."""
        from utils.wefax_stations import get_station
        station = get_station('NOJ')
        assert station is not None
        assert station['callsign'] == 'NOJ'
        assert station['country'] == 'US'

    def test_get_station_case_insensitive(self):
        """get_station() should be case-insensitive."""
        from utils.wefax_stations import get_station
        assert get_station('noj') is not None

    def test_get_station_not_found(self):
        """get_station() should return None for unknown callsign."""
        from utils.wefax_stations import get_station
        assert get_station('XXXXX') is None

    def test_resolve_tuning_frequency_auto_uses_carrier_for_known_station(self):
        """Known station frequencies default to carrier-list behavior in auto mode."""
        from utils.wefax_stations import resolve_tuning_frequency_khz

        tuned, reference, offset_applied = resolve_tuning_frequency_khz(
            listed_frequency_khz=4298.0,
            station_callsign='NOJ',
            frequency_reference='auto',
        )

        assert math.isclose(tuned, 4296.1, abs_tol=1e-6)
        assert reference == 'carrier'
        assert offset_applied is True

    def test_resolve_tuning_frequency_auto_preserves_unknown_station_input(self):
        """Ad-hoc frequencies (no station metadata) should be treated as dial."""
        from utils.wefax_stations import resolve_tuning_frequency_khz

        tuned, reference, offset_applied = resolve_tuning_frequency_khz(
            listed_frequency_khz=4298.0,
            station_callsign='',
            frequency_reference='auto',
        )

        assert math.isclose(tuned, 4298.0, abs_tol=1e-6)
        assert reference == 'dial'
        assert offset_applied is False

    def test_resolve_tuning_frequency_dial_override(self):
        """Explicit dial reference must bypass USB alignment."""
        from utils.wefax_stations import resolve_tuning_frequency_khz

        tuned, reference, offset_applied = resolve_tuning_frequency_khz(
            listed_frequency_khz=4298.0,
            station_callsign='NOJ',
            frequency_reference='dial',
        )

        assert math.isclose(tuned, 4298.0, abs_tol=1e-6)
        assert reference == 'dial'
        assert offset_applied is False

    def test_resolve_tuning_frequency_rejects_invalid_reference(self):
        """Invalid frequency reference values should raise a validation error."""
        from utils.wefax_stations import resolve_tuning_frequency_khz

        try:
            resolve_tuning_frequency_khz(
                listed_frequency_khz=4298.0,
                station_callsign='NOJ',
                frequency_reference='invalid',
            )
            raise AssertionError("Expected ValueError for invalid frequency_reference")
        except ValueError as exc:
            assert 'frequency_reference' in str(exc)

    def test_station_frequencies_have_khz(self):
        """Each frequency entry must have 'khz' and 'description'."""
        from utils.wefax_stations import load_stations
        for station in load_stations():
            for freq in station['frequencies']:
                assert 'khz' in freq, f"{station['callsign']} missing khz"
                assert 'description' in freq, f"{station['callsign']} missing description"
                assert isinstance(freq['khz'], (int, float))
                assert freq['khz'] > 0

    def test_schedule_format(self):
        """Schedule entries must have utc, duration_min, content."""
        from utils.wefax_stations import load_stations
        for station in load_stations():
            for entry in station['schedule']:
                assert 'utc' in entry
                assert 'duration_min' in entry
                assert 'content' in entry
                # UTC format: HH:MM
                parts = entry['utc'].split(':')
                assert len(parts) == 2
                assert 0 <= int(parts[0]) <= 23
                assert 0 <= int(parts[1]) <= 59

    def test_get_current_broadcasts(self):
        """get_current_broadcasts() should return up to 3 entries."""
        from utils.wefax_stations import get_current_broadcasts
        broadcasts = get_current_broadcasts('NOJ')
        assert isinstance(broadcasts, list)
        assert len(broadcasts) <= 3
        for b in broadcasts:
            assert 'utc' in b
            assert 'content' in b


# ---------------------------------------------------------------------------
# Decoder unit tests
# ---------------------------------------------------------------------------

class TestWeFaxDecoder:
    """WeFax decoder DSP and data class tests."""

    def test_freq_to_pixel_black(self):
        """1500 Hz should map to 0 (black)."""
        from utils.wefax import _freq_to_pixel
        assert _freq_to_pixel(1500.0) == 0

    def test_freq_to_pixel_white(self):
        """2300 Hz should map to 255 (white)."""
        from utils.wefax import _freq_to_pixel
        assert _freq_to_pixel(2300.0) == 255

    def test_freq_to_pixel_mid(self):
        """1900 Hz (carrier) should map to ~128."""
        from utils.wefax import _freq_to_pixel
        val = _freq_to_pixel(1900.0)
        assert 120 <= val <= 135

    def test_freq_to_pixel_clamp_low(self):
        """Below 1500 Hz should clamp to 0."""
        from utils.wefax import _freq_to_pixel
        assert _freq_to_pixel(1000.0) == 0

    def test_freq_to_pixel_clamp_high(self):
        """Above 2300 Hz should clamp to 255."""
        from utils.wefax import _freq_to_pixel
        assert _freq_to_pixel(3000.0) == 255

    def test_ioc_576_pixel_count(self):
        """IOC 576 should give pi*576 ≈ 1809 pixels per line."""
        pixels = int(math.pi * 576)
        assert pixels == 1809

    def test_ioc_288_pixel_count(self):
        """IOC 288 should give pi*288 ≈ 904 pixels per line."""
        pixels = int(math.pi * 288)
        assert pixels == 904

    def test_goertzel_mag_detects_tone(self):
        """Goertzel should detect a pure tone."""
        from utils.wefax import _goertzel_mag
        sr = 22050
        freq = 1900.0
        t = np.arange(sr) / sr
        samples = np.sin(2 * np.pi * freq * t)
        mag = _goertzel_mag(samples[:2205], freq, sr)
        # Should be significantly non-zero for a matching tone
        assert mag > 1.0

    def test_goertzel_mag_rejects_wrong_freq(self):
        """Goertzel should be much weaker for non-matching frequency."""
        from utils.wefax import _goertzel_mag
        sr = 22050
        t = np.arange(sr) / sr
        samples = np.sin(2 * np.pi * 1900.0 * t)
        mag_match = _goertzel_mag(samples[:2205], 1900.0, sr)
        mag_off = _goertzel_mag(samples[:2205], 300.0, sr)
        assert mag_match > mag_off * 5

    def test_detect_tone_start(self):
        """detect_tone should identify a 300 Hz start tone."""
        from utils.wefax import _detect_tone
        sr = 22050
        t = np.arange(sr) / sr
        samples = np.sin(2 * np.pi * 300.0 * t)
        assert _detect_tone(samples[:2205], 300.0, sr, threshold=2.0)

    def test_wefax_image_to_dict(self):
        """WeFaxImage.to_dict() should produce expected format."""
        from datetime import datetime, timezone

        from utils.wefax import WeFaxImage
        img = WeFaxImage(
            filename='test.png',
            path=Path('/tmp/test.png'),
            station='NOJ',
            frequency_khz=4298,
            timestamp=datetime(2026, 1, 1, tzinfo=timezone.utc),
            ioc=576,
            lpm=120,
            size_bytes=1234,
        )
        d = img.to_dict()
        assert d['filename'] == 'test.png'
        assert d['station'] == 'NOJ'
        assert d['frequency_khz'] == 4298
        assert d['ioc'] == 576
        assert d['url'] == '/wefax/images/test.png'

    def test_wefax_progress_to_dict(self):
        """WeFaxProgress.to_dict() should produce expected format."""
        from utils.wefax import WeFaxProgress
        p = WeFaxProgress(
            status='receiving',
            station='NOJ',
            message='Receiving: 100 lines',
            progress_percent=50,
            line_count=100,
        )
        d = p.to_dict()
        assert d['type'] == 'wefax_progress'
        assert d['status'] == 'receiving'
        assert d['progress'] == 50
        assert d['station'] == 'NOJ'
        assert d['line_count'] == 100

    def test_singleton_returns_same_instance(self, tmp_path):
        """get_wefax_decoder() should return a singleton."""
        from utils.wefax import WeFaxDecoder
        # Use __new__ to avoid __init__ creating dirs
        d1 = WeFaxDecoder.__new__(WeFaxDecoder)
        # Test the module-level singleton pattern
        import utils.wefax as wefax_mod
        original = wefax_mod._decoder
        try:
            wefax_mod._decoder = d1
            assert wefax_mod.get_wefax_decoder() is d1
            assert wefax_mod.get_wefax_decoder() is d1
        finally:
            wefax_mod._decoder = original


# ---------------------------------------------------------------------------
# Route tests
# ---------------------------------------------------------------------------

class TestWeFaxRoutes:
    """WeFax route endpoint tests."""

    def test_status(self, client):
        """GET /wefax/status should return decoder status."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False
        mock_decoder.get_images.return_value = []

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.get('/wefax/status')

        assert response.status_code == 200
        data = response.get_json()
        assert data['available'] is True
        assert data['running'] is False

    def test_stations_list(self, client):
        """GET /wefax/stations should return station list."""
        _login_session(client)
        response = client.get('/wefax/stations')
        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'ok'
        assert data['count'] >= 10

    def test_station_detail(self, client):
        """GET /wefax/stations/NOJ should return station detail."""
        _login_session(client)
        response = client.get('/wefax/stations/NOJ')
        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'ok'
        assert data['station']['callsign'] == 'NOJ'
        assert 'current_broadcasts' in data

    def test_station_not_found(self, client):
        """GET /wefax/stations/XXXXX should return 404."""
        _login_session(client)
        response = client.get('/wefax/stations/XXXXX')
        assert response.status_code == 404

    def test_start_requires_frequency(self, client):
        """POST /wefax/start without frequency should fail."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.post(
                '/wefax/start',
                data=json.dumps({}),
                content_type='application/json',
            )

        assert response.status_code == 400
        data = response.get_json()
        assert data['status'] == 'error'

    def test_start_validates_frequency_range(self, client):
        """POST /wefax/start with out-of-range frequency should fail."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.post(
                '/wefax/start',
                data=json.dumps({'frequency_khz': 100}),  # 0.1 MHz - too low
                content_type='application/json',
            )

        assert response.status_code == 400

    def test_start_validates_ioc(self, client):
        """POST /wefax/start with invalid IOC should fail."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.post(
                '/wefax/start',
                data=json.dumps({'frequency_khz': 4298, 'ioc': 999}),
                content_type='application/json',
            )

        assert response.status_code == 400
        data = response.get_json()
        assert 'IOC' in data['message']

    def test_start_validates_lpm(self, client):
        """POST /wefax/start with invalid LPM should fail."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.post(
                '/wefax/start',
                data=json.dumps({'frequency_khz': 4298, 'lpm': 999}),
                content_type='application/json',
            )

        assert response.status_code == 400
        data = response.get_json()
        assert 'LPM' in data['message']

    def test_start_success(self, client):
        """POST /wefax/start with valid params should succeed."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False
        mock_decoder.start.return_value = True

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
             patch('routes.wefax.app_module.claim_sdr_device', return_value=None):
            response = client.post(
                '/wefax/start',
                data=json.dumps({
                    'frequency_khz': 4298,
                    'station': 'NOJ',
                    'device': 0,
                    'ioc': 576,
                    'lpm': 120,
                }),
                content_type='application/json',
            )

        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'started'
        assert data['frequency_khz'] == 4298
        assert data['usb_offset_applied'] is True
        assert math.isclose(data['tuned_frequency_khz'], 4296.1, abs_tol=1e-6)
        assert data['frequency_reference'] == 'carrier'
        assert data['station'] == 'NOJ'
        mock_decoder.start.assert_called_once()
        start_kwargs = mock_decoder.start.call_args.kwargs
        assert math.isclose(start_kwargs['frequency_khz'], 4296.1, abs_tol=1e-6)

    def test_start_respects_dial_reference_override(self, client):
        """POST /wefax/start with dial reference should not apply USB offset."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False
        mock_decoder.start.return_value = True

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
             patch('routes.wefax.app_module.claim_sdr_device', return_value=None):
            response = client.post(
                '/wefax/start',
                data=json.dumps({
                    'frequency_khz': 4298,
                    'station': 'NOJ',
                    'device': 0,
                    'frequency_reference': 'dial',
                }),
                content_type='application/json',
            )

        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'started'
        assert data['usb_offset_applied'] is False
        assert math.isclose(data['tuned_frequency_khz'], 4298.0, abs_tol=1e-6)
        assert data['frequency_reference'] == 'dial'
        start_kwargs = mock_decoder.start.call_args.kwargs
        assert math.isclose(start_kwargs['frequency_khz'], 4298.0, abs_tol=1e-6)

    def test_start_device_busy(self, client):
        """POST /wefax/start should return 409 when device is busy."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.is_running = False

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder), \
             patch('routes.wefax.app_module.claim_sdr_device',
                   return_value='Device 0 in use by pager'):
            response = client.post(
                '/wefax/start',
                data=json.dumps({'frequency_khz': 4298}),
                content_type='application/json',
            )

        assert response.status_code == 409
        data = response.get_json()
        assert data['error_type'] == 'DEVICE_BUSY'

    def test_stop(self, client):
        """POST /wefax/stop should stop the decoder."""
        _login_session(client)
        mock_decoder = MagicMock()

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.post('/wefax/stop')

        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'stopped'
        mock_decoder.stop.assert_called_once()

    def test_images_list(self, client):
        """GET /wefax/images should return image list."""
        _login_session(client)
        mock_decoder = MagicMock()
        mock_decoder.get_images.return_value = []

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.get('/wefax/images')

        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'ok'
        assert data['count'] == 0

    def test_delete_image_invalid_filename(self, client):
        """DELETE /wefax/images/<filename> should reject invalid filenames."""
        _login_session(client)
        mock_decoder = MagicMock()

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            # Use a filename with special chars that won't be split by Flask routing
            response = client.delete('/wefax/images/te$t!file.png')

        assert response.status_code == 400

    def test_delete_image_wrong_extension(self, client):
        """DELETE /wefax/images/<filename> should reject non-PNG."""
        _login_session(client)
        mock_decoder = MagicMock()

        with patch('routes.wefax.get_wefax_decoder', return_value=mock_decoder):
            response = client.delete('/wefax/images/test.jpg')

        assert response.status_code == 400

    def test_schedule_enable_applies_usb_alignment(self, client):
        """Scheduler should receive tuned USB dial frequency in auto mode."""
        _login_session(client)
        mock_scheduler = MagicMock()
        mock_scheduler.enable.return_value = {
            'enabled': True,
            'scheduled_count': 2,
            'total_broadcasts': 2,
        }

        with patch('utils.wefax_scheduler.get_wefax_scheduler', return_value=mock_scheduler):
            response = client.post(
                '/wefax/schedule/enable',
                data=json.dumps({
                    'station': 'NOJ',
                    'frequency_khz': 4298,
                    'device': 0,
                }),
                content_type='application/json',
            )

        assert response.status_code == 200
        data = response.get_json()
        assert data['status'] == 'ok'
        assert data['usb_offset_applied'] is True
        assert math.isclose(data['tuned_frequency_khz'], 4296.1, abs_tol=1e-6)
        enable_kwargs = mock_scheduler.enable.call_args.kwargs
        assert math.isclose(enable_kwargs['frequency_khz'], 4296.1, abs_tol=1e-6)


class TestWeFaxProgressCallback:
    """Regression tests for WeFax route-level progress callback behavior."""

    def test_terminal_progress_releases_active_device(self):
        """Terminal decoder events must release any manually claimed SDR."""
        import routes.wefax as wefax_routes

        original_device = wefax_routes.wefax_active_device
        try:
            wefax_routes.wefax_active_device = 3
            with patch('routes.wefax.app_module.release_sdr_device') as mock_release:
                wefax_routes._progress_callback({
                    'type': 'wefax_progress',
                    'status': 'error',
                    'message': 'decode failed',
                })

            mock_release.assert_called_once_with(3, 'rtlsdr')
            assert wefax_routes.wefax_active_device is None
        finally:
            wefax_routes.wefax_active_device = original_device

    def test_non_terminal_progress_does_not_release_active_device(self):
        """Non-terminal progress updates must not release SDR ownership."""
        import routes.wefax as wefax_routes

        original_device = wefax_routes.wefax_active_device
        try:
            wefax_routes.wefax_active_device = 4
            with patch('routes.wefax.app_module.release_sdr_device') as mock_release:
                wefax_routes._progress_callback({
                    'type': 'wefax_progress',
                    'status': 'receiving',
                    'line_count': 120,
                })

            mock_release.assert_not_called()
            assert wefax_routes.wefax_active_device == 4
        finally:
            wefax_routes.wefax_active_device = original_device