import type { Transport, OpenOptions } from "./interface";
import type { SerialPort } from "serialport";

export class SerialPortTransport implements Transport {
  constructor(private port: SerialPort) {}

  async open(options: OpenOptions): Promise<void> {
    if (this.port.isOpen) {
      await this.close();
    }

    await new Promise<void>((resolve, reject) => {
      this.port.open((error) => {
        if (error) {
          reject(error);
          return;
        }
        resolve();
      });
    });
    
    await this.updateOptions(options);
  }

  async close(): Promise<void> {
    return new Promise<void>((resolve, reject) => {
      this.port.close((error) => {
        if (error) {
          reject(error);
          return;
        }
        resolve();
      });
    });
  }

  async read(): Promise<Buffer> {
    const data = this.port.read();
    if (data) {
      return Promise.resolve(Buffer.from(data));
    }

    return new Promise((resolve) => {
      this.port.once("readable", () => {
        const data = this.port.read();
        if (data) {
          return resolve(Buffer.from(data));
        }
      });
    });
  }

  async write(data: Buffer): Promise<void> {
    return new Promise<void>((resolve, reject) => {
      this.port.write(data, (error) => {
        if (error) {
          reject(error);
          return;
        }
        resolve();
      });
    });
  }

  private updateOptions(options: OpenOptions): Promise<void> {
    return new Promise<void>((resolve, reject) => {
      if (this.port.baudRate === options.baudRate) {
        resolve();
        return;
      }

      this.port.update(options, (error) => {
        if (error) {
          reject(error);
          return;
        }
        resolve();
      });
    });
  }
}