import { describe, test, expect, beforeEach } from "bun:test";
import { ConsoleBuffer } from "../src/lib/server/console-buffer";

describe("Console Buffer", () => {
  let buffer: ConsoleBuffer;

  beforeEach(() => {
    buffer = ConsoleBuffer.getInstance();
    buffer.clear();
  });

  test("adds and retrieves messages", () => {
    buffer.addMessage({
      id: "1",
      type: "log",
      message: "Test message",
      timestamp: Date.now(),
    });

    const messages = buffer.getAllMessages();
    expect(messages).toHaveLength(1);
    expect(messages[0].message).toBe("Test message");
  });

  test("retrieves recent messages since timestamp", () => {
    const now = Date.now();

    buffer.addMessage({
      id: "1",
      type: "log",
      message: "Old message",
      timestamp: now - 1000,
    });

    buffer.addMessage({
      id: "2",
      type: "log",
      message: "New message",
      timestamp: now + 1000,
    });

    const recent = buffer.getRecentMessages(now);
    expect(recent).toHaveLength(1);
    expect(recent[0].message).toBe("New message");
  });

  test("marks messages as read", () => {
    buffer.addMessage({
      id: "1",
      type: "log",
      message: "Message 1",
      timestamp: Date.now(),
    });

    buffer.markAsRead();

    buffer.addMessage({
      id: "2",
      type: "log",
      message: "Message 2",
      timestamp: Date.now() + 100,
    });

    const recent = buffer.getRecentMessages();
    expect(recent).toHaveLength(1);
    expect(recent[0].message).toBe("Message 2");
  });

  test("limits buffer to max messages", () => {
    for (let i = 0; i < 150; i++) {
      buffer.addMessage({
        id: `msg-${i}`,
        type: "log",
        message: `Message ${i}`,
        timestamp: Date.now() + i,
      });
    }

    const messages = buffer.getAllMessages();
    expect(messages.length).toBeLessThanOrEqual(100);
    expect(messages[messages.length - 1].message).toContain("149");
  });

  test("clears all messages", () => {
    buffer.addMessage({
      id: "1",
      type: "log",
      message: "Test",
      timestamp: Date.now(),
    });

    buffer.clear();
    const messages = buffer.getAllMessages();
    expect(messages).toHaveLength(0);
  });

  test("detects loading game state", () => {
    buffer.addMessage({
      id: "1",
      type: "log",
      message: "🎮 Starting game",
      timestamp: Date.now(),
    });

    const state = buffer.getGameStateFromMessages();
    expect(state.isLoading).toBe(true);
    expect(state.hasError).toBe(false);
    expect(state.isReady).toBe(false);
  });

  test("detects ready game state", () => {
    buffer.addMessage({
      id: "1",
      type: "log",
      message: "✅ Game started",
      timestamp: Date.now(),
    });

    const state = buffer.getGameStateFromMessages();
    expect(state.isLoading).toBe(false);
    expect(state.hasError).toBe(false);
    expect(state.isReady).toBe(true);
  });

  test("detects error game state", () => {
    buffer.addMessage({
      id: "1",
      type: "error",
      message: "❌ Error: Failed to load",
      timestamp: Date.now(),
    });

    const state = buffer.getGameStateFromMessages();
    expect(state.hasError).toBe(true);
    expect(state.lastError).toContain("Failed to load");
    expect(state.isReady).toBe(false);
  });

  test("handles different message types", () => {
    const types = ["log", "warn", "error", "info"] as const;

    types.forEach((type, index) => {
      buffer.addMessage({
        id: `${index}`,
        type,
        message: `${type} message`,
        timestamp: Date.now() + index,
      });
    });

    const messages = buffer.getAllMessages();
    expect(messages).toHaveLength(4);
    expect(messages.map((m) => m.type)).toEqual(types);
  });

  test("singleton instance", () => {
    const instance1 = ConsoleBuffer.getInstance();
    const instance2 = ConsoleBuffer.getInstance();

    expect(instance1).toBe(instance2);
  });
});