"""Tests for the HF/Shortwave WebSDR integration."""

from unittest.mock import patch

import pytest

from routes.websdr import _haversine, _parse_gps_coord
from utils.kiwisdr import parse_host_port

# ============================================
# Helper function tests
# ============================================


def test_parse_gps_coord_float():
    """Should parse a simple float string."""
    assert _parse_gps_coord("51.5074") == pytest.approx(51.5074)


def test_parse_gps_coord_negative():
    """Should parse a negative coordinate."""
    assert _parse_gps_coord("-33.87") == pytest.approx(-33.87)


def test_parse_gps_coord_parentheses():
    """Should handle parentheses in coordinate string."""
    assert _parse_gps_coord("(-33.87)") == pytest.approx(-33.87)


def test_parse_gps_coord_empty():
    """Should return None for empty string."""
    assert _parse_gps_coord("") is None
    assert _parse_gps_coord(None) is None


def test_parse_gps_coord_invalid():
    """Should return None for invalid string."""
    assert _parse_gps_coord("abc") is None


def test_haversine_same_point():
    """Distance between same point should be 0."""
    assert _haversine(51.5, -0.1, 51.5, -0.1) == pytest.approx(0.0, abs=0.01)


def test_haversine_known_distance():
    """Test with known city pair (London to Paris ~343 km)."""
    dist = _haversine(51.5074, -0.1278, 48.8566, 2.3522)
    assert 340 < dist < 350


# ============================================
# Endpoint tests
# ============================================


@pytest.fixture
def auth_client(client):
    """Client with logged-in session."""
    with client.session_transaction() as sess:
        sess["logged_in"] = True
    return client


def test_websdr_status(auth_client):
    """Status endpoint should return cache info."""
    resp = auth_client.get("/websdr/status")
    assert resp.status_code == 200
    data = resp.get_json()
    assert data["status"] == "ok"
    assert "cached_receivers" in data


def test_websdr_receivers_empty_cache(auth_client):
    """Receivers endpoint should work even with empty cache."""
    with patch("routes.websdr.get_receivers", return_value=[]):
        resp = auth_client.get("/websdr/receivers")
        assert resp.status_code == 200
        data = resp.get_json()
        assert data["status"] == "success"
        assert data["receivers"] == []


def test_websdr_receivers_with_data(auth_client):
    """Receivers endpoint should return filtered data."""
    mock_receivers = [
        {
            "name": "Test RX",
            "url": "http://test.com",
            "lat": 51.5,
            "lon": -0.1,
            "users": 1,
            "users_max": 4,
            "available": True,
            "freq_lo": 0,
            "freq_hi": 30000,
            "antenna": "Dipole",
            "bands": "HF",
        },
        {
            "name": "Full RX",
            "url": "http://full.com",
            "lat": 48.8,
            "lon": 2.3,
            "users": 4,
            "users_max": 4,
            "available": False,
            "freq_lo": 0,
            "freq_hi": 30000,
            "antenna": "Loop",
            "bands": "HF",
        },
    ]
    with patch("routes.websdr.get_receivers", return_value=mock_receivers):
        # Filter available only
        resp = auth_client.get("/websdr/receivers?available=true")
        assert resp.status_code == 200
        data = resp.get_json()
        assert len(data["receivers"]) == 1
        assert data["receivers"][0]["name"] == "Test RX"


def test_websdr_nearest_missing_params(auth_client):
    """Nearest endpoint should require lat/lon."""
    resp = auth_client.get("/websdr/receivers/nearest")
    assert resp.status_code == 400


def test_websdr_nearest_with_coords(auth_client):
    """Nearest endpoint should sort by distance."""
    mock_receivers = [
        {
            "name": "Far RX",
            "url": "http://far.com",
            "lat": -33.87,
            "lon": 151.21,
            "users": 0,
            "users_max": 4,
            "available": True,
            "freq_lo": 0,
            "freq_hi": 30000,
            "antenna": "Dipole",
            "bands": "HF",
        },
        {
            "name": "Near RX",
            "url": "http://near.com",
            "lat": 51.0,
            "lon": -0.5,
            "users": 0,
            "users_max": 4,
            "available": True,
            "freq_lo": 0,
            "freq_hi": 30000,
            "antenna": "Loop",
            "bands": "HF",
        },
    ]
    with patch("routes.websdr.get_receivers", return_value=mock_receivers):
        resp = auth_client.get("/websdr/receivers/nearest?lat=51.5&lon=-0.1")
        assert resp.status_code == 200
        data = resp.get_json()
        assert data["status"] == "success"
        assert len(data["receivers"]) == 2
        # Near should be first
        assert data["receivers"][0]["name"] == "Near RX"


def test_websdr_spy_station_receivers(auth_client):
    """Spy station cross-reference should find matching receivers."""
    mock_receivers = [
        {
            "name": "HF RX",
            "url": "http://hf.com",
            "lat": 51.5,
            "lon": -0.1,
            "users": 0,
            "users_max": 4,
            "available": True,
            "freq_lo": 0,
            "freq_hi": 30000,
            "antenna": "Dipole",
            "bands": "HF",
        },
    ]
    with patch("routes.websdr.get_receivers", return_value=mock_receivers):
        # e06 is one of the spy stations
        resp = auth_client.get("/websdr/spy-station/e06/receivers")
        assert resp.status_code == 200
        data = resp.get_json()
        assert data["status"] == "success"
        assert "station" in data


def test_websdr_spy_station_not_found(auth_client):
    """Non-existent station should return 404."""
    resp = auth_client.get("/websdr/spy-station/nonexistent/receivers")
    assert resp.status_code == 404


# ============================================
# parse_host_port tests (integration)
# ============================================


def test_parse_host_port_http_url():
    """Should parse standard KiwiSDR URL."""
    host, port = parse_host_port("http://kiwi.example.com:8073")
    assert host == "kiwi.example.com"
    assert port == 8073


def test_parse_host_port_no_protocol():
    """Should handle bare hostname."""
    host, port = parse_host_port("my-kiwi.local:8074")
    assert host == "my-kiwi.local"
    assert port == 8074


def test_parse_host_port_with_trailing_slash():
    """Should handle URL with trailing path."""
    host, port = parse_host_port("http://kiwi.com:8073/")
    assert host == "kiwi.com"
    assert port == 8073