#
# NRF24L01+ Enhanced ShockBurst packets decoder
#
payload_len_default = 4
packets = (
    "10101010 11101110 00000011 00001000 00001011 01000111 000100 10 0 10101010 10101010 10101010 10101010 00011101",
    "10101010 11001000 11001000 11000011 110011 10 0 00001011 00000011 00000101 00000000 0010001100100000",
    "10101010 11001000 11001000 11000100 000100 11 1 00001011 00000011 00000101 00000000 0010010011100010",
    "10101010 11001000 11001000 11000100  00001011 00000011 00000101 00000010 1000010101000010",
    "10101010 11001000 11001000 11000000 110011 10 0 11110101 00000010 00000011 00000000 0000111001000000",
    "01010101 01000000 01101000 00010101 000000 00 0 0100100000100000",
    #  '01010101 01000010 11100100 10100110 01010101 01000100 110011 00 0 10010101 10110011 01100100 10101100 10101011 01010010 01111100 01001010 1100110100110001',
)


def bin2hex(x):
    def bin2hex_helper(r):
        while r:
            yield r[0:2].upper()
            r = r[2:]

    if len(x) == 0:
        return
    fmt = "{0:0" + str(int(len(x) / 8 * 2)) + "X}"
    hex_data = fmt.format(int(x, 2))
    return list(bin2hex_helper(hex_data))


def bin2hexlong(b):
    b = b.replace(" ", "")
    out = ""
    n = 8
    for i in range(0, len(b), n):
        b2 = b[i : i + n]
        out = out + "{0:02X}".format(int(b2.ljust(8, "0"), 2))
    return out


def split_packet(packet, parts):
    """Split a string of 1s and 0s into multiple substrings as specified by parts.
    Example: "111000011000", (3, 4, 2) -> ["111", "0000", "11", "000"]
    :param packet: String of 1s and 0s
    :param parts: Tuple of length of substrings
    :return: list of substrings
    """
    out = []
    packet = packet.replace(" ", "")
    for part_length in parts:
        out.append(packet[0:part_length])
        packet = packet[part_length:]
    out.append(packet)
    return out


def parse_packet(packet, address_length, ESB):
    """Split a packet into its fields and return them as tuple."""
    if ESB:
        preamble, address, payload_length, pid, no_ack, rest = split_packet(
            packet=packet, parts=(8, 8 * address_length, 6, 2, 1)
        )
        payload, crc = split_packet(
            packet=rest,
            parts=(
                (
                    payload_len_default
                    if int(payload_length, 2) > 32
                    else int(payload_length, 2)
                )
                * 8,
            ),
        )
    else:
        preamble, address, rest = split_packet(
            packet=packet, parts=(8, 8 * address_length)
        )
        crc = packet.rsplit(" ", 1)[1]
        payload = rest[0 : len(rest) - len(crc)]
        payload_length = pid = no_ack = ""

    assert preamble in ("10101010", "01010101")
    assert len(crc) in (8, 16)

    return preamble, address, payload_length, pid, no_ack, payload, crc


def crc(bits, size=8):
    """Calculate the crc value for the polynomial initialized with 0xFF/0xFFFF)
    :param size: 8 or 16 bit crc
    :param bits: String of 1s and 0s
    :return:
    :polynomial: 1 byte CRC - standard is 0x107 = 0b100000111 = x^8+x^2+x^1+1, result the same for 0x07
    :polynomial: 2 byte CRC - standard is 0x11021 = X^16+X^12+X^5+1, result the same for 0x1021
    """
    if size == 8:
        polynomial = 0x107
        crc = 0xFF
    else:
        polynomial = 0x11021
        crc = 0xFFFF
    max_crc_value = (1 << size) - 1  # e.g. 0xFF for mode 8bit-crc
    for bit in bits:
        bit = int(bit, 2)
        crc <<= 1
        if (crc >> size) ^ bit:  # top most lfsr bit xor current data bit
            crc ^= polynomial
        crc &= max_crc_value  # trim the crc to reject carry over bits
    #        print('{:X}'.format(crc))
    return crc


if __name__ == "__main__":
    for packet in packets:
        fld = packet.split(" ")
        address_length = -1
        ESB = True
        for f in fld:
            if len(f) == 6:
                break
            if len(f) == 0:
                ESB = False
                break
            address_length += 1
        (
            preamble,
            address,
            payload_length,
            pid,
            no_ack,
            payload,
            crc_received,
        ) = parse_packet(packet=packet, address_length=address_length, ESB=ESB)
        crc_size = len(crc_received)
        crc_received = "0x" + "{:X}".format(int(crc_received, 2))
        print(f"Packet: {packet}")
        print(
            "\n".join(
                (
                    f"Hex: {bin2hexlong(packet)}",
                    "Preamble: 0x%X" % int(preamble, 2),
                    f"Address: {address_length} bytes - {bin2hex(address)}",
                )
            )
        )
        if ESB:
            print(
                "\n".join(
                    (
                        f"Payload length in packet: {int(payload_length, 2)}, used: {(payload_len_default if int(payload_length, 2) > 32 else int(payload_length, 2))}",
                        f"Payload: {bin2hex(payload)}",
                        f"Pid: {int(pid, 2)}",
                        f"No_ack: {int(no_ack, 2) == 1}",
                    )
                )
            )
        else:
            print(
                f"Not Enhanced ShockBurst packet, payload length: {int(len(payload) / 8)}"
            )
            print(f"Payload: {bin2hex(payload)}")
        print(f"CRC{crc_size}: {crc_received}")
        crc_calculated = "0x" + "{:X}".format(
            crc(address + payload_length + pid + no_ack + payload, size=crc_size)
        )
        if crc_received == crc_calculated:
            print("CRC is valid!")
        else:
            print(f"CRC mismatch! Calculated CRC is {crc_calculated}.")
        print("-------------")