"""本批教程的合成计算样例；Python 3 标准库，无网络、无设备写入。"""
import json
import math
import ipaddress
from pathlib import Path


def crc_modbus(data):
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
    return crc


class LengthParser:
    """本文 L 协议：u16 大端长度，不含前缀；允许零长度。"""
    def __init__(self, limit=1024):
        self.buffer = bytearray()
        self.limit = limit

    def feed(self, chunk):
        self.buffer.extend(chunk)
        result = []
        while len(self.buffer) >= 2:
            size = int.from_bytes(self.buffer[:2], 'big')
            if size > self.limit:
                raise ValueError('负载超限')
            if len(self.buffer) < 2 + size:
                break
            result.append(bytes(self.buffer[2:2 + size]))
            del self.buffer[:2 + size]
        return result

    def finish(self):
        if self.buffer:
            raise ValueError('连接结束时存在截断数据')


class DelimiterParser:
    """本文 D 协议：LF 分隔，返回正文不含 LF，允许空行。"""
    def __init__(self, limit=1024):
        self.buffer = bytearray()
        self.limit = limit

    def feed(self, chunk):
        self.buffer.extend(chunk)
        result = []
        while True:
            end = self.buffer.find(b'\n')
            if end < 0:
                if len(self.buffer) > self.limit:
                    raise ValueError('未结束正文超限')
                return result
            if end > self.limit:
                raise ValueError('正文超限')
            result.append(bytes(self.buffer[:end]))
            del self.buffer[:end + 1]

    def finish(self):
        if self.buffer:
            raise ValueError('连接结束时缺少 LF')


def decode_signal(payload, start, length, byte_order, signed=False):
    """只做 DBC 基本取位；不处理复用、浮点和厂商扩展。"""
    if length <= 0:
        raise ValueError('信号长度必须为正')
    value = 0
    bit = start
    for index in range(length):
        if bit < 0 or bit >= len(payload) * 8:
            raise ValueError('信号超出帧范围')
        one = (payload[bit // 8] >> (bit % 8)) & 1
        if byte_order == 'Intel':
            value |= one << index
            bit += 1
        elif byte_order == 'Motorola':
            value = (value << 1) | one
            bit = bit + 15 if bit % 8 == 0 else bit - 1
        else:
            raise ValueError('未知端序')
    if signed and value & (1 << (length - 1)):
        value -= 1 << length
    return value


def expect_error(call):
    try:
        call()
    except ValueError:
        return
    raise AssertionError('预期拒绝的输入被接受')


def main():
    folder = Path(__file__).resolve().parent
    checked = []
    for ident in ['N058', 'N059', 'N060', 'N061']:
        fixture = json.loads((folder / (ident + '.json')).read_text(encoding='utf-8'))['data']
        if ident == 'N058':
            for case in fixture['cases']:
                value = crc_modbus(bytes.fromhex(case['input_hex']))
                assert f'{value:04X}' == case['crc_value']
                assert value.to_bytes(2, 'little') == bytes.fromhex(case['wire_hex'])
        elif ident == 'N059':
            for case in fixture['cases']:
                frame = bytes.fromhex(case['frame_hex'])
                a, b = case['input_range']
                assert crc_modbus(frame[a:b]) == int(case['crc_value'], 16)
                assert int.from_bytes(frame[-2:], 'little') == int(case['crc_value'], 16)
        elif ident == 'N060':
            value = crc_modbus(bytes.fromhex(fixture['input_hex']))
            assert f'{value:04X}' == fixture['crc_value_hex']
            assert value.to_bytes(2, 'little') == bytes.fromhex(fixture['wire_hex'])
            assert fixture['crc_value_hex'].encode('ascii') == bytes.fromhex(fixture['display_ascii_hex'])
        else:
            for case in fixture['vectors']:
                value = crc_modbus(bytes.fromhex(case['input_hex']))
                assert f'{value:04X}' == case['value']
                assert value.to_bytes(2, 'little') == bytes.fromhex(case['wire'])
        checked.append(ident)
    assert crc_modbus(b'123456789') == 0x4B37
    assert crc_modbus(bytes.fromhex('01 03 00 00 00 0A')) != crc_modbus(b'01 03 00 00 00 0A')
    bad = bytearray.fromhex('01 03 02 00 2A 39 9B')
    bad[4] ^= 1
    assert crc_modbus(bad[:-2]) != int.from_bytes(bad[-2:], 'little')

    for cls, stream in [(LengthParser, bytes.fromhex('00 03 41 42 43 00 02 44 45')),
                        (DelimiterParser, b'ABC\nDE\n')]:
        for cut in range(len(stream) + 1):
            parser = cls()
            assert parser.feed(stream[:cut]) + parser.feed(stream[cut:]) == [b'ABC', b'DE']
            parser.finish()
        parser = cls()
        result = []
        for byte in stream:
            result += parser.feed(bytes([byte]))
        assert result == [b'ABC', b'DE']
        parser.finish()
    p = LengthParser()
    assert p.feed(bytes.fromhex('00 03 41 42')) == []
    expect_error(p.finish)
    expect_error(lambda: LengthParser().feed(bytes.fromhex('04 01')))
    expect_error(lambda: DelimiterParser(2).feed(b'ABC\n'))
    assert LengthParser().feed(b'\x00\x00') == [b'']
    assert DelimiterParser().feed(b'\n\n') == [b'', b'']
    checked.append('N048')

    layout = json.loads((folder / 'N062.json').read_text(encoding='utf-8'))['data']
    start = int(layout['flash_start'], 16)
    end = int(layout['flash_end_exclusive'], 16)
    regions = [(int(x['start'], 16), int(x['start'], 16) + int(x['size'], 16)) for x in layout['regions']]
    assert end - start == 65536
    assert regions[0][0] == start and regions[-1][1] == end
    assert all(a[1] <= b[0] for a, b in zip(regions, regions[1:]))
    assert regions[1][0] + int(layout['app_file_size'], 16) == int(layout['app_file_end_exclusive'], 16)
    assert int(layout['app_file_end_exclusive'], 16) <= regions[1][1]
    checked.append('N062')

    signals = json.loads((folder / 'N067.json').read_text(encoding='utf-8'))['data']['signals']
    for signal in signals:
        raw = decode_signal(bytes.fromhex(signal['data_hex']), signal['start_bit'], signal['length'], signal['byte_order'], signal['signed'])
        assert raw == signal['expected_raw']
        assert math.isclose(raw * signal['factor'] + signal['offset'], signal['expected_physical'])
    assert decode_signal(bytes.fromhex('34 12'), 7, 16, 'Motorola') == 13330
    assert decode_signal(bytes.fromhex('9C 0F'), 0, 12, 'Intel', True) == -100
    expect_error(lambda: decode_signal(b'\x00', 7, 16, 'Motorola'))
    checked.append('N067')

    timeline = json.loads((folder / 'N068.json').read_text(encoding='utf-8'))['data']
    first, second = timeline['anchors']
    convert = lambda b: first['a'] + (b - first['b']) * (second['a'] - first['a']) / (second['b'] - first['b'])
    assert convert(first['b']) == first['a']
    assert convert(second['b']) == second['a']
    assert math.isclose(convert(timeline['event']['b']), timeline['event']['b_mapped_to_a'])
    checked.append('N068')
    for case in json.loads((folder / 'N069.json').read_text(encoding='utf-8'))['data']['networks']:
        interface = ipaddress.ip_interface(case['interface'])
        assert str(interface.network) == case['network']
        assert str(interface.network.broadcast_address) == case['broadcast']
    checked.append('N069')
    request = b'Q001 PING\n'
    response = b'Q001 OK\n'
    assert len(request) == 10 and len(response) == 8
    assert request.hex() == '513030312050494e470a'
    checked.extend(['N042', 'N046', 'N047'])
    assert b'01' == bytes.fromhex('30 31')
    assert b'AT\r\n' == bytes.fromhex('41 54 0D 0A')
    print(json.dumps({'result':'通过','mode':'合成样本与纯计算，未操作真实设备','article_ids':checked}, ensure_ascii=False))


if __name__ == '__main__':
    main()
