"""Tests for SubGhzManager utility module."""

from __future__ import annotations

import json
import os
from unittest.mock import MagicMock, patch

import pytest

from utils.subghz import SubGhzCapture, SubGhzManager


@pytest.fixture
def tmp_data_dir(tmp_path):
    """Create a temporary data directory for SubGhz captures."""
    data_dir = tmp_path / 'subghz'
    data_dir.mkdir()
    (data_dir / 'captures').mkdir()
    return data_dir


@pytest.fixture
def manager(tmp_data_dir):
    """Create a SubGhzManager with temp directory."""
    return SubGhzManager(data_dir=tmp_data_dir)


class TestSubGhzManagerInit:
    def test_creates_data_dirs(self, tmp_path):
        data_dir = tmp_path / 'new_subghz'
        SubGhzManager(data_dir=data_dir)
        assert (data_dir / 'captures').is_dir()

    def test_active_mode_idle(self, manager):
        assert manager.active_mode == 'idle'

    def test_get_status_idle(self, manager):
        status = manager.get_status()
        assert status['mode'] == 'idle'


class TestToolDetection:
    def test_check_hackrf_found(self, manager):
        with patch('shutil.which', return_value='/usr/bin/hackrf_transfer'):
            assert manager.check_hackrf() is True

    def test_check_hackrf_not_found(self, manager):
        with patch('shutil.which', return_value=None), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._hackrf_available = None  # reset cache
            assert manager.check_hackrf() is False

    def test_check_rtl433_found(self, manager):
        with patch('shutil.which', return_value='/usr/bin/rtl_433'):
            assert manager.check_rtl433() is True

    def test_check_sweep_found(self, manager):
        with patch('shutil.which', return_value='/usr/bin/hackrf_sweep'):
            assert manager.check_sweep() is True


class TestReceive:
    def test_start_receive_no_hackrf(self, manager):
        with patch('shutil.which', return_value=None), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._hackrf_available = None
            result = manager.start_receive(frequency_hz=433920000)
            assert result['status'] == 'error'
            assert 'not found' in result['message']

    def test_start_receive_success(self, manager):
        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        mock_proc.stderr = MagicMock()
        mock_proc.stderr.readline = MagicMock(return_value=b'')

        with patch('shutil.which', return_value='/usr/bin/hackrf_transfer'), \
             patch('subprocess.Popen', return_value=mock_proc), \
             patch.object(manager, 'check_hackrf_device', return_value=True), \
             patch('utils.subghz.register_process'):
            manager._hackrf_available = None
            result = manager.start_receive(
                frequency_hz=433920000,
                sample_rate=2000000,
                lna_gain=32,
                vga_gain=20,
            )
            assert result['status'] == 'started'
            assert result['frequency_hz'] == 433920000
            assert manager.active_mode == 'rx'

    def test_start_receive_already_running(self, manager):
        import time as _time
        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        manager._rx_process = mock_proc
        # Pre-lock device checks now run before active_mode guard
        manager._hackrf_available = True
        manager._hackrf_device_cache = True
        manager._hackrf_device_cache_ts = _time.time()

        result = manager.start_receive(frequency_hz=433920000)
        assert result['status'] == 'error'
        assert 'Already running' in result['message']

    def test_stop_receive_not_running(self, manager):
        result = manager.stop_receive()
        assert result['status'] == 'not_running'

    def test_stop_receive_creates_metadata(self, manager, tmp_data_dir):
        # Create a fake IQ file
        iq_file = tmp_data_dir / 'captures' / 'test.iq'
        iq_file.write_bytes(b'\x00' * 1024)

        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        manager._rx_process = mock_proc
        manager._rx_file = iq_file
        manager._rx_frequency_hz = 433920000
        manager._rx_sample_rate = 2000000
        manager._rx_lna_gain = 32
        manager._rx_vga_gain = 20
        manager._rx_start_time = 1000.0
        manager._rx_bursts = [{'start_seconds': 1.23, 'duration_seconds': 0.15, 'peak_level': 42}]

        with patch('utils.subghz.safe_terminate'), \
             patch('time.time', return_value=1005.0):
            result = manager.stop_receive()

        assert result['status'] == 'stopped'
        assert 'capture' in result
        assert result['capture']['frequency_hz'] == 433920000

        # Verify JSON sidecar was written
        meta_path = iq_file.with_suffix('.json')
        assert meta_path.exists()
        meta = json.loads(meta_path.read_text())
        assert meta['frequency_hz'] == 433920000
        assert isinstance(meta.get('bursts'), list)
        assert meta['bursts'][0]['peak_level'] == 42


class TestTxSafety:
    def test_validate_tx_frequency_ism_433(self):
        result = SubGhzManager.validate_tx_frequency(433920000)
        assert result is None  # Valid

    def test_validate_tx_frequency_ism_315(self):
        result = SubGhzManager.validate_tx_frequency(315000000)
        assert result is None

    def test_validate_tx_frequency_ism_915(self):
        result = SubGhzManager.validate_tx_frequency(915000000)
        assert result is None

    def test_validate_tx_frequency_out_of_band(self):
        result = SubGhzManager.validate_tx_frequency(100000000)  # 100 MHz
        assert result is not None
        assert 'outside allowed TX bands' in result

    def test_validate_tx_frequency_between_bands(self):
        result = SubGhzManager.validate_tx_frequency(500000000)  # 500 MHz
        assert result is not None

    def test_transmit_no_hackrf(self, manager):
        with patch('shutil.which', return_value=None), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._hackrf_available = None
            result = manager.transmit(capture_id='abc123')
            assert result['status'] == 'error'

    def test_transmit_capture_not_found(self, manager):
        with patch('shutil.which', return_value='/usr/bin/hackrf_transfer'), \
             patch.object(manager, 'check_hackrf_device', return_value=True):
            manager._hackrf_available = None
            result = manager.transmit(capture_id='nonexistent')
            assert result['status'] == 'error'
            assert 'not found' in result['message']

    def test_transmit_out_of_band_rejected(self, manager, tmp_data_dir):
        # Create a capture with out-of-band frequency
        meta = {
            'id': 'test123',
            'filename': 'test.iq',
            'frequency_hz': 100000000,  # 100 MHz - out of ISM
            'sample_rate': 2000000,
            'lna_gain': 32,
            'vga_gain': 20,
            'timestamp': '2026-01-01T00:00:00Z',
        }
        meta_path = tmp_data_dir / 'captures' / 'test.json'
        meta_path.write_text(json.dumps(meta))
        (tmp_data_dir / 'captures' / 'test.iq').write_bytes(b'\x00' * 100)

        with patch('shutil.which', return_value='/usr/bin/hackrf_transfer'), \
             patch.object(manager, 'check_hackrf_device', return_value=True):
            manager._hackrf_available = None
            result = manager.transmit(capture_id='test123')
            assert result['status'] == 'error'
            assert 'outside allowed TX bands' in result['message']

    def test_transmit_already_running(self, manager, tmp_data_dir):
        import time as _time
        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        manager._rx_process = mock_proc
        # Pre-lock device checks now run before active_mode guard
        manager._hackrf_available = True
        manager._hackrf_device_cache = True
        manager._hackrf_device_cache_ts = _time.time()
        # Capture lookup also runs pre-lock now; provide a valid capture + IQ file
        meta = {
            'id': 'test123',
            'filename': 'test.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2025-01-01T00:00:00',
        }
        (tmp_data_dir / 'captures' / 'test.json').write_text(json.dumps(meta))
        (tmp_data_dir / 'captures' / 'test.iq').write_bytes(b'\x00' * 64)

        result = manager.transmit(capture_id='test123')
        assert result['status'] == 'error'
        assert 'Already running' in result['message']

    def test_transmit_segment_extracts_range(self, manager, tmp_data_dir):
        meta = {
            'id': 'seg001',
            'filename': 'seg.iq',
            'frequency_hz': 433920000,
            'sample_rate': 1000,
            'lna_gain': 24,
            'vga_gain': 20,
            'timestamp': '2026-01-01T00:00:00Z',
            'duration_seconds': 1.0,
            'size_bytes': 2000,
        }
        (tmp_data_dir / 'captures' / 'seg.json').write_text(json.dumps(meta))
        (tmp_data_dir / 'captures' / 'seg.iq').write_bytes(bytes(range(200)) * 10)

        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        mock_timer = MagicMock()
        mock_timer.start = MagicMock()

        with patch('shutil.which', return_value='/usr/bin/hackrf_transfer'), \
             patch.object(manager, 'check_hackrf_device', return_value=True), \
             patch('subprocess.Popen', return_value=mock_proc), \
             patch('utils.subghz.register_process'), \
             patch('threading.Timer', return_value=mock_timer), \
             patch('threading.Thread') as mock_thread_cls:
            mock_thread = MagicMock()
            mock_thread.start = MagicMock()
            mock_thread_cls.return_value = mock_thread

            manager._hackrf_available = None
            result = manager.transmit(
                capture_id='seg001',
                start_seconds=0.2,
                duration_seconds=0.3,
            )

        assert result['status'] == 'transmitting'
        assert result['segment'] is not None
        assert result['segment']['duration_seconds'] == pytest.approx(0.3, abs=0.01)
        assert manager._tx_temp_file is not None
        assert manager._tx_temp_file.exists()


class TestCaptureLibrary:
    def test_list_captures_empty(self, manager):
        captures = manager.list_captures()
        assert captures == []

    def test_list_captures_with_data(self, manager, tmp_data_dir):
        meta = {
            'id': 'cap001',
            'filename': 'test.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'lna_gain': 32,
            'vga_gain': 20,
            'timestamp': '2026-01-01T00:00:00Z',
            'duration_seconds': 5.0,
            'size_bytes': 1024,
            'label': 'test capture',
        }
        (tmp_data_dir / 'captures' / 'test.json').write_text(json.dumps(meta))

        captures = manager.list_captures()
        assert len(captures) == 1
        assert captures[0].capture_id == 'cap001'
        assert captures[0].label == 'test capture'

    def test_get_capture(self, manager, tmp_data_dir):
        meta = {
            'id': 'cap002',
            'filename': 'test2.iq',
            'frequency_hz': 315000000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:00:00Z',
        }
        (tmp_data_dir / 'captures' / 'test2.json').write_text(json.dumps(meta))

        cap = manager.get_capture('cap002')
        assert cap is not None
        assert cap.frequency_hz == 315000000

    def test_get_capture_not_found(self, manager):
        cap = manager.get_capture('nonexistent')
        assert cap is None

    def test_delete_capture(self, manager, tmp_data_dir):
        captures_dir = tmp_data_dir / 'captures'
        iq_path = captures_dir / 'delete_me.iq'
        meta_path = captures_dir / 'delete_me.json'
        iq_path.write_bytes(b'\x00' * 100)
        meta_path.write_text(json.dumps({
            'id': 'del001',
            'filename': 'delete_me.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:00:00Z',
        }))

        assert manager.delete_capture('del001') is True
        assert not iq_path.exists()
        assert not meta_path.exists()

    def test_delete_capture_not_found(self, manager):
        assert manager.delete_capture('nonexistent') is False

    def test_update_label(self, manager, tmp_data_dir):
        meta = {
            'id': 'lbl001',
            'filename': 'label_test.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:00:00Z',
            'label': '',
        }
        meta_path = tmp_data_dir / 'captures' / 'label_test.json'
        meta_path.write_text(json.dumps(meta))

        assert manager.update_capture_label('lbl001', 'Garage Remote') is True

        updated = json.loads(meta_path.read_text())
        assert updated['label'] == 'Garage Remote'
        assert updated['label_source'] == 'manual'

    def test_update_label_not_found(self, manager):
        assert manager.update_capture_label('nonexistent', 'test') is False

    def test_get_capture_path(self, manager, tmp_data_dir):
        captures_dir = tmp_data_dir / 'captures'
        iq_path = captures_dir / 'path_test.iq'
        iq_path.write_bytes(b'\x00' * 100)
        (captures_dir / 'path_test.json').write_text(json.dumps({
            'id': 'pth001',
            'filename': 'path_test.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:00:00Z',
        }))

        path = manager.get_capture_path('pth001')
        assert path is not None
        assert path.name == 'path_test.iq'

    def test_get_capture_path_not_found(self, manager):
        assert manager.get_capture_path('nonexistent') is None

    def test_trim_capture_manual_segment(self, manager, tmp_data_dir):
        captures_dir = tmp_data_dir / 'captures'
        iq_path = captures_dir / 'trim_src.iq'
        iq_path.write_bytes(bytes(range(200)) * 20)  # 4000 bytes at 1000 sps => 2.0s
        (captures_dir / 'trim_src.json').write_text(json.dumps({
            'id': 'trim001',
            'filename': 'trim_src.iq',
            'frequency_hz': 433920000,
            'sample_rate': 1000,
            'lna_gain': 24,
            'vga_gain': 20,
            'timestamp': '2026-01-01T00:00:00Z',
            'duration_seconds': 2.0,
            'size_bytes': 4000,
            'label': 'Weather Burst',
            'bursts': [
                {
                    'start_seconds': 0.55,
                    'duration_seconds': 0.2,
                    'peak_level': 67,
                    'fingerprint': 'abc123',
                    'modulation_hint': 'OOK/ASK',
                    'modulation_confidence': 0.9,
                }
            ],
        }))

        result = manager.trim_capture(
            capture_id='trim001',
            start_seconds=0.5,
            duration_seconds=0.4,
        )

        assert result['status'] == 'ok'
        assert result['capture']['id'] != 'trim001'
        assert result['capture']['size_bytes'] == 800
        assert result['capture']['label'].endswith('(Trim)')
        trimmed_iq = captures_dir / result['capture']['filename']
        assert trimmed_iq.exists()
        trimmed_meta = trimmed_iq.with_suffix('.json')
        assert trimmed_meta.exists()

    def test_trim_capture_auto_burst(self, manager, tmp_data_dir):
        captures_dir = tmp_data_dir / 'captures'
        iq_path = captures_dir / 'auto_src.iq'
        iq_path.write_bytes(bytes(range(100)) * 40)  # 4000 bytes
        (captures_dir / 'auto_src.json').write_text(json.dumps({
            'id': 'trim002',
            'filename': 'auto_src.iq',
            'frequency_hz': 433920000,
            'sample_rate': 1000,
            'lna_gain': 24,
            'vga_gain': 20,
            'timestamp': '2026-01-01T00:00:00Z',
            'duration_seconds': 2.0,
            'size_bytes': 4000,
            'bursts': [
                {'start_seconds': 0.2, 'duration_seconds': 0.1, 'peak_level': 12},
                {'start_seconds': 1.2, 'duration_seconds': 0.25, 'peak_level': 88},
            ],
        }))

        result = manager.trim_capture(capture_id='trim002')
        assert result['status'] == 'ok'
        assert result['segment']['auto_selected'] is True
        assert result['capture']['duration_seconds'] > 0.25

    def test_list_captures_groups_same_fingerprint(self, manager, tmp_data_dir):
        cap_a = {
            'id': 'grp001',
            'filename': 'a.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:00:00Z',
            'dominant_fingerprint': 'deadbeefcafebabe',
        }
        cap_b = {
            'id': 'grp002',
            'filename': 'b.iq',
            'frequency_hz': 433920000,
            'sample_rate': 2000000,
            'timestamp': '2026-01-01T00:01:00Z',
            'dominant_fingerprint': 'deadbeefcafebabe',
        }
        (tmp_data_dir / 'captures' / 'a.json').write_text(json.dumps(cap_a))
        (tmp_data_dir / 'captures' / 'b.json').write_text(json.dumps(cap_b))

        captures = manager.list_captures()
        assert len(captures) == 2
        assert all(c.fingerprint_group.startswith('SIG-') for c in captures)
        assert all(c.fingerprint_group_size == 2 for c in captures)


class TestSweep:
    def test_start_sweep_no_tool(self, manager):
        with patch('shutil.which', return_value=None), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._sweep_available = None
            result = manager.start_sweep()
            assert result['status'] == 'error'

    def test_start_sweep_success(self, manager):
        import time as _time
        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        mock_proc.stdout = MagicMock()

        with patch('shutil.which', return_value='/usr/bin/hackrf_sweep'), \
             patch('subprocess.Popen', return_value=mock_proc), \
             patch('utils.subghz.register_process'):
            manager._sweep_available = None
            manager._hackrf_device_cache = True
            manager._hackrf_device_cache_ts = _time.time()
            result = manager.start_sweep(freq_start_mhz=300, freq_end_mhz=928)
            assert result['status'] == 'started'

            # Signal daemon threads to stop so they don't outlive the test
            manager._sweep_running = False

    def test_stop_sweep_not_running(self, manager):
        result = manager.stop_sweep()
        assert result['status'] == 'not_running'


class TestDecode:
    def test_start_decode_no_hackrf(self, manager):
        with patch('shutil.which', return_value=None), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._hackrf_available = None
            manager._rtl433_available = None
            result = manager.start_decode(frequency_hz=433920000)
            assert result['status'] == 'error'
            assert 'hackrf_transfer' in result['message']

    def test_start_decode_no_rtl433(self, manager):
        def which_side_effect(name):
            if name == 'hackrf_transfer':
                return '/usr/bin/hackrf_transfer'
            return None

        with patch('shutil.which', side_effect=which_side_effect), \
             patch('utils.subghz.get_tool_path', return_value=None):
            manager._hackrf_available = None
            manager._rtl433_available = None
            result = manager.start_decode(frequency_hz=433920000)
            assert result['status'] == 'error'
            assert 'rtl_433' in result['message']

    def test_start_decode_success(self, manager):
        mock_hackrf_proc = MagicMock()
        mock_hackrf_proc.poll.return_value = None
        mock_hackrf_proc.stdout = MagicMock()
        mock_hackrf_proc.stderr = MagicMock()
        mock_hackrf_proc.stderr.readline = MagicMock(return_value=b'')

        mock_rtl433_proc = MagicMock()
        mock_rtl433_proc.poll.return_value = None
        mock_rtl433_proc.stdout = MagicMock()
        mock_rtl433_proc.stderr = MagicMock()
        mock_rtl433_proc.stderr.readline = MagicMock(return_value=b'')

        call_count = [0]

        def popen_side_effect(*args, **kwargs):
            call_count[0] += 1
            if call_count[0] == 1:
                return mock_hackrf_proc
            return mock_rtl433_proc

        def which_side_effect(name):
            return f'/usr/bin/{name}'

        with patch('shutil.which', side_effect=which_side_effect), \
             patch('subprocess.Popen', side_effect=popen_side_effect) as mock_popen, \
             patch('utils.subghz.register_process'):
            import time as _time
            manager._hackrf_available = None
            manager._rtl433_available = None
            manager._hackrf_device_cache = True
            manager._hackrf_device_cache_ts = _time.time()
            result = manager.start_decode(
                frequency_hz=433920000,
                sample_rate=2000000,
            )
            assert result['status'] == 'started'
            assert result['frequency_hz'] == 433920000
            assert manager.active_mode == 'decode'

            # Two processes: hackrf_transfer + rtl_433
            assert mock_popen.call_count == 2

            # Verify hackrf_transfer command
            hackrf_cmd = mock_popen.call_args_list[0][0][0]
            assert os.path.basename(hackrf_cmd[0]) == 'hackrf_transfer'
            assert '-r' in hackrf_cmd

            # Verify rtl_433 command
            rtl433_cmd = mock_popen.call_args_list[1][0][0]
            assert os.path.basename(rtl433_cmd[0]) == 'rtl_433'
            assert '-r' in rtl433_cmd
            assert 'cs8:-' in rtl433_cmd

            # Both processes tracked
            assert manager._decode_hackrf_process is mock_hackrf_proc
            assert manager._decode_process is mock_rtl433_proc

            # Signal daemon threads to stop so they don't outlive the test
            manager._decode_stop = True

    def test_stop_decode_not_running(self, manager):
        result = manager.stop_decode()
        assert result['status'] == 'not_running'

    def test_stop_decode_terminates_both(self, manager):
        mock_hackrf = MagicMock()
        mock_hackrf.poll.return_value = None
        mock_rtl433 = MagicMock()
        mock_rtl433.poll.return_value = None

        manager._decode_hackrf_process = mock_hackrf
        manager._decode_process = mock_rtl433
        manager._decode_frequency_hz = 433920000

        with patch('utils.subghz.safe_terminate') as mock_term, \
             patch('utils.subghz.unregister_process'):
            result = manager.stop_decode()

        assert result['status'] == 'stopped'
        assert manager._decode_hackrf_process is None
        assert manager._decode_process is None
        assert mock_term.call_count == 2


class TestStopAll:
    def test_stop_all_clears_processes(self, manager):
        mock_proc = MagicMock()
        mock_proc.poll.return_value = None
        manager._rx_process = mock_proc

        with patch('utils.subghz.safe_terminate'):
            manager.stop_all()

        assert manager._rx_process is None
        assert manager._decode_hackrf_process is None
        assert manager._decode_process is None
        assert manager._tx_process is None
        assert manager._sweep_process is None


class TestSubGhzCapture:
    def test_to_dict(self):
        cap = SubGhzCapture(
            capture_id='abc123',
            filename='test.iq',
            frequency_hz=433920000,
            sample_rate=2000000,
            lna_gain=32,
            vga_gain=20,
            timestamp='2026-01-01T00:00:00Z',
            duration_seconds=5.0,
            size_bytes=1024,
            label='Test',
        )
        d = cap.to_dict()
        assert d['id'] == 'abc123'
        assert d['frequency_hz'] == 433920000
        assert d['label'] == 'Test'