const { LoopbackReceiver } = require("../src/output/loopback");
const dgram = require("dgram");

describe("LoopbackReceiver", () => {
  let receiver;

  beforeEach(async () => {
    receiver = new LoopbackReceiver();
    await receiver.start();
  });

  afterEach(async () => {
    await receiver.stop();
  });

  it("starts and stops listening", () => {
    expect(receiver.isListening()).toBe(true);
  });

  it("captures an ArtDmx packet sent to localhost", async () => {
    // Build a test packet
    const { buildArtDmxPacket } = require("../src/output/artnet");
    const slots = new Array(512).fill(0);
    slots[0] = 42;
    slots[1] = 84;
    const packet = buildArtDmxPacket(3, slots);

    const sendSocket = dgram.createSocket({ type: "udp4", reuseAddr: true });
    await new Promise((resolve) => {
      sendSocket.send(packet, 0, packet.length, 6454, "127.0.0.1", (err) => {
        if (err) console.error(err);
        resolve();
      });
    });

    // Wait for receipt
    await new Promise((r) => setTimeout(r, 200));
    sendSocket.close();

    const packets = receiver.getPackets(3);
    expect(packets.length).toBeGreaterThanOrEqual(1);
    expect(packets[0].dmxData[0]).toBe(42);
    expect(packets[0].dmxData[1]).toBe(84);
  });

  it("getPackets filters by universe", async () => {
    const { buildArtDmxPacket } = require("../src/output/artnet");

    const sendUniverse = (u) => {
      const slots = new Array(512).fill(0);
      slots[0] = u;
      const packet = buildArtDmxPacket(u, slots);
      const s = dgram.createSocket({ type: "udp4", reuseAddr: true });
      return new Promise((resolve) => {
        s.send(packet, 0, packet.length, 6454, "127.0.0.1", (err) => {
          if (err) console.error(err);
          s.close();
          resolve();
        });
      });
    };

    await sendUniverse(1);
    await sendUniverse(2);
    await sendUniverse(1);
    await new Promise((r) => setTimeout(r, 200));

    const u1 = receiver.getPackets(1);
    const u2 = receiver.getPackets(2);
    expect(u1.length).toBe(2);
    expect(u2.length).toBe(1);
  });

  it("clear removes captured packets", async () => {
    const { buildArtDmxPacket } = require("../src/output/artnet");
    const slots = new Array(512).fill(0);
    const packet = buildArtDmxPacket(7, slots);

    const sendSocket = dgram.createSocket({ type: "udp4", reuseAddr: true });
    await new Promise((resolve) => {
      sendSocket.send(packet, 0, packet.length, 6454, "127.0.0.1", (err) => {
        if (err) console.error(err);
        resolve();
      });
    });
    await new Promise((r) => setTimeout(r, 200));
    sendSocket.close();

    expect(receiver.getPackets().length).toBeGreaterThanOrEqual(1);
    receiver.clear();
    expect(receiver.getPackets().length).toBe(0);
  });

  it("getLatest returns the most recent packet for a universe", async () => {
    const { buildArtDmxPacket } = require("../src/output/artnet");

    for (let i = 0; i < 3; i++) {
      const slots = new Array(512).fill(0);
      slots[0] = i * 10;
      const packet = buildArtDmxPacket(9, slots);
      const sendSocket = dgram.createSocket({ type: "udp4", reuseAddr: true });
      await new Promise((resolve) => {
        sendSocket.send(packet, 0, packet.length, 6454, "127.0.0.1", (err) => {
          if (err) console.error(err);
          resolve();
        });
      });
      sendSocket.close();
    }
    await new Promise((r) => setTimeout(r, 200));

    const latest = receiver.getLatest(9);
    expect(latest).not.toBeNull();
    expect(latest.dmxData[0]).toBe(20);
  });
});