"""Wire vectors and DSView API boundary tests; no sigrok installation needed."""
import binascii
import importlib
from pathlib import Path
import struct
import sys
import types
import tempfile
import importlib.util
import unittest

ROOT = Path(__file__).resolve().parents[1]
SPEC = importlib.util.spec_from_file_location('dsview_build', ROOT / 'build.py')
BUILD = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(BUILD)
RUNTIME = tempfile.TemporaryDirectory()
BUILD.package_decoders(Path(RUNTIME.name))
(Path(RUNTIME.name) / 'decoders/common/__init__.py').write_text('')


class FakeDecoder:
    def has_channel(self, channel):
        return channel < 2

    def register(self, kind):
        return kind

    def put(self, ss, es, output, data):
        self.emitted.append((ss, es, output, data))


stub = types.ModuleType('sigrokdecode')
stub.Decoder = FakeDecoder
stub.OUTPUT_ANN, stub.OUTPUT_PYTHON, stub.SRD_CONF_SAMPLERATE = 0, 1, 2
previous = sys.modules.get('sigrokdecode')
sys.modules['sigrokdecode'] = stub
sys.path.insert(0, str(Path(RUNTIME.name) / 'decoders'))
try:
    uart = importlib.import_module('set_uart.pd')
    wire = importlib.import_module('common.setgui_decoders.set_uart')
    can = importlib.import_module('set_can.pd')
    cancore = importlib.import_module('common.setgui_decoders.set_can')
    pm = importlib.import_module('pm35_uart.pd')
    gate = importlib.import_module('gate_driver_timing.pd')
    pair_decoder = importlib.import_module('transistor_pair.pd')
    pmcore = importlib.import_module('common.setgui_decoders.pm35_uart')
finally:
    sys.path.pop(0)
    if previous is None:
        del sys.modules['sigrokdecode']
    else:
        sys.modules['sigrokdecode'] = previous

PING = bytes.fromhex('A5 5A 02 08 01 00 00 00 2A 00 34 12 00 00 33 EC 33 04')
BRIDGE = bytes.fromhex('AA 55 08 01 01 67 45 23 01 AA BB FE 14')


def crc32_frame(header, payload=b''):
    data = header + payload
    return data + struct.pack('<I', binascii.crc32(data[2:]) & 0xffffffff)


def modbus(raw):
    return raw + struct.pack('<H', wire.crc16(raw, True))


def feed(parser, raw):
    events = []
    for i, byte in enumerate(raw):
        events.extend(parser.feed(byte, i * 10, i * 10 + 9))
    return events


def instance(module, **options):
    decoder = module.Decoder()
    decoder.options = {item['id']: item['default'] for item in decoder.options}
    decoder.options.update(options)
    decoder.emitted = []
    decoder.metadata(2, 1000000)
    decoder.start()
    return decoder


def uart_bytes(decoder, raw, direction=0, base=0):
    for i, byte in enumerate(raw):
        ss = base + i * 100
        decoder.decode(ss, ss+80, ('DATA', direction, (byte, [])))
        decoder.decode(ss, ss+90, ('FRAME', direction, (byte, True)))


def frames(decoder):
    return [item[3][1] for item in decoder.emitted if item[2] == 1]


class WireTests(unittest.TestCase):
    def test_reference_crc(self):
        self.assertEqual(wire.crc16(b'123456789'), 0x29b1)
        self.assertEqual(wire.crc16(b'123456789', True), 0x4b37)

    def test_documented_ping(self):
        result = wire.parse_frame(PING)
        self.assertEqual((result['destination'], result['sequence']), (42, 0x1234))

    def test_documented_bridge(self):
        result = wire.parse_frame(BRIDGE)
        self.assertEqual((result['can_id'], result['payload']), (0x1234567, b'\xaa\xbb'))

    def test_v1_big_endian_header(self):
        frame = crc32_frame(bytes.fromhex('a55a010c12340003'), b'abc')
        result = wire.parse_frame(frame)
        self.assertEqual(result['sequence'], 0x1234)
        self.assertIn('FIRMWARE_DATA', result['summary'])

    def test_noise_crc_and_resync(self):
        damaged = bytearray(PING)
        damaged[-1] ^= 1
        events = feed(wire.StreamParser(), b'noise\xa5' + damaged + PING + BRIDGE)
        self.assertEqual(sum(e[2] is not None for e in events), 2)
        self.assertTrue(any(e[3] and 'CRC' in e[3] for e in events))

    def test_bad_version_and_length(self):
        events = feed(wire.StreamParser(), bytes.fromhex('a55aff a55a010100000201') + PING)
        self.assertEqual(sum(e[2] is not None for e in events), 1)
        self.assertGreaterEqual(sum(bool(e[3]) for e in events), 2)

    def test_max_payload(self):
        raw = crc32_frame(bytes.fromhex('a55a020009000000000001000002'), bytes(range(256))*2)
        events = feed(wire.StreamParser(), raw)
        self.assertEqual(len(events), 1)
        self.assertEqual(len(events[0][2]['payload']), 512)

    def test_unknown_message_preserved(self):
        raw = crc32_frame(bytes.fromhex('a55a020034120000000001000000'))
        self.assertEqual(wire.parse_frame(raw)['message_type'], 0x1234)

    def test_uart_directions_are_independent(self):
        decoder = instance(uart)
        for i, byte in enumerate(PING):
            decoder.decode(i*10, i*10+9, ('FRAME', 0, (byte, True)))
            decoder.decode(i*10, i*10+9, ('FRAME', 1, (byte, True)))
        self.assertEqual([f['direction'] for f in frames(decoder)], [0, 1])

    def test_uart_invalid_last_byte_not_emitted(self):
        decoder = instance(uart)
        uart_bytes(decoder, PING[:-1])
        decoder.decode(2000, 2090, ('FRAME', 0, (PING[-1], False)))
        self.assertFalse(frames(decoder))
        uart_bytes(decoder, PING, base=3000)
        self.assertEqual(len(frames(decoder)), 1)

    def test_uart_gap_discards_partial(self):
        decoder = instance(uart)
        uart_bytes(decoder, PING[:10])
        uart_bytes(decoder, PING, base=200000)
        self.assertEqual(len(frames(decoder)), 1)


class CanTests(unittest.TestCase):
    def segments(self, packet=PING):
        yield bytes([0x10]) + struct.pack('<H', len(packet)) + packet[:5]
        for i, offset in enumerate(range(5, len(packet), 7), 1):
            yield bytes([0x20 | (i & 15)]) + packet[offset:offset+7]

    def test_set_reassembly(self):
        decoder = instance(can, protocol='set-v2')
        for i, data in enumerate(self.segments()):
            decoder.decode(i*1000, i*1000+900, ('extended', 0x122a0000, 'data', len(data), list(data)))
        self.assertEqual(frames(decoder)[-1]['raw'], PING)

    def test_missing_segment(self):
        reader = cancore.Reassembler()
        parts = list(self.segments())
        reader.feed(0x122a0000, parts[0], 0, 9, 0)
        events = reader.feed(0x122a0000, parts[2], 10, 19, 1)
        self.assertIn('sequence', events[-1][3])
        self.assertFalse(reader.pending)

    def test_timeout_and_new_first(self):
        reader = cancore.Reassembler()
        first = next(self.segments())
        reader.feed(0x122a0000, first, 0, 9, 0)
        events = reader.feed(0x122a0000, first, 20, 29, 500)
        self.assertIn('timeout', events[0][3])
        self.assertEqual(reader.pending[0x122a0000]['start'], 20)

    def test_id_mismatch(self):
        reader = cancore.Reassembler()
        for i, part in enumerate(self.segments()):
            events = reader.feed(0x122b0000, part, i*10, i*10+9, i)
        self.assertIn('disagree', events[-1][3])

    def test_sequence_wrap(self):
        packet = crc32_frame(bytes.fromhex('a55a0200010000002a0001008000'), bytes(128))
        reader = cancore.Reassembler()
        for i, part in enumerate(self.segments(packet)):
            events = reader.feed(0x122a0000, part, i*10, i*10+9, i)
        self.assertEqual(events[-1][2]['raw'], packet)

    def test_interleaved_channels(self):
        reader = cancore.Reassembler()
        complete = []
        for i, part in enumerate(self.segments()):
            for channel in (0, 1):
                complete += reader.feed(0x122a0000 | channel, part, i*10, i*10+9, i)
        self.assertEqual(sum(bool(e[2] and 'raw' in e[2]) for e in complete), 2)

    def test_gas(self):
        result = cancore.legacy(0x1b530010, b'\x34\x12\xfe\xff')
        self.assertEqual(result['registers'], [(16, 0x1234), (17, 0xfffe)])
        with self.assertRaises(ValueError):
            cancore.legacy(0x1b530010, b'\x00')

    def test_balsam_mask_and_endianness(self):
        result = cancore.legacy(0xba0010, bytes.fromhex('a01012340000ffff'), 'balsam')
        self.assertEqual(result['registers'], [(16, 0x1234), (18, 0xffff)])
        self.assertIsNone(cancore.legacy(0xba000f, bytes(8), 'balsam'))

    def test_ignore_standard_and_remote(self):
        decoder = instance(can)
        decoder.decode(0, 9, ('standard', 0x123, 'data', 0, []))
        decoder.decode(10, 19, ('extended', 0x1b530010, 'remote', 0, []))
        self.assertFalse(decoder.emitted)

    def test_boot_vectors(self):
        self.assertIn('ENTER_BOOT', cancore.legacy(0x13590702, b'')['summary'])
        self.assertIn('offset=0x8', cancore.legacy(0x135b0001, bytes.fromhex('1011121314151617'))['summary'])
        self.assertIn('status=0', cancore.legacy(0x1b5c0702, bytes.fromhex('00ff000000000000'))['summary'])


class PM35Tests(unittest.TestCase):
    def test_single_wire_auto(self):
        reader = pmcore.PM35Parser('auto')
        raw = modbus(bytes.fromhex('100300000002')) + modbus(bytes.fromhex('1003041234ffff'))
        events = feed(reader, raw)
        self.assertEqual(len(events), 2)
        self.assertTrue(all(event[2] for event in events))

    def test_request_and_response(self):
        request = modbus(bytes.fromhex('100300000002'))
        response = modbus(bytes.fromhex('1003041234ffff'))
        decoder = instance(pm)
        uart_bytes(decoder, request, 1)
        uart_bytes(decoder, response, 0, 10000)
        self.assertEqual(len(frames(decoder)), 2)
        self.assertEqual(frames(decoder)[1]['values'], [0x1234, 65535])

    def test_128_word_legacy_reply(self):
        events = feed(pmcore.PM35Parser('response'), modbus(b'\x10\x03\x00' + bytes(256)))
        self.assertEqual(len(events[0][2]['values']), 128)

    def test_write_command(self):
        result = pmcore.parse_pm35(modbus(bytes.fromhex('1006007f8000')), 'request')
        self.assertIn('command_bits=8000', result['summary'])

    def test_exception(self):
        result = pmcore.parse_pm35(modbus(bytes.fromhex('108302')), 'response')
        self.assertIn('exception', result['summary'])

    def test_crc_and_range_errors(self):
        with self.assertRaisesRegex(ValueError, 'CRC'):
            pmcore.parse_pm35(bytes.fromhex('1003000000010000'), 'request')
        with self.assertRaisesRegex(ValueError, 'range'):
            pmcore.parse_pm35(modbus(bytes.fromhex('1003007f0002')), 'request')


class GateAdapterTests(unittest.TestCase):
    def test_wait_releases_dsview_shared_pin_tuple(self):
        for channels, pair in (((1,), 0), ((0, 1), 0), ((0, 1), 1)):
            with self.subTest(channels=channels, pair=pair):
                decoder = instance(pair_decoder if pair else gate)
                decoder.has_channel = lambda channel: channel in channels
                shared_pins = tuple([0, 0])
                calls = []

                def wait(conditions):
                    # Native DSView owns one reference and PyTuple_SetItem
                    # rejects any reference retained by the previous caller.
                    self.assertEqual(sys.getrefcount(shared_pins), 2)
                    if len(calls) == 3:
                        raise StopIteration
                    calls.append(conditions)
                    decoder.samplenum = len(calls) * 10
                    decoder.matched = 0
                    return shared_pins

                decoder.wait = wait
                with self.assertRaises(StopIteration):
                    decoder.decode()
                self.assertEqual(len(calls), 3)

    def test_orphan_filter_boundaries_profiles_and_polarities(self):
        for profile in ('1SP0635', '1SD536F2'):
            for active_high in (True, False):
                with self.subTest(profile=profile, active_high=active_high):
                    checker = gate.TimingChecker(1_000_000_000, profile=profile,
                        vstat_active_high=active_high, orphan_min_width_ns=50)
                    for start, width, expected in ((100, 20, []), (200, 49, []),
                                                    (300, 50, ['orphan']), (400, 51, ['orphan'])):
                        self.assertEqual(checker.on_status_edge(start, int(active_high)), [])
                        events = checker.on_status_edge(start + width, int(not active_high))
                        self.assertEqual([event['kind'] for event in events], expected)
                    self.assertIsNone(checker.status_start)

    def test_orphan_filter_preserves_ack_errors_faults_and_missing_ack(self):
        checker = gate.TimingChecker(1_000_000_000, orphan_min_width_ns=10_000)
        checker.on_control_edge(0, 1)
        self.assertEqual(checker.on_status_edge(250, 1)[0]['kind'], 'delay_ok')
        self.assertEqual(checker.on_status_edge(950, 0)[0]['kind'], 'width_ok')
        checker.on_control_edge(1000, 0)
        checker.on_status_edge(1250, 1)
        self.assertEqual(checker.on_status_edge(1270, 0)[0]['kind'], 'width_fail')
        checker.on_status_edge(2000, 1)
        self.assertEqual(checker.on_status_edge(4000, 0)[0]['kind'], 'fault')
        checker.on_control_edge(5000, 1)
        self.assertEqual(checker.expire(checker.next_deadline())[0]['kind'], 'missing')

    def test_orphan_filter_default_disabled_and_unknown_duration_retained(self):
        checker = gate.TimingChecker(1_000_000_000)
        checker.on_status_edge(10, 1)
        self.assertEqual(checker.on_status_edge(30, 0)[0]['short'], 'ORPHAN 20.0 ns')
        checker = gate.TimingChecker(1_000_000_000, orphan_min_width_ns=50)
        # A recording starting within a pulse gives no measurable pulse width.
        self.assertEqual(checker.on_status_edge(10, 0)[0]['short'], 'Vstat?')

    def test_orphan_filter_rejects_invalid_thresholds(self):
        for value in (-1, float('nan'), float('inf')):
            with self.subTest(value=value), self.assertRaisesRegex(ValueError, 'ORPHAN'):
                gate.TimingChecker(100_000_000, orphan_min_width_ns=value)

    def test_orphan_filter_option_through_native_edge_api(self):
        decoder = instance(gate, orphan_min_width_ns=50)
        decoder.metadata(2, 100_000_000)
        decoder.samplenum = 0
        samples = iter([(10, 1), (12, 0), (20, 1), (25, 0)])
        def wait(conditions):
            decoder.samplenum, level = next(samples)
            decoder.matched = 2
            return 0, level
        decoder.wait = wait
        with self.assertRaises(StopIteration):
            decoder.decode()
        self.assertEqual(len(decoder.emitted), 1)
        self.assertEqual(decoder.emitted[0][:2], (20, 25))
        self.assertEqual(decoder.emitted[0][3][1][1], 'ORPHAN 50.0 ns')

    def test_profiles_through_native_edge_api(self):
        for profile, active, edges, expected in [
            ('1SP0635', 'high', [(100, 1, 0, 1), (125, 1, 1, 2), (195, 1, 0, 2)], 700),
            ('1SD536F2', 'low', [(20, 1, 1, 1), (58, 1, 0, 2), (148, 1, 1, 2)], 900),
        ]:
            with self.subTest(profile=profile):
                decoder = instance(gate, profile=profile, vstat_active=active)
                decoder.metadata(2, 100_000_000)
                decoder.samplenum = 0
                samples = iter(edges)
                def wait(conditions):
                    decoder.samplenum, vin, vstat, decoder.matched = next(samples)
                    return vin, vstat
                decoder.wait = wait
                with self.assertRaises(StopIteration):
                    decoder.decode()
                self.assertEqual([item[3][0] for item in decoder.emitted], [0, 1, 2])
                self.assertIn(str(expected), decoder.emitted[-1][3][1][0])

    def test_driver_has_no_pair_controls(self):
        decoder = instance(gate)
        self.assertNotIn('pair_analysis', decoder.options)
        self.assertNotIn('vin2_mintime_ns', decoder.options)
        self.assertEqual([c['id'] for c in gate.Decoder.optional_channels], ['vin', 'vstat'])

    def test_pair_decoder_without_vstat(self):
        decoder = instance(pair_decoder, vin2_mintime_ns=200, deadtime_12_ns=50)
        decoder.metadata(2, 1_000_000_000)
        samples = iter([(0, (0, 0)), (10, (1, 0)), (110, (0, 0)),
                        (140, (0, 1)), (240, (0, 0)), (280, (1, 0))])
        def wait(conditions):
            decoder.samplenum, pins = next(samples)
            return pins
        decoder.wait = wait
        with self.assertRaises(StopIteration):
            decoder.decode()
        text = ' '.join(item[3][1][0] for item in decoder.emitted)
        self.assertIn('Deadtime Vin1 -> Vin2: 30.0 ns', text)
        self.assertIn('FAIL: Vin2 active', text)
        self.assertIn('duty', text)
        self.assertNotIn('ACK', text)
        self.assertTrue(any(e[3][0] == 3 for e in decoder.emitted))
        decoder.reset()
        self.assertIsNone(decoder.checker)

    def test_status_only_and_pair_requires_two_inputs(self):
        decoder = instance(gate)
        decoder.has_channel = lambda channel: channel == 1
        samples = iter([(10, 1), (1010, 0)])
        def wait(conditions):
            self.assertEqual(conditions, [{1: 'e'}])
            decoder.samplenum, status = next(samples)
            decoder.matched = 1
            return (255, status, 255)
        decoder.wait = wait
        with self.assertRaises(StopIteration):
            decoder.decode()
        self.assertEqual(len(decoder.emitted), 1)
        decoder = instance(pair_decoder)
        decoder.has_channel = lambda channel: channel == 0
        with self.assertRaisesRegex(ValueError, 'Vin1 and Vin2'):
            decoder.decode()

    def test_missing_ack_timer_emits_error(self):
        decoder = instance(gate)
        decoder.metadata(2, 100_000_000)
        decoder.samplenum = 0
        calls = []
        def wait(conditions):
            calls.append(conditions)
            if len(calls) == 1:
                decoder.samplenum, decoder.matched = 100, 1
            elif len(calls) == 2:
                decoder.samplenum += conditions[2]['skip']
                decoder.matched = 4
            else:
                raise StopIteration
            return 1, 0
        decoder.wait = wait
        with self.assertRaises(StopIteration):
            decoder.decode()
        self.assertEqual([item[3][0] for item in decoder.emitted], [0, 4])

    def test_packaged_core_matches_canonical_templates(self):
        canonical = ROOT.parents[1] / 'python/logic_analyzer/decoders'
        packaged = Path(RUNTIME.name) / 'decoders/common/setgui_decoders'
        for name in ('gate_timing', 'transistor_pair', 'set_uart', 'set_can', 'pm35_uart'):
            self.assertEqual((canonical / (name + '.py')).read_bytes(),
                             (packaged / (name + '.py')).read_bytes())


if __name__ == '__main__':
    unittest.main()