"""Tests for BT Locate — Bluetooth SAR Device Location System."""

from unittest.mock import MagicMock, patch

import pytest

try:
    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms
    from cryptography.hazmat.primitives.ciphers import modes as cipher_modes
    HAS_CRYPTOGRAPHY = True
except ImportError:
    HAS_CRYPTOGRAPHY = False

from utils.bt_locate import (
    DistanceEstimator,
    Environment,
    LocateSession,
    LocateTarget,
    get_locate_session,
    resolve_rpa,
    start_locate_session,
    stop_locate_session,
)


class TestResolveRPA:
    """Test BLE Resolvable Private Address resolution."""

    @pytest.mark.skipif(not HAS_CRYPTOGRAPHY, reason="cryptography not installed")
    def test_resolve_rpa_valid_match(self):
        """Test RPA resolution with known IRK/address pair.

        Uses test vector: IRK = all zeros, we generate matching address.
        """
        # The ah() function: encrypt(IRK, 0x00..00 || prand) then take last 3 bytes

        irk = b'\x00' * 16
        # Choose prand with upper 2 bits = 01 (resolvable)
        prand = bytes([0x40, 0x00, 0x01])
        plaintext = b'\x00' * 13 + prand
        c = Cipher(algorithms.AES(irk), cipher_modes.ECB())
        enc = c.encryptor()
        encrypted = enc.update(plaintext) + enc.finalize()
        hash_bytes = encrypted[13:16]

        # Build address: prand || hash
        addr_bytes = prand + hash_bytes
        address = ':'.join(f'{b:02X}' for b in addr_bytes)

        assert resolve_rpa(irk, address) is True

    def test_resolve_rpa_invalid_address(self):
        """Test RPA resolution with non-matching address."""
        irk = b'\x00' * 16
        # Non-resolvable address (upper 2 bits != 01)
        assert resolve_rpa(irk, 'FF:FF:FF:FF:FF:FF') is False

    @pytest.mark.skipif(not HAS_CRYPTOGRAPHY, reason="cryptography not installed")
    def test_resolve_rpa_wrong_irk(self):
        """Test RPA resolution with wrong IRK."""
        irk = b'\x00' * 16
        prand = bytes([0x40, 0x00, 0x01])
        plaintext = b'\x00' * 13 + prand
        c = Cipher(algorithms.AES(irk), cipher_modes.ECB())
        enc = c.encryptor()
        encrypted = enc.update(plaintext) + enc.finalize()
        hash_bytes = encrypted[13:16]
        addr_bytes = prand + hash_bytes
        address = ':'.join(f'{b:02X}' for b in addr_bytes)

        # Different IRK should fail
        wrong_irk = b'\x01' * 16
        assert resolve_rpa(wrong_irk, address) is False

    def test_resolve_rpa_short_address(self):
        """Test with invalid short address."""
        irk = b'\x00' * 16
        assert resolve_rpa(irk, 'AA:BB') is False

    def test_resolve_rpa_empty(self):
        """Test with empty inputs."""
        assert resolve_rpa(b'\x00' * 16, '') is False


class TestDistanceEstimator:
    """Test RSSI-to-distance estimation."""

    def test_free_space_distance(self):
        estimator = DistanceEstimator(path_loss_exponent=2.0, rssi_at_1m=-59)
        # At 1m, RSSI should be -59, so distance should be ~1m
        d = estimator.estimate(-59)
        assert abs(d - 1.0) < 0.01

    def test_weaker_signal_farther(self):
        estimator = DistanceEstimator(path_loss_exponent=2.0)
        d1 = estimator.estimate(-50)
        d2 = estimator.estimate(-70)
        assert d2 > d1

    def test_indoor_closer_estimate(self):
        """Indoor (n=3) should estimate closer distance for same RSSI."""
        free_space = DistanceEstimator(path_loss_exponent=2.0)
        indoor = DistanceEstimator(path_loss_exponent=3.0)
        rssi = -75
        d_free = free_space.estimate(rssi)
        d_indoor = indoor.estimate(rssi)
        # With higher path loss exponent, same RSSI means closer distance
        assert d_indoor < d_free

    def test_proximity_band_immediate(self):
        assert DistanceEstimator.proximity_band(0.5) == 'IMMEDIATE'

    def test_proximity_band_near(self):
        assert DistanceEstimator.proximity_band(3.0) == 'NEAR'

    def test_proximity_band_far(self):
        assert DistanceEstimator.proximity_band(10.0) == 'FAR'


class TestLocateTarget:
    """Test target matching."""

    def test_match_by_mac(self):
        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        device = MagicMock()
        device.device_id = 'other'
        device.address = 'AA:BB:CC:DD:EE:FF'
        device.name = None
        assert target.matches(device) is True

    def test_match_by_mac_case_insensitive(self):
        target = LocateTarget(mac_address='aa:bb:cc:dd:ee:ff')
        device = MagicMock()
        device.device_id = 'other'
        device.address = 'AA:BB:CC:DD:EE:FF'
        device.name = None
        assert target.matches(device) is True

    def test_match_by_mac_without_separators(self):
        target = LocateTarget(mac_address='aabbccddeeff')
        device = MagicMock()
        device.device_id = 'other'
        device.address = 'AA:BB:CC:DD:EE:FF'
        device.name = None
        assert target.matches(device) is True

    def test_match_by_name_pattern(self):
        target = LocateTarget(name_pattern='iPhone')
        device = MagicMock()
        device.device_id = 'other'
        device.address = '00:00:00:00:00:00'
        device.name = "John's iPhone 15"
        assert target.matches(device) is True

    def test_no_match(self):
        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        device = MagicMock()
        device.device_id = 'other'
        device.address = '11:22:33:44:55:66'
        device.name = None
        assert target.matches(device) is False

    def test_match_by_device_id(self):
        target = LocateTarget(device_id='my-device-123')
        device = MagicMock()
        device.device_id = 'my-device-123'
        device.address = '00:00:00:00:00:00'
        device.name = None
        assert target.matches(device) is True

    def test_to_dict(self):
        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF', known_name='Test')
        d = target.to_dict()
        assert d['mac_address'] == 'AA:BB:CC:DD:EE:FF'
        assert d['known_name'] == 'Test'


class TestLocateSession:
    """Test locate session lifecycle."""

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_start_stop(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner

        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session = LocateSession(target, Environment.OUTDOOR)
        session.start()

        assert session.active is True
        mock_scanner.add_device_callback.assert_called_once()

        session.stop()
        assert session.active is False
        mock_scanner.remove_device_callback.assert_called_once()

    @patch('utils.bt_locate.get_bluetooth_scanner')
    @patch('utils.bt_locate.get_current_position')
    def test_detection_creates_trail_point(self, mock_gps, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner
        mock_gps.return_value = None  # No GPS

        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session = LocateSession(target, Environment.OUTDOOR)
        session.start()

        # Simulate device callback
        device = MagicMock()
        device.device_id = 'test'
        device.address = 'AA:BB:CC:DD:EE:FF'
        device.name = 'Test Device'
        device.rssi_current = -65

        session._on_device(device)

        assert session.detection_count == 1
        assert len(session.trail) == 1
        assert session.trail[0].rssi == -65

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_non_matching_device_ignored(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner

        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session = LocateSession(target, Environment.OUTDOOR)
        session.start()

        device = MagicMock()
        device.device_id = 'other'
        device.address = '11:22:33:44:55:66'
        device.name = None
        device.rssi_current = -70

        session._on_device(device)
        assert session.detection_count == 0

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_get_status(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner

        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session = LocateSession(target, Environment.FREE_SPACE)
        session.start()

        status = session.get_status()
        assert status['active'] is True
        assert status['environment'] == 'FREE_SPACE'
        assert status['detection_count'] == 0


class TestModuleLevelSessionManagement:
    """Test module-level session functions."""

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_start_and_get_session(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner

        target = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session = start_locate_session(target)

        assert get_locate_session() is session
        assert session.active is True

        stop_locate_session()
        assert get_locate_session() is None

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_start_replaces_existing_session(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_get_scanner.return_value = mock_scanner

        target1 = LocateTarget(mac_address='AA:BB:CC:DD:EE:FF')
        session1 = start_locate_session(target1)

        target2 = LocateTarget(mac_address='11:22:33:44:55:66')
        session2 = start_locate_session(target2)

        assert get_locate_session() is session2
        assert session1.active is False
        assert session2.active is True

        stop_locate_session()

    @patch('utils.bt_locate.get_bluetooth_scanner')
    def test_start_raises_when_scanner_cannot_start(self, mock_get_scanner):
        mock_scanner = MagicMock()
        mock_scanner.is_scanning = False
        mock_scanner.start_scan.return_value = False
        status = MagicMock()
        status.error = 'No adapter'
        mock_scanner.get_status.return_value = status
        mock_get_scanner.return_value = mock_scanner

        with pytest.raises(RuntimeError):
            start_locate_session(LocateTarget(mac_address='AA:BB:CC:DD:EE:FF'))