// types.ts
export interface SerialConfig {
  baudRate?: number;
  dataBits?: 7 | 8;
  stopBits?: 1 | 2;
  parity?: 'none' | 'even' | 'odd';
}
 
/**
 * A custom transformer that takes raw string chunks 
 * and groups them by carriage returns/newlines.
 */
class LineBreakTransformer implements Transformer<string, string> {
  private container = '';
 
  transform(chunk: string, controller: TransformStreamDefaultController<string>) {
    this.container += chunk;
    const lines = this.container.split('\r\n');
    
    // Keep the last partial line in the container
    this.container = lines.pop() || '';
    
    // Enqueue complete lines
    lines.forEach(line => controller.enqueue(line));
  }
 
  flush(controller: TransformStreamDefaultController<string>) {
    // Flush any remaining data when the stream closes
    if (this.container) {
      controller.enqueue(this.container);
    }
  }
}
 
export class HardwareCommunicator {
  private port: SerialPort | null = null;
  private reader: ReadableStreamDefaultReader<string> | null = null;
  private writer: WritableStreamDefaultWriter<string> | null = null;
 
  constructor(private config: SerialConfig = { baudRate: 115200 }) {
    this.setupPhysicalDisconnectListener();
  }
 
  private setupPhysicalDisconnectListener() {
    navigator.serial.addEventListener('disconnect', (event) => {
      if (this.port === event.target) {
        console.warn('Hardware was physically unplugged.');
        this.cleanup();
      }
    });
  }
 
  /**
   * Triggers the browser native port selection dialog.
   * MUST be called as a direct result of user interaction (e.g., a click event).
   */
  async connect(): Promise<void> {
    try {
      this.port = await navigator.serial.requestPort();
      await this.port.open(this.config);
 
      // 1. Setup the read pipeline (Raw Bytes -> Text -> Lines)
      const textDecoder = new TextDecoderStream();
      const lineBreaker = new TransformStream(new LineBreakTransformer());
      
      this.port.readable!
        .pipeThrough(textDecoder)
        .pipeThrough(lineBreaker);
 
      this.reader = lineBreaker.readable.getReader();
 
      // 2. Setup the write pipeline (Text -> Raw Bytes)
      const textEncoder = new TextEncoderStream();
      textEncoder.readable.pipeTo(this.port.writable!);
      this.writer = textEncoder.writable.getWriter();
 
      console.log('Successfully bound to hardware port.');
    } catch (error) {
      console.error('Failed to bind port. User canceled or hardware busy:', error);
      throw error;
    }
  }
 
  /**
   * Continuously pulls assembled lines from the hardware.
   */
  async listen(onLine: (line: string) => void): Promise<void> {
    if (!this.reader) throw new Error('Cannot listen: Port not open.');
 
    try {
      while (true) {
        const { value, done } = await this.reader.read();
        if (done) break;
        if (value) onLine(value);
      }
    } catch (error) {
      console.error('Stream reading error:', error);
    } finally {
      this.reader.releaseLock();
    }
  }
 
  /**
   * Transmits a string payload to the device, appending a newline.
   */
  async send(command: string): Promise<void> {
    if (!this.writer) throw new Error('Cannot write: Port not open.');
    
    await this.writer.write(`${command}\r\n`);
  }
 
  private async cleanup() {
    if (this.reader) {
      await this.reader.cancel();
      this.reader.releaseLock();
      this.reader = null;
    }
    if (this.writer) {
      await this.writer.close();
      this.writer.releaseLock();
      this.writer = null;
    }
    if (this.port) {
      await this.port.close();
      this.port = null;
    }
  }
 
  async disconnect() {
    await this.cleanup();
    console.log('Connection closed cleanly.');
  }
}

// Assuming a React-like state or Vanilla JS DOM nodes
const connectBtn = document.getElementById('btn-connect');
const terminalOut = document.getElementById('terminal-output');
 
const comms = new HardwareCommunicator({ baudRate: 115200 });
 
connectBtn?.addEventListener('click', async () => {
  try {
    // This triggers the browser permission dialog
    await comms.connect();
    
    terminalOut.innerText += '\n[SYSTEM] Connected to device.\n';
 
    // Start listening asynchronously. Thanks to our LineBreakTransformer, 
    // 'data' here is a complete, well-formed line from the board.
    comms.listen((data) => {
      terminalOut.innerText += `\n[RX] ${data}`;
      
      // Example: Reacting to specific hardware state
      if (data.includes('BOOT_COMPLETE')) {
        comms.send('GET_TELEMETRY');
      }
    });
 
    // Ping the board
    await comms.send('PING');
    
  } catch (e) {
    alert('Connection failed. Please ensure the device is plugged in and not in use by another program.');
  }
});