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

import { SocketSpeak } from "../messages";
import { ManagedSocketError } from "../errors";
import { NON_RECONNECT_CODES, SocketDisconnectCode } from "../constants";

describe("createDataMessage()", () => {
  test("wraps the provided data in a message object", () => {
    const data = { foo: "bar" };
    const message = SocketSpeak.createDataMessage(data);
    expect(message).toEqual({ type: "message", data });
  });
});

describe("createHeartbeatMessage()", () => {
  test("creates a heartbeat message with the current timestamp", () => {
    const message = SocketSpeak.createHeartbeatMessage();
    expect(message.type).toBe("heartbeat");
    expect(message.data).toBeTypeOf("string");
  });
});

describe("serialize()", () => {
  test("serializes a SocketMessage object into a JSON string", () => {
    const message = SocketSpeak.createDataMessage({ foo: "bar" });
    const serialized = SocketSpeak.serialize(message) as string;
    expect(serialized).toBe(JSON.stringify(message));
  });
});

describe("deserialize()", () => {
  test("deserializes a JSON string into a SocketMessage object", () => {
    const message = SocketSpeak.createDataMessage({ foo: "bar" });
    const serialized = SocketSpeak.serialize(message);
    const deserialized = SocketSpeak.deserialize(serialized);
    expect(deserialized).toEqual(message);
  });

  test("throws an error if the JSON string cannot be parsed", () => {
    const invalidData = "invalid";
    expect(() => SocketSpeak.deserialize(invalidData)).toThrow(
      ManagedSocketError,
    );
  });

  test("throws an error if the message shape is invalid", () => {
    const invalidData = JSON.stringify({ type: "invalid" });
    expect(() => SocketSpeak.deserialize(invalidData)).toThrow(
      ManagedSocketError,
    );
  });
});

describe("prepare()", () => {
  test("serializes and wraps the provided data in a message object", () => {
    const data = { foo: "bar" };
    const message = SocketSpeak.prepare(data);
    expect(message).toEqual(SocketSpeak.serialize({ type: "message", data }));
  });
});

describe("isCatatrophicCloseCode()", () => {
  test("returns for codes in the catastrophic list", () => {
    for (const code of NON_RECONNECT_CODES) {
      expect(SocketSpeak.isCatastrophicCloseCode(code)).toBe(true);
    }
  });

  test("returns false for other close codes", () => {
    expect(
      SocketSpeak.isCatastrophicCloseCode(
        SocketDisconnectCode.CLOSE_SERVICE_RESTART,
      ),
    ).toBe(false);
  });
});