#!/usr/bin/env python3
# Copyright (C) 2025 Aaron Brown
# SPDX-License-Identifier: GPL-2.0-only
"""Convert MeshCore JSON radio log to pcapng format.

Usage:
    python3 meshcore_json2pcap.py input.json [output.pcapng]

The JSON input is an array of objects with fields:
    timestamp: milliseconds since epoch
    snr: signal-to-noise ratio (float, dB)
    packet: hex-encoded raw packet bytes

Output is pcapng (section header + interface description + enhanced packet
blocks) using LINKTYPE 147 (DLT_USER0).
A 6-byte radio metadata header is prepended to each packet:
    byte  0:   version (0)
    byte  1:   pad (0)
    bytes 2-3: header length as uint16 LE (6)
    bytes 4-5: SNR as int16 LE (value * 100)
"""

import argparse
import json
import struct
import sys
import os


PCAPNG_SNAPLEN = 65535

# Link-layer type for MeshCore packets.  We use DLT_USER0 (147) because
# Wireshark's Lua API can only register dissectors on built-in encap types
# (USER0-USER15).  This value will be replaced with an officially assigned
# LINKTYPE once one is registered with tcpdump.org -- that change will break
# existing pcapng files.
LINKTYPE_MESHCORE = 147


def _pad4(length):
    """Return the number of padding bytes needed to align to 4 bytes."""
    return (4 - length % 4) % 4


def _write_block(f, block_type, body):
    """Write a pcapng block: type(4) + total_length(4) + body + pad + total_length(4)."""
    pad = _pad4(len(body))
    total_length = 12 + len(body) + pad
    f.write(struct.pack("<II", block_type, total_length))
    f.write(body)
    f.write(b"\x00" * pad)
    f.write(struct.pack("<I", total_length))


def write_pcapng(input_path, output_path, radio_header=True):
    with open(input_path, "r") as f:
        packets = json.load(f)

    with open(output_path, "wb") as f:
        # Section Header Block (SHB)
        shb_body = struct.pack(
            "<IHHq",
            0x1A2B3C4D,  # byte-order magic
            1,            # major version
            0,            # minor version
            -1,           # section length (unspecified)
        )
        _write_block(f, 0x0A0D0D0A, shb_body)

        # Interface Description Block (IDB)
        idb_body = struct.pack(
            "<HHI",
            LINKTYPE_MESHCORE,  # link type
            0,                  # reserved
            PCAPNG_SNAPLEN,
        )
        _write_block(f, 0x00000001, idb_body)

        # Enhanced Packet Blocks (EPB)
        count = 0
        for idx, pkt in enumerate(packets):
            for field in ("timestamp", "packet"):
                if field not in pkt:
                    raise ValueError(
                        f"Packet {idx}: missing required field '{field}'"
                    )

            ts_ms = pkt["timestamp"]
            snr = pkt.get("snr", 0.0)

            try:
                raw = bytes.fromhex(pkt["packet"])
            except ValueError as e:
                raise ValueError(
                    f"Packet {idx}: invalid hex in 'packet' field: {e}"
                ) from e

            # pcapng timestamp: microseconds since epoch as 64-bit,
            # stored as two 32-bit halves (high, low)
            ts_us = ts_ms * 1000
            ts_high = (ts_us >> 32) & 0xFFFFFFFF
            ts_low = ts_us & 0xFFFFFFFF

            if radio_header:
                snr_int = int(round(snr * 100))
                radio_hdr = struct.pack("<BBHh", 0, 0, 6, snr_int)
                frame = radio_hdr + raw
            else:
                frame = raw

            epb_body = struct.pack(
                "<IIIII",
                0,             # interface ID
                ts_high,
                ts_low,
                len(frame),    # captured length
                len(frame),    # original length
            ) + frame
            _write_block(f, 0x00000006, epb_body)
            count += 1

    return count


def main():
    parser = argparse.ArgumentParser(
        description="Convert MeshCore JSON radio log to pcapng format."
    )
    parser.add_argument("input", help="Input JSON file path")
    parser.add_argument(
        "output", nargs="?", default=None,
        help="Output pcapng file path (default: input with .pcapng extension)"
    )
    parser.add_argument(
        "--no-radio-header", action="store_true",
        help="Omit the radio metadata header from each packet"
    )
    args = parser.parse_args()

    input_path = args.input
    if args.output:
        output_path = args.output
    else:
        base, _ = os.path.splitext(input_path)
        output_path = base + ".pcapng"

    count = write_pcapng(input_path, output_path, radio_header=not args.no_radio_header)
    print(f"Wrote {count} packets to {output_path}")


if __name__ == "__main__":
    main()