intercept/tests/test_dsc.py

"""Tests for DSC (Digital Selective Calling) utilities."""

import json

import pytest


class TestDSCParser:
    """Tests for DSC parser utilities."""

    def test_get_country_from_mmsi_ship_station(self):
        """Test country lookup for standard ship MMSI."""
        from utils.dsc.parser import get_country_from_mmsi

        # UK ships start with 232-235
        assert get_country_from_mmsi("232123456") == "United Kingdom"
        assert get_country_from_mmsi("235987654") == "United Kingdom"

        # US ships start with 303, 338, 366-369
        assert get_country_from_mmsi("366123456") == "USA"
        assert get_country_from_mmsi("369000001") == "USA"

        # Panama (common flag of convenience)
        assert get_country_from_mmsi("351234567") == "Panama"
        assert get_country_from_mmsi("370000001") == "Panama"

        # Norway
        assert get_country_from_mmsi("257123456") == "Norway"

        # Germany
        assert get_country_from_mmsi("211000001") == "Germany"

    def test_get_country_from_mmsi_coast_station(self):
        """Test country lookup for coast station MMSI (starts with 00)."""
        from utils.dsc.parser import get_country_from_mmsi

        # Coast stations: 00 + MID
        assert get_country_from_mmsi("002320001") == "United Kingdom"
        assert get_country_from_mmsi("003660001") == "USA"

    def test_get_country_from_mmsi_group_station(self):
        """Test country lookup for group station MMSI (starts with 0)."""
        from utils.dsc.parser import get_country_from_mmsi

        # Group call: 0 + MID
        assert get_country_from_mmsi("023200001") == "United Kingdom"
        assert get_country_from_mmsi("036600001") == "USA"

    def test_get_country_from_mmsi_unknown(self):
        """Test country lookup returns None for unknown MID."""
        from utils.dsc.parser import get_country_from_mmsi

        assert get_country_from_mmsi("999999999") is None
        assert get_country_from_mmsi("100000000") is None

    def test_get_country_from_mmsi_invalid(self):
        """Test country lookup handles invalid input."""
        from utils.dsc.parser import get_country_from_mmsi

        assert get_country_from_mmsi("") is None
        assert get_country_from_mmsi(None) is None
        assert get_country_from_mmsi("12") is None

    def test_get_distress_nature_text(self):
        """Test distress nature code to text conversion."""
        from utils.dsc.parser import get_distress_nature_text

        assert get_distress_nature_text(100) == "UNDESIGNATED"
        assert get_distress_nature_text(101) == "FIRE"
        assert get_distress_nature_text(102) == "FLOODING"
        assert get_distress_nature_text(103) == "COLLISION"
        assert get_distress_nature_text(106) == "SINKING"
        assert get_distress_nature_text(109) == "PIRACY"
        assert get_distress_nature_text(110) == "MOB"  # Man overboard

    def test_get_distress_nature_text_unknown(self):
        """Test distress nature returns formatted unknown for invalid codes."""
        from utils.dsc.parser import get_distress_nature_text

        assert "UNKNOWN" in get_distress_nature_text(999)
        assert "999" in get_distress_nature_text(999)

    def test_get_distress_nature_text_string_input(self):
        """Test distress nature accepts string input."""
        from utils.dsc.parser import get_distress_nature_text

        assert get_distress_nature_text("101") == "FIRE"
        assert get_distress_nature_text("invalid") == "invalid"

    def test_get_format_text(self):
        """Test format code to text conversion per ITU-R M.493."""
        from utils.dsc.parser import get_format_text

        assert get_format_text(102) == "ALL_SHIPS"
        assert get_format_text(112) == "INDIVIDUAL"
        assert get_format_text(114) == "INDIVIDUAL_ACK"
        assert get_format_text(116) == "GROUP"
        assert get_format_text(120) == "DISTRESS"
        assert get_format_text(123) == "ALL_SHIPS_URGENCY_SAFETY"

    def test_get_format_text_unknown(self):
        """Test format code returns unknown for invalid codes."""
        from utils.dsc.parser import get_format_text

        result = get_format_text(999)
        assert "UNKNOWN" in result

    def test_get_format_text_removed_codes(self):
        """Test that non-ITU format codes are no longer recognized."""
        from utils.dsc.parser import get_format_text

        # These were previously defined but are not ITU-R M.493 specifiers
        for code in [100, 104, 106, 108, 110, 118]:
            result = get_format_text(code)
            assert "UNKNOWN" in result

    def test_get_telecommand_text(self):
        """Test telecommand code to text conversion."""
        from utils.dsc.parser import get_telecommand_text

        assert get_telecommand_text(100) == "F3E_G3E_ALL"
        assert get_telecommand_text(105) == "DATA"
        assert get_telecommand_text(107) == "DISTRESS_ACK"
        assert get_telecommand_text(111) == "TEST"

    def test_get_category_priority(self):
        """Test category priority values."""
        from utils.dsc.parser import get_category_priority

        # Distress has highest priority (0)
        assert get_category_priority("DISTRESS") == 0
        assert get_category_priority("distress") == 0

        # Urgency/safety
        assert get_category_priority("ALL_SHIPS_URGENCY_SAFETY") == 2

        # Routine-level
        assert get_category_priority("ALL_SHIPS") == 5
        assert get_category_priority("GROUP") == 5
        assert get_category_priority("INDIVIDUAL") == 5

        # Unknown gets default high number
        assert get_category_priority("UNKNOWN") == 10

    def test_validate_mmsi_valid(self):
        """Test MMSI validation with valid numbers."""
        from utils.dsc.parser import validate_mmsi

        assert validate_mmsi("232123456") is True
        assert validate_mmsi("366000001") is True
        assert validate_mmsi("002320001") is True  # Coast station
        assert validate_mmsi("023200001") is True  # Group station

    def test_validate_mmsi_invalid(self):
        """Test MMSI validation rejects invalid numbers."""
        from utils.dsc.parser import validate_mmsi

        assert validate_mmsi("") is False
        assert validate_mmsi(None) is False
        assert validate_mmsi("12345678") is False  # Too short
        assert validate_mmsi("1234567890") is False  # Too long
        assert validate_mmsi("abcdefghi") is False  # Not digits
        assert validate_mmsi("000000000") is False  # All zeros

    def test_classify_mmsi(self):
        """Test MMSI classification."""
        from utils.dsc.parser import classify_mmsi

        # Ship stations (start with 2-7)
        assert classify_mmsi("232123456") == "ship"
        assert classify_mmsi("366000001") == "ship"
        assert classify_mmsi("503000001") == "ship"

        # Coast stations (start with 00)
        assert classify_mmsi("002320001") == "coast"

        # Group stations (start with 0, not 00)
        assert classify_mmsi("023200001") == "group"

        # SAR aircraft (start with 111)
        assert classify_mmsi("111232001") == "sar"

        # Aids to Navigation (start with 99)
        assert classify_mmsi("992321001") == "aton"

        # Unknown
        assert classify_mmsi("invalid") == "unknown"
        assert classify_mmsi("812345678") == "unknown"

    def test_parse_dsc_message_distress(self):
        """Test parsing a distress message with ITU format 120."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "dest_mmsi": "002320001",
                "category": "DISTRESS",
                "nature": 101,
                "position": {"lat": 51.5, "lon": -0.1},
                "telecommand1": 100,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "120002032123456101100127",
            }
        )

        msg = parse_dsc_message(raw)

        assert msg is not None
        assert msg["type"] == "dsc_message"
        assert msg["source_mmsi"] == "232123456"
        assert msg["category"] == "DISTRESS"
        assert msg["source_country"] == "United Kingdom"
        assert msg["nature_of_distress"] == "FIRE"
        assert msg["latitude"] == 51.5
        assert msg["longitude"] == -0.1
        assert msg["is_critical"] is True
        assert msg["priority"] == 0

    def test_parse_dsc_message_group(self):
        """Test parsing a group call message."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 116,
                "source_mmsi": "366000001",
                "dest_mmsi": "023200001",
                "category": "GROUP",
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "116023200001366000001117",
            }
        )

        msg = parse_dsc_message(raw)

        assert msg is not None
        assert msg["category"] == "GROUP"
        assert msg["source_country"] == "USA"
        assert msg["is_critical"] is False
        assert msg["priority"] == 5

    def test_parse_dsc_message_individual(self):
        """Test parsing an individual call message."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 112,
                "source_mmsi": "366000001",
                "dest_mmsi": "232123456",
                "category": "INDIVIDUAL",
                "telecommand1": 100,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "112232123456366000001100122",
            }
        )

        msg = parse_dsc_message(raw)

        assert msg is not None
        assert msg["category"] == "INDIVIDUAL"
        assert msg["is_critical"] is False

    def test_parse_dsc_message_invalid_json(self):
        """Test parsing rejects invalid JSON."""
        from utils.dsc.parser import parse_dsc_message

        assert parse_dsc_message("not json") is None
        assert parse_dsc_message("{invalid}") is None

    def test_parse_dsc_message_missing_type(self):
        """Test parsing rejects messages without correct type."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps({"source_mmsi": "232123456"})
        assert parse_dsc_message(raw) is None

        raw = json.dumps({"type": "other", "source_mmsi": "232123456"})
        assert parse_dsc_message(raw) is None

    def test_parse_dsc_message_missing_mmsi(self):
        """Test parsing rejects messages without source MMSI."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps({"type": "dsc"})
        assert parse_dsc_message(raw) is None

    def test_parse_dsc_message_empty(self):
        """Test parsing handles empty input."""
        from utils.dsc.parser import parse_dsc_message

        assert parse_dsc_message("") is None
        assert parse_dsc_message(None) is None
        assert parse_dsc_message("   ") is None

    def test_parse_dsc_message_rejects_non_itu_format(self):
        """Test parser rejects records with non-ITU format specifier."""
        from utils.dsc.parser import parse_dsc_message

        for bad_format in [100, 104, 106, 108, 110, 118, 999]:
            raw = json.dumps(
                {
                    "type": "dsc",
                    "format": bad_format,
                    "source_mmsi": "232123456",
                    "category": "ROUTINE",
                    "raw": "120232123456100127",
                }
            )
            assert parse_dsc_message(raw) is None, f"Format {bad_format} should be rejected"

    def test_parse_dsc_message_rejects_telecommand_out_of_range(self):
        """Test parser rejects records with telecommand out of 100-127 range."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "dest_mmsi": "002320001",
                "category": "DISTRESS",
                "telecommand1": 200,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "120002032123456200127",
            }
        )
        assert parse_dsc_message(raw) is None

    def test_parse_dsc_message_accepts_zero_telecommand(self):
        """Test parser does not drop telecommand with value 100 (truthiness fix)."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 112,
                "source_mmsi": "232123456",
                "dest_mmsi": "366000001",
                "category": "INDIVIDUAL",
                "telecommand1": 100,
                "telecommand2": 100,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "112366000001232123456100100122",
            }
        )

        msg = parse_dsc_message(raw)
        assert msg is not None
        assert msg["telecommand1"] == 100
        assert msg["telecommand2"] == 100

    def test_parse_dsc_message_validates_raw_field(self):
        """Test parser validates raw field structure."""
        from utils.dsc.parser import parse_dsc_message

        # Non-digit raw field
        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "category": "DISTRESS",
                "raw": "12abc",
            }
        )
        assert parse_dsc_message(raw) is None

        # Raw field length not divisible by 3
        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "category": "DISTRESS",
                "raw": "1201",
            }
        )
        assert parse_dsc_message(raw) is None

        # Raw field with non-EOS last token
        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "category": "DISTRESS",
                "raw": "120100",
            }
        )
        assert parse_dsc_message(raw) is None

    def test_parse_dsc_message_accepts_valid_eos_in_raw(self):
        """Test parser accepts all three valid EOS values in raw field."""
        from utils.dsc.parser import parse_dsc_message

        for eos in [117, 122, 127]:
            raw = json.dumps(
                {
                    "type": "dsc",
                    "format": 120,
                    "source_mmsi": "232123456",
                    "dest_mmsi": "002320001",
                    "category": "DISTRESS",
                    "timestamp": "2025-01-15T12:00:00Z",
                    "raw": f"120002032123456{eos:03d}",
                }
            )
            msg = parse_dsc_message(raw)
            assert msg is not None, f"EOS {eos} should be accepted"

    def test_parse_dsc_message_rejects_invalid_mmsi(self):
        """Test parser rejects invalid MMSI values."""
        from utils.dsc.parser import parse_dsc_message

        # All-zeros MMSI
        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "000000000",
                "category": "DISTRESS",
                "raw": "120000000000127",
            }
        )
        assert parse_dsc_message(raw) is None

        # Short MMSI
        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "12345",
                "category": "DISTRESS",
                "raw": "120127",
            }
        )
        assert parse_dsc_message(raw) is None

    def test_parse_dsc_message_nature_zero_not_dropped(self):
        """Test that nature code 0 is not dropped by truthiness check."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 120,
                "source_mmsi": "232123456",
                "dest_mmsi": "002320001",
                "category": "DISTRESS",
                "nature": 0,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "120002032123456000127",
            }
        )

        msg = parse_dsc_message(raw)
        assert msg is not None
        assert msg["nature_code"] == 0

    def test_parse_dsc_message_channel_zero_not_dropped(self):
        """Test that channel value 0 is not dropped by truthiness check."""
        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 112,
                "source_mmsi": "232123456",
                "dest_mmsi": "366000001",
                "category": "INDIVIDUAL",
                "channel": 0,
                "telecommand1": 100,
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "112366000001232123456100122",
            }
        )

        msg = parse_dsc_message(raw)
        assert msg is not None
        assert msg["channel"] == 0

    def test_format_dsc_for_display(self):
        """Test message formatting for display."""
        from utils.dsc.parser import format_dsc_for_display

        msg = {
            "category": "DISTRESS",
            "source_mmsi": "232123456",
            "source_country": "United Kingdom",
            "dest_mmsi": "002320001",
            "nature_of_distress": "FIRE",
            "latitude": 51.5074,
            "longitude": -0.1278,
            "telecommand1_text": "F3E_G3E_ALL",
            "channel": 16,
            "timestamp": "2025-01-15T12:00:00Z",
        }

        output = format_dsc_for_display(msg)

        assert "DISTRESS" in output
        assert "232123456" in output
        assert "United Kingdom" in output
        assert "FIRE" in output
        assert "51.5074" in output
        assert "Channel: 16" in output


class TestDSCDecoder:
    """Tests for DSC decoder utilities."""

    @pytest.fixture
    def decoder(self):
        """Create a DSC decoder instance."""
        # Skip if scipy not available
        pytest.importorskip("scipy")
        pytest.importorskip("numpy")
        from utils.dsc.decoder import DSCDecoder

        return DSCDecoder()

    def test_decode_mmsi_valid(self, decoder):
        """Test MMSI decoding from symbols."""
        # Each symbol is 2 BCD digits
        # To encode MMSI 232123456, we need:
        # 02-32-12-34-56 -> symbols [2, 32, 12, 34, 56]
        symbols = [2, 32, 12, 34, 56]
        result = decoder._decode_mmsi(symbols)
        assert result == "232123456"

    def test_decode_mmsi_with_leading_zeros(self, decoder):
        """Test MMSI decoding handles leading zeros."""
        # Coast station: 002320001
        # Padded to 10 digits: 0002320001
        # BCD pairs: 00-02-32-00-01 -> [0, 2, 32, 0, 1]
        symbols = [0, 2, 32, 0, 1]
        result = decoder._decode_mmsi(symbols)
        assert result == "002320001"

    def test_decode_mmsi_short_symbols(self, decoder):
        """Test MMSI decoding returns None for short symbol list."""
        result = decoder._decode_mmsi([1, 2, 3])
        assert result is None

    def test_decode_mmsi_invalid_symbols(self, decoder):
        """Test MMSI decoding returns None for out-of-range symbols."""
        # Symbols > 99 should cause decode to fail
        symbols = [100, 32, 12, 34, 56]
        result = decoder._decode_mmsi(symbols)
        assert result is None

    def test_decode_position_northeast(self, decoder):
        """Test position decoding for NE quadrant."""
        # Quadrant 10 = NE (lat+, lon+)
        # Position: 51°30'N, 0°10'E
        # lon_deg = symbols[3]*100 + symbols[4] = 0, lon_min = symbols[5] = 10
        symbols = [10, 51, 30, 0, 0, 10, 0, 0, 0, 0]
        result = decoder._decode_position(symbols)

        assert result is not None
        assert result["lat"] == pytest.approx(51.5, rel=0.01)
        assert result["lon"] == pytest.approx(0.1667, rel=0.01)

    def test_decode_position_northwest(self, decoder):
        """Test position decoding for NW quadrant."""
        # Quadrant 11 = NW (lat+, lon-)
        # Position: 40°42'N, 74°00'W (NYC area)
        symbols = [11, 40, 42, 0, 74, 0, 0, 0, 0, 0]
        result = decoder._decode_position(symbols)

        assert result is not None
        assert result["lat"] > 0  # North
        assert result["lon"] < 0  # West

    def test_decode_position_southeast(self, decoder):
        """Test position decoding for SE quadrant."""
        # Quadrant 0 = SE (lat-, lon+)
        symbols = [0, 33, 51, 1, 51, 12, 0, 0, 0, 0]
        result = decoder._decode_position(symbols)

        assert result is not None
        assert result["lat"] < 0  # South
        assert result["lon"] > 0  # East

    def test_decode_position_short_symbols(self, decoder):
        """Test position decoding handles short symbol list."""
        result = decoder._decode_position([10, 51, 30])
        assert result is None

    def test_decode_position_invalid_values(self, decoder):
        """Test position decoding handles invalid values gracefully."""
        # Latitude > 90 should be treated as 0
        symbols = [10, 95, 30, 0, 10, 0, 0, 0, 0, 0]
        result = decoder._decode_position(symbols)
        assert result is not None
        assert result["lat"] == pytest.approx(0.5, rel=0.01)  # 0 deg + 30 min

    def test_bits_to_symbol(self, decoder):
        """Test bit to symbol conversion."""
        # Symbol value is first 7 bits (LSB first)
        # Value 100 = 0b1100100 -> bits [0,0,1,0,0,1,1] -> 3 ones
        # Check bits must make total even -> need 1 more one -> [1,0,0]
        bits = [0, 0, 1, 0, 0, 1, 1, 1, 0, 0]
        result = decoder._bits_to_symbol(bits)
        assert result == 100

    def test_bits_to_symbol_wrong_length(self, decoder):
        """Test bit to symbol returns -1 for wrong length."""
        result = decoder._bits_to_symbol([0, 1, 0, 1, 0])
        assert result == -1

    def test_detect_dot_pattern(self, decoder):
        """Test dot pattern detection with 200+ alternating bits."""
        # Dot pattern requires at least 200 bits / 100 alternations
        decoder.bit_buffer = [1, 0] * 110  # 220 alternating bits
        assert decoder._detect_dot_pattern() is True

    def test_detect_dot_pattern_insufficient(self, decoder):
        """Test dot pattern not detected with insufficient alternations."""
        decoder.bit_buffer = [1, 0] * 40  # Only 80 bits, below 200 threshold
        assert decoder._detect_dot_pattern() is False

    def test_detect_dot_pattern_not_alternating(self, decoder):
        """Test dot pattern not detected without alternation."""
        decoder.bit_buffer = [1, 1, 1, 1, 0, 0, 0, 0] * 5
        assert decoder._detect_dot_pattern() is False

    def test_bounded_phasing_strip(self, decoder):
        """Test that >7 phasing symbols causes decode to return None."""
        # Build message bits: 10 phasing symbols (120) + format + data
        # Each symbol is 10 bits. Phasing symbol 120 = 0b1111000 LSB first
        # 120 in 7 bits LSB-first: 0,0,0,1,1,1,1 + 3 check bits
        # 120 = 0b1111000 -> LSB first: 0,0,0,1,1,1,1 -> ones=4 (even) -> check [0,0,0]
        phasing_bits = [0, 0, 0, 1, 1, 1, 1, 0, 0, 0]  # symbol 120
        # 10 phasing symbols (>7 max)
        decoder.message_bits = phasing_bits * 10
        # Add some non-phasing symbols after (enough for a message)
        # Symbol 112 (INDIVIDUAL) = 0b1110000 LSB-first: 0,0,0,0,1,1,1 -> ones=3 (odd) -> need odd check
        # For simplicity, just add enough bits for the decoder to attempt
        for _ in range(20):
            decoder.message_bits.extend([0, 0, 0, 0, 1, 1, 1, 1, 0, 0])
        result = decoder._try_decode_message()
        assert result is None

    def test_eos_minimum_length(self, decoder):
        """Test that EOS found too early in the symbol stream is skipped."""
        # Build a message where EOS appears at position 5 (< MIN_SYMBOLS_FOR_FORMAT=12)
        # This should not be accepted as a valid message end
        # Symbol 127 (EOS) = 0b1111111 LSB-first: 1,1,1,1,1,1,1 -> ones=7 (odd) -> check needs 1 one
        # Use a simple approach: create symbols directly via _try_decode_message
        # Create 5 normal symbols + EOS at position 5 — should be skipped
        # Followed by more symbols and a real EOS at position 15
        from utils.dsc.decoder import DSCDecoder

        d = DSCDecoder()

        # Build symbols manually: we need _try_decode_message to find EOS too early
        # Symbol 112 = format code. We'll build 10 bits per symbol.
        # Since check bit validation is now active, we need valid check bits.
        # Symbol value 10 = 0b0001010 LSB-first: 0,1,0,1,0,0,0, ones=2 (even) -> check [0,0,0]
        sym_10 = [0, 1, 0, 1, 0, 0, 0, 0, 0, 0]
        # Symbol 127 (EOS) = 0b1111111, ones=7 (odd) -> check needs odd total -> [1,0,0]
        sym_eos = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0]

        # 5 normal symbols + early EOS (should be skipped) + 8 more normal + real EOS
        d.message_bits = sym_10 * 5 + sym_eos + sym_10 * 8 + sym_eos
        result = d._try_decode_message()
        # The early EOS at index 5 should be skipped; the one at index 14
        # is past MIN_SYMBOLS_FOR_FORMAT so it can be accepted.
        # But the message content is garbage, so _decode_symbols will likely
        # return None for other reasons. The key test: it doesn't return a
        # message truncated at position 5.
        # Just verify no crash and either None or a valid longer message
        # (not truncated at the early EOS)
        assert result is None or len(result.get("raw", "")) > 18

    def test_bits_to_symbol_check_bit_validation(self, decoder):
        """Test that _bits_to_symbol rejects symbols with invalid check bits."""
        # Symbol 100 = 0b1100100 LSB-first: 0,0,1,0,0,1,1
        # ones in data = 3, need total even -> check bits need 1 one
        # Valid: [0,0,1,0,0,1,1, 1,0,0] -> total ones = 4 (even) -> valid
        valid_bits = [0, 0, 1, 0, 0, 1, 1, 1, 0, 0]
        assert decoder._bits_to_symbol(valid_bits) == 100

        # Invalid: flip one check bit -> total ones = 5 (odd) -> invalid
        invalid_bits = [0, 0, 1, 0, 0, 1, 1, 0, 0, 0]
        assert decoder._bits_to_symbol(invalid_bits) == -1

    def test_safety_is_critical(self):
        """Test that SAFETY category is marked as critical."""
        import json

        from utils.dsc.parser import parse_dsc_message

        raw = json.dumps(
            {
                "type": "dsc",
                "format": 123,
                "source_mmsi": "232123456",
                "category": "SAFETY",
                "timestamp": "2025-01-15T12:00:00Z",
                "raw": "123232123456100122",
            }
        )
        msg = parse_dsc_message(raw)
        assert msg is not None
        assert msg["is_critical"] is True


class TestDSCConstants:
    """Tests for DSC constants."""

    def test_format_codes_completeness(self):
        """Test that all ITU-R M.493 format specifiers are defined."""
        from utils.dsc.constants import FORMAT_CODES

        # ITU-R M.493 format specifiers (and only these)
        expected_keys = {102, 112, 114, 116, 120, 123}
        assert set(FORMAT_CODES.keys()) == expected_keys

    def test_valid_format_specifiers_set(self):
        """Test VALID_FORMAT_SPECIFIERS matches FORMAT_CODES keys."""
        from utils.dsc.constants import FORMAT_CODES, VALID_FORMAT_SPECIFIERS

        assert set(FORMAT_CODES.keys()) == VALID_FORMAT_SPECIFIERS

    def test_valid_eos_symbols(self):
        """Test VALID_EOS contains the three ITU-defined EOS symbols."""
        from utils.dsc.constants import VALID_EOS

        assert {117, 122, 127} == VALID_EOS

    def test_distress_nature_codes_completeness(self):
        """Test that all distress nature codes are defined."""
        from utils.dsc.constants import DISTRESS_NATURE_CODES

        # ITU-R M.493 distress nature codes
        assert 100 in DISTRESS_NATURE_CODES  # UNDESIGNATED
        assert 101 in DISTRESS_NATURE_CODES  # FIRE
        assert 102 in DISTRESS_NATURE_CODES  # FLOODING
        assert 103 in DISTRESS_NATURE_CODES  # COLLISION
        assert 106 in DISTRESS_NATURE_CODES  # SINKING
        assert 109 in DISTRESS_NATURE_CODES  # PIRACY
        assert 110 in DISTRESS_NATURE_CODES  # MOB

    def test_mid_country_map_completeness(self):
        """Test that common MID codes are defined."""
        from utils.dsc.constants import MID_COUNTRY_MAP

        # Verify some key maritime nations
        assert "232" in MID_COUNTRY_MAP  # UK
        assert "366" in MID_COUNTRY_MAP  # USA
        assert "351" in MID_COUNTRY_MAP  # Panama
        assert "257" in MID_COUNTRY_MAP  # Norway
        assert "211" in MID_COUNTRY_MAP  # Germany
        assert "503" in MID_COUNTRY_MAP  # Australia
        assert "431" in MID_COUNTRY_MAP  # Japan

    def test_vhf_channel_70_frequency(self):
        """Test DSC Channel 70 frequency constant."""
        from utils.dsc.constants import VHF_CHANNELS

        assert VHF_CHANNELS[70] == 156.525

    def test_dsc_modulation_parameters(self):
        """Test DSC modulation constants per ITU-R M.493."""
        from utils.dsc.constants import (
            DSC_BAUD_RATE,
            DSC_MARK_FREQ,
            DSC_SPACE_FREQ,
        )

        assert DSC_BAUD_RATE == 1200
        assert DSC_MARK_FREQ == 2100
        assert DSC_SPACE_FREQ == 1300

    def test_telecommand_codes_full(self):
        """Test TELECOMMAND_CODES_FULL covers 0-127 range."""
        from utils.dsc.constants import TELECOMMAND_CODES_FULL

        assert len(TELECOMMAND_CODES_FULL) == 128
        # Known codes map correctly
        assert TELECOMMAND_CODES_FULL[100] == "F3E_G3E_ALL"
        assert TELECOMMAND_CODES_FULL[107] == "DISTRESS_ACK"
        # Unknown codes map to "UNKNOWN"
        assert TELECOMMAND_CODES_FULL[0] == "UNKNOWN"
        assert TELECOMMAND_CODES_FULL[99] == "UNKNOWN"

    def test_telecommand_formats(self):
        """Test TELECOMMAND_FORMATS contains correct format codes."""
        from utils.dsc.constants import TELECOMMAND_FORMATS

        assert {112, 114, 116, 120, 123} == TELECOMMAND_FORMATS

    def test_min_symbols_for_format(self):
        """Test MIN_SYMBOLS_FOR_FORMAT constant."""
        from utils.dsc.constants import MIN_SYMBOLS_FOR_FORMAT

        assert MIN_SYMBOLS_FOR_FORMAT == 12