import { describe, expect, test } from 'bun:test';

import { commandName, compareVersions, EBB } from '../src/ebb.js';

import { commands, connected, makeMachine } from './helpers.js';

/** Scripted transport: responds to each command via a function. */

class FakeTransport {

  constructor(respond) {

    this.respond = respond;

    this.out = [];

    this.sent = [];

  }

  async open() {}

  async close() {}

  async clearInput() {

    this.out = [];

  }

  async write(text) {

    for (const cmd of text.split('\r').filter(Boolean)) {

      this.sent.push(cmd);

      const r = this.respond(cmd);

      if (r != null) this.out.push(...[].concat(r));

    }

  }

  async readLine() {

    return this.out.length ? this.out.shift() : '';

  }

}

const EBB_V = 'EBBv13_and_above EB Firmware Version 3.0.3\r\n';

describe('helpers', () => {

  test('commandName', () => {

    expect(commandName('SM,10,1,1')).toBe('SM');

    expect(commandName('R')).toBe('R');

    expect(commandName('A,1')).toBe('A');

    expect(commandName('QG')).toBe('QG');

  });

  test('compareVersions', () => {

    expect(compareVersions('3.0.2', '3.0.2')).toBe(0);

    expect(compareVersions('3.0.10', '3.0.2')).toBe(1);

    expect(compareVersions('2.9', '3.0.2')).toBe(-1);

  });

});

describe('EBB serial layer', () => {

  test('connects, enters future syntax, reads nickname', async () => {

    const t = new FakeTransport((c) => {

      if (c === 'v') return EBB_V;

      if (c === 'CU,10,1') return 'OK\r\n';

      if (c === 'QT') return 'QT,plotbot\n';

      return `${c.slice(0, 2)}\n`;

    });

    const ebb = new EBB();

    expect(await ebb.connect(t)).toBe(true);

    expect(ebb.version).toBe('3.0.3');

    expect(ebb.name).toBe('plotbot');

    expect(t.sent).toEqual(['v', 'CU,10,1', 'QT']);

  });

  test('rejects firmware older than 3.0.2', async () => {

    const t = new FakeTransport((c) => (c === 'v' ? 'EBBv13_and_above EB Firmware Version 2.8.1\r\n' : 'OK\r\n'));

    const ebb = new EBB();

    expect(await ebb.connect(t)).toBe(false);

    expect(ebb.err).toContain('not supported');

    expect(t.sent).toEqual(['v']); // Nothing else is sent to an unsupported board.

  });

  test('rejects a device that is not an EBB', async () => {

    const t = new FakeTransport(() => 'hello\r\n');

    const ebb = new EBB();

    expect(await ebb.connect(t)).toBe(false);

    expect(t.sent).toEqual(['v', 'v']); // Two identification attempts, as plotink does.

  });

  test('query strips the echoed name; command checks the echo', async () => {

    const t = new FakeTransport((c) => {

      if (c === 'v') return EBB_V;

      if (c === 'QS') return 'QS,1421,-429\n';

      if (c === 'QG') return 'QG,3E\n';

      if (c === 'QE') return 'QE,16,0\n';

      return `${c.split(',')[0]}\n`;

    });

    const ebb = new EBB();

    await ebb.connect(t);

    expect(await ebb.querySteps()).toEqual([1421, -429]);

    expect(await ebb.queryStatusByte()).toBe(0x3e);

    expect(await ebb.motorsQueryEnabled()).toEqual([1, 0]);

    expect(await ebb.command('SM,10,0,0')).toBe(true);

  });

  test('an EBB error stops all further commands', async () => {

    const t = new FakeTransport((c) => {

      if (c === 'v') return EBB_V;

      if (c.startsWith('SM')) return '!8 Err: Unknown command\n';

      return `${c.split(',')[0]}\n`;

    });

    const ebb = new EBB();

    await ebb.connect(t);

    expect(await ebb.command('SM,1,1,1')).toBe(false);

    expect(ebb.err).toContain('Err');

    const before = t.sent.length;

    expect(await ebb.command('SP,0')).toBe(false);

    expect(await ebb.query('QS')).toBe(null);

    expect(t.sent.length).toBe(before); // Nothing more goes to the machine.

  });

  test('a missing reply is a timeout error', async () => {

    const t = new FakeTransport((c) => (c === 'v' ? EBB_V : c === 'QT' ? 'QT\n' : null));

    const ebb = new EBB();

    await ebb.connect(t);

    expect(await ebb.command('SP,1')).toBe(false);

    expect(ebb.err).toContain('timeout');

  });

  test('a reply for a different command is an error', async () => {

    const t = new FakeTransport((c) => (c === 'v' ? EBB_V : 'XX\n'));

    const ebb = new EBB();

    await ebb.connect(t);

    expect(await ebb.command('SP,1')).toBe(false);

    expect(ebb.err).toContain('Unexpected response');

  });

  test('int32 variables round-trip, including negatives', async () => {

    const { nd } = await connected({}, (n) => { n.options.homing = false; });

    for (const v of [0, 1, -1, 123456789, -2147483648, 2147483647]) {

      await nd.machine.varWriteInt32(v, 24);

      expect(await nd.machine.varReadInt32(24)).toBe(v);

    }

  });

});

describe('NextDraw connect sequence', () => {

  test('fresh machine: configures, raises pen, enables motors, sets home', async () => {

    const { sim } = await connected({}, (n) => { n.options.homing = false; });

    expect(commands(sim)).toEqual([

      'v', 'CU,10,1', 'QT',

      'CU,3,1', 'CU,4,16', 'CU,50,0', // connection setup

      'QC', // power check

      'QL,10', 'QL,11', // cached pen configuration (none yet)

      'SC,11,231', 'SC,12,154', 'SC,4,9720', 'SC,5,8280', // servo rates and positions

      'SP,1,45,2', // raise pen on pin B2

      'SC,8,1', 'SL,162,10', 'SL,142,11', // 1 PWM channel; cache pen config

      'CU,60,135', 'QE', 'QE', 'EM,1,1', 'SL,0,12', 'CS', // enable motors at 16x, not homed

      'QL,12', // homed?

      'CS', 'SL,0,24', 'SL,0,25', 'SL,0,26', 'SL,0,27', 'SL,0,28', 'SL,0,29', 'SL,0,30', 'SL,0,31',

      'SL,1,12', // set home here, zero offsets, mark homed

      'QS', 'QL,24', 'QL,25', 'QL,26', 'QL,27', 'QL,28', 'QL,29', 'QL,30', 'QL,31',

      'T3,1,0,0,0,0,0,0,3', // read position and clear accumulators

    ]);

    expect(sim.violations).toEqual([]);

  });

  test('reconnect: pen and homing state are reused, nothing moves', async () => {

    const { nd, sim, clock } = await connected({ startX: 2, startY: 3 });

    await nd.moveto(1, 1);

    await nd.disconnect();

    const n = sim.log.length;

    const { NextDraw } = await import('../src/nextdraw.js');

    const nd2 = new NextDraw({ transport: sim, clock, log: () => {} });

    nd2.interactive();

    expect(await nd2.connect()).toBe(true);

    const cmds = sim.log.slice(n).map((l) => l.cmd);

    expect(cmds.some((c) => /^(SP|SM|T3,[^1]|TD|HM|EM)/.test(c))).toBe(false);

    expect(nd2.currentPos()[0]).toBeCloseTo(1, 3);

    expect(nd2.currentPos()[1]).toBeCloseTo(1, 3);

  });

  test('connect fails cleanly without a machine', async () => {

    const { nd, sim, messages } = makeMachine();

    sim.unplug();

    expect(await nd.connect()).toBe(false);

    expect(nd.plotStatus.stopped).toBe(101);

    expect(messages.join(' ')).toContain('Failed to connect');

  });

  test('errors.connect = true throws instead', async () => {

    const { nd, sim } = makeMachine();

    sim.unplug();

    nd.errors.connect = true;

    await expect(nd.connect()).rejects.toThrow('Failed to connect');

  });

  test('motion API requires a connection', async () => {

    const { nd } = makeMachine();

    await expect(nd.moveto(1, 1)).rejects.toThrow('Not connected');

  });

});