intercept/tests/test_meteor_detector.py

"""Unit tests for utils/meteor_detector.py."""

import json
import time

import numpy as np
import pytest

from utils.meteor_detector import MeteorDetector, MeteorEvent, PingState


@pytest.fixture
def detector():
    """Create a detector with test-friendly defaults."""
    return MeteorDetector(
        snr_threshold_db=6.0,
        min_duration_ms=50.0,
        cooldown_ms=200.0,
        freq_drift_tolerance_hz=500.0,
        noise_alpha=0.5,  # fast adaptation for tests
    )


def _make_noise(fft_size=256, noise_level=-80.0, rng=None):
    """Generate a noise-floor FFT frame."""
    if rng is None:
        rng = np.random.default_rng(42)
    return (noise_level + rng.normal(0, 1, fft_size)).astype(np.float32)


def _inject_signal(frame, bin_index, power_db):
    """Inject a signal at a specific bin."""
    out = frame.copy()
    out[bin_index] = power_db
    return out


class TestMeteorDetectorBasic:
    """Basic construction and property tests."""

    def test_initial_state(self, detector):
        assert detector.state == PingState.IDLE
        assert detector._pings_total == 0
        assert detector._events == []

    def test_update_settings(self, detector):
        detector.update_settings(snr_threshold_db=10.0, min_duration_ms=100.0)
        assert detector.snr_threshold_db == 10.0
        assert detector.min_duration_ms == 100.0

    def test_reset(self, detector):
        detector._pings_total = 5
        detector._events.append(MeteorEvent(
            id='test', start_ts=0, end_ts=1, duration_ms=100,
            peak_db=-40, snr_db=20, center_freq_hz=143e6,
            peak_freq_hz=143e6, freq_offset_hz=0, confidence=0.8,
        ))
        detector.reset()
        assert detector._pings_total == 0
        assert detector._events == []
        assert detector.state == PingState.IDLE


class TestNoiseFloor:
    """Noise floor tracking tests."""

    def test_noise_floor_initialized_on_first_frame(self, detector):
        frame = _make_noise()
        detector.process_frame(frame, 142e6, 144e6, timestamp=1.0)
        assert detector._noise_initialized
        assert detector._noise_floor is not None

    def test_noise_floor_stable_without_signal(self, detector):
        rng = np.random.default_rng(123)
        for i in range(50):
            frame = _make_noise(rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=float(i))

        # Noise floor should be close to -80 dB
        median_nf = float(np.median(detector._noise_floor))
        assert -82 < median_nf < -78


class TestDetectionStateMachine:
    """State machine transition tests."""

    def test_no_detection_on_pure_noise(self, detector):
        rng = np.random.default_rng(42)
        for i in range(100):
            frame = _make_noise(rng=rng)
            stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=float(i) * 0.05)
            assert event is None
        assert detector._pings_total == 0

    def test_detect_strong_ping(self, detector):
        rng = np.random.default_rng(42)
        fft_size = 256
        center_bin = fft_size // 2
        ts = 0.0

        # Prime noise floor with 20 frames
        for _ in range(20):
            frame = _make_noise(fft_size, rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.05

        # Inject signal for enough frames to exceed min_duration_ms (50ms)
        # At 0.05s per frame, need 2+ frames
        events = []
        for _ in range(5):
            frame = _make_noise(fft_size, rng=rng)
            frame = _inject_signal(frame, center_bin, -40.0)  # ~40 dB above noise
            stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            if event:
                events.append(event)
            ts += 0.05

        # Signal drops — should enter cooldown
        for _ in range(10):
            frame = _make_noise(fft_size, rng=rng)
            stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            if event:
                events.append(event)
            ts += 0.05

        assert len(events) == 1
        evt = events[0]
        assert evt.snr_db > 10
        assert evt.duration_ms > 0
        assert evt.confidence > 0

    def test_false_alarm_short_burst(self, detector):
        """A signal below min_duration should not produce an event."""
        rng = np.random.default_rng(42)
        fft_size = 256
        center_bin = fft_size // 2
        ts = 0.0

        # Prime noise floor
        for _ in range(20):
            frame = _make_noise(fft_size, rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.001  # 1ms per frame

        # Single frame with signal (1ms < 50ms min_duration)
        frame = _make_noise(fft_size, rng=rng)
        frame = _inject_signal(frame, center_bin, -40.0)
        stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
        ts += 0.001

        # Immediately back to noise
        frame = _make_noise(fft_size, rng=rng)
        stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)

        assert event is None
        assert detector.state == PingState.IDLE


class TestEventProperties:
    """Test event metadata and tags."""

    def _generate_event(self, detector, snr_offset=40.0, num_signal_frames=10):
        rng = np.random.default_rng(99)
        fft_size = 256
        center_bin = fft_size // 2
        ts = 0.0

        # Prime noise floor
        for _ in range(30):
            frame = _make_noise(fft_size, rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.05

        # Signal frames
        for _ in range(num_signal_frames):
            frame = _make_noise(fft_size, rng=rng)
            frame = _inject_signal(frame, center_bin, -80 + snr_offset)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.05

        # Cooldown frames
        events = []
        for _ in range(20):
            frame = _make_noise(fft_size, rng=rng)
            stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            if event:
                events.append(event)
            ts += 0.05

        return events

    def test_event_has_required_fields(self, detector):
        events = self._generate_event(detector)
        assert len(events) >= 1
        e = events[0]
        assert e.id
        assert e.start_ts > 0
        assert e.end_ts > e.start_ts
        assert e.duration_ms > 0
        assert e.peak_db != 0
        assert e.snr_db > 0
        assert 0 <= e.confidence <= 1
        assert isinstance(e.tags, list)

    def test_event_to_dict(self, detector):
        events = self._generate_event(detector)
        d = events[0].to_dict()
        assert isinstance(d, dict)
        assert 'id' in d
        assert 'snr_db' in d
        assert 'tags' in d

    def test_strong_tag(self, detector):
        events = self._generate_event(detector, snr_offset=60)
        assert len(events) >= 1
        assert 'strong' in events[0].tags


class TestStats:
    """Stats computation tests."""

    def test_stats_structure(self, detector):
        frame = _make_noise()
        stats, _ = detector.process_frame(frame, 142e6, 144e6, timestamp=time.time())
        assert stats['type'] == 'stats'
        assert 'pings_total' in stats
        assert 'pings_last_10min' in stats
        assert 'strongest_snr' in stats
        assert 'current_noise_floor' in stats
        assert 'uptime_s' in stats
        assert 'state' in stats

    def test_pings_total_increments(self, detector):
        rng = np.random.default_rng(42)
        fft_size = 256
        center_bin = fft_size // 2
        ts = 0.0

        # Prime
        for _ in range(20):
            frame = _make_noise(fft_size, rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.05

        # Two separate pings
        for _ in range(2):
            for _ in range(5):
                frame = _make_noise(fft_size, rng=rng)
                frame = _inject_signal(frame, center_bin, -40.0)
                detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
                ts += 0.05
            # Gap
            for _ in range(15):
                frame = _make_noise(fft_size, rng=rng)
                detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
                ts += 0.05

        assert detector._pings_total == 2


class TestExport:
    """Export functionality tests."""

    def test_export_csv(self, detector):
        detector._events.append(MeteorEvent(
            id='abc', start_ts=1000.0, end_ts=1000.5, duration_ms=500,
            peak_db=-40, snr_db=20, center_freq_hz=143e6,
            peak_freq_hz=143.001e6, freq_offset_hz=1000, confidence=0.85,
            tags=['strong', 'medium'],
        ))
        csv = detector.export_events_csv()
        assert 'abc' in csv
        assert 'strong;medium' in csv

    def test_export_json(self, detector):
        detector._events.append(MeteorEvent(
            id='def', start_ts=2000.0, end_ts=2001.0, duration_ms=1000,
            peak_db=-35, snr_db=25, center_freq_hz=143e6,
            peak_freq_hz=143e6, freq_offset_hz=0, confidence=0.9,
        ))
        data = json.loads(detector.export_events_json())
        assert len(data) == 1
        assert data[0]['id'] == 'def'

    def test_get_events(self, detector):
        for i in range(10):
            detector._events.append(MeteorEvent(
                id=str(i), start_ts=float(i), end_ts=float(i) + 0.1,
                duration_ms=100, peak_db=-40, snr_db=15,
                center_freq_hz=143e6, peak_freq_hz=143e6,
                freq_offset_hz=0, confidence=0.7,
            ))
        events = detector.get_events(limit=5)
        assert len(events) == 5

    def test_clear_events(self, detector):
        detector._events.append(MeteorEvent(
            id='x', start_ts=0, end_ts=1, duration_ms=100,
            peak_db=-40, snr_db=15, center_freq_hz=143e6,
            peak_freq_hz=143e6, freq_offset_hz=0, confidence=0.7,
        ))
        detector._pings_total = 1
        count = detector.clear_events()
        assert count == 1
        assert len(detector._events) == 0
        assert detector._pings_total == 0


class TestFreqWindow:
    """Test frequency windowing."""

    def test_freq_window_limits_detection_range(self):
        detector = MeteorDetector(
            snr_threshold_db=6.0,
            min_duration_ms=10.0,
            cooldown_ms=50.0,
            noise_alpha=0.5,
            freq_window_hz=100000,  # 100 kHz window
        )
        rng = np.random.default_rng(42)
        fft_size = 256
        ts = 0.0

        # Prime
        for _ in range(20):
            frame = _make_noise(fft_size, rng=rng)
            detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
            ts += 0.01

        # Signal at edge of spectrum (outside 100 kHz window around center)
        # Center is 143 MHz, window is 142.95-143.05 MHz
        # Bin 0 corresponds to 142 MHz — outside window
        frame = _make_noise(fft_size, rng=rng)
        frame = _inject_signal(frame, 5, -30.0)  # near start, outside window
        stats, event = detector.process_frame(frame, 142e6, 144e6, timestamp=ts)
        # Should not trigger since signal is outside the freq window
        # (the windowed slice won't contain bin 5)
        assert event is None