// web_serial_worker.ts
// High-throughput Web Serial Worker with zero-allocation BYOB reader

export class HardwareSerialManager {
  private port: SerialPort | null = null;
  private reader: ReadableStreamBYOBReader | null = null;
  private writer: WritableStreamDefaultWriter<Uint8Array> | null = null;

  async open(baudRate: number = 115200): Promise<void> {
    // Request hardware port filter matching common USB bridges (e.g. CP2102, CH340)
    this.port = await navigator.serial.requestPort({
      filters: [{ usbVendorId: 0x10c4 }, { usbVendorId: 0x1a86 }]
    });

    await this.port.open({
      baudRate,
      dataBits: 8,
      stopBits: 1,
      parity: 'none',
      bufferSize: 16384,
      flowControl: 'none'
    });

    this.startBYOBReadLoop();
  }

  private async startBYOBReadLoop(): Promise<void> {
    if (!this.port?.readable) return;

    // Allocate persistent 4 KB buffer for DMA transfer
    const buffer = new ArrayBuffer(4096);
    this.reader = this.port.readable.getReader({ mode: 'byob' });

    try {
      while (true) {
        const { value, done } = await this.reader.read(new Uint8Array(buffer, 0, buffer.byteLength));
        if (done) break;
        if (value) {
          // Process zero-copy received chunk
          this.handleIncomingChunk(value);
        }
      }
    } finally {
      this.reader.releaseLock();
    }
  }

  async send(data: Uint8Array): Promise<void> {
    if (!this.port?.writable) return;
    this.writer = this.port.writable.getWriter();
    await this.writer.write(data);
    this.writer.releaseLock();
  }

  private handleIncomingChunk(chunk: Uint8Array): void {
    self.postMessage({ type: 'SERIAL_RX', bytes: chunk }, [chunk.buffer]);
  }
}

// cobs_transformer.ts
// WHATWG TransformStream for Consistent Overhead Byte Stuffing (COBS)

export class COBSDecoderStream extends TransformStream<Uint8Array, Uint8Array> {
  constructor() {
    let buffer: number[] = [];

    super({
      transform(chunk: Uint8Array, controller: TransformStreamDefaultController<Uint8Array>) {
        for (let i = 0; i < chunk.length; i++) {
          const byte = chunk[i];
          if (byte === 0x00) {
            // End-of-packet delimiter encountered
            if (buffer.length > 0) {
              const decoded = decodeCOBS(new Uint8Array(buffer));
              controller.enqueue(decoded);
              buffer = [];
            }
          } else {
            buffer.push(byte);
          }
        }
      }
    });
  }
}

function decodeCOBS(src: Uint8Array): Uint8Array {
  const dest: number[] = [];
  let i = 0;
  while (i < src.length) {
    const code = src[i++];
    for (let j = 1; j < code && i < src.length; j++) {
      dest.push(src[i++]);
    }
    if (code < 0xff && i < src.length) dest.push(0x00);
  }
  return new Uint8Array(dest);
}

// main.c — ESP-IDF / C Microcontroller UART Telemetry Streamer
#include "driver/uart.h"
#include "esp_log.h"

#define UART_PORT UART_NUM_0
#define BUF_SIZE (1024)

void app_main(void) {
    uart_config_t uart_config = {
        .baud_rate = 115200,
        .data_bits = UART_DATA_8_BITS,
        .parity    = UART_PARITY_DISABLE,
        .stop_bits = UART_STOP_BITS_1,
        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE
    };
    uart_param_config(UART_PORT, &uart_config);
    uart_driver_install(UART_PORT, BUF_SIZE * 2, 0, 0, NULL, 0);

    while (1) {
        // Broadcast periodic 50Hz telemetry frame
        const char msg[] = "{"telemetry":{"ax":0.02,"ay":-0.98,"az":0.15,"temp":24.5}}
";
        uart_write_bytes(UART_PORT, msg, sizeof(msg) - 1);
        vTaskDelay(pdMS_TO_TICKS(20)); // 20ms = 50Hz
    }
}