import { describe, it, expect, vi, beforeEach } from "vitest";

// Mock the database module
vi.mock("../server/db", () => ({
  getDb: vi.fn().mockResolvedValue({
    select: vi.fn().mockReturnThis(),
    from: vi.fn().mockReturnThis(),
    where: vi.fn().mockReturnThis(),
    orderBy: vi.fn().mockReturnThis(),
    limit: vi.fn().mockResolvedValue([
      {
        id: 1,
        gameId: "slot-vikingsgoberserkygg",
        gameName: "Vikings Go Berserk",
        provider: "Yggdrasil",
        rtp: "96.10",
        volatility: "high",
        category: "slots",
        iconUrl: "https://cdn.example.com/vikings.jpg",
        isActive: 1,
        createdAt: new Date("2026-04-08T22:49:00.000Z"),
      },
      {
        id: 2,
        gameId: "slot-wickedcircusygg",
        gameName: "Wicked Circus",
        provider: "Yggdrasil",
        rtp: "96.20",
        volatility: "high",
        category: "slots",
        iconUrl: "https://cdn.example.com/circus.jpg",
        isActive: 1,
        createdAt: new Date("2026-04-08T22:49:00.000Z"),
      },
    ]),
    update: vi.fn().mockReturnThis(),
    set: vi.fn().mockReturnThis(),
    insert: vi.fn().mockReturnThis(),
    values: vi.fn().mockReturnThis(),
  }),
}));

describe("Slot Engine Game Launch", () => {
  it("should generate a slot engine URL with correct parameters", () => {
    const gameId = "slot-vikingsgoberserkygg";
    const gameName = "Vikings Go Berserk";
    const provider = "Yggdrasil";
    const rtp = "96.10";
    const volatility = "high";
    const userId = 42;

    const params = new URLSearchParams({
      name: gameName,
      provider,
      rtp,
      volatility,
      gameId,
      userId: String(userId),
    });
    const launchUrl = `/slot-engine.html?${params.toString()}`;

    expect(launchUrl).toContain("/slot-engine.html");
    expect(launchUrl).toContain("name=Vikings+Go+Berserk");
    expect(launchUrl).toContain("provider=Yggdrasil");
    expect(launchUrl).toContain("rtp=96.10");
    expect(launchUrl).toContain("volatility=high");
    expect(launchUrl).toContain("gameId=slot-vikingsgoberserkygg");
    expect(launchUrl).toContain("userId=42");
  });

  it("should use default values when rtp and volatility are not provided", () => {
    const params = new URLSearchParams({
      name: "Test Game",
      provider: "NextGen",
      rtp: "96",
      volatility: "medium",
      gameId: "slot-testgame",
      userId: "1",
    });
    const launchUrl = `/slot-engine.html?${params.toString()}`;
    expect(launchUrl).toContain("rtp=96");
    expect(launchUrl).toContain("volatility=medium");
  });

  it("should identify slot engine providers correctly", () => {
    const SLOT_ENGINE_PROVIDERS = ["Yggdrasil", "NextGen", "AGS", "PlayGD"];
    expect(SLOT_ENGINE_PROVIDERS.includes("Yggdrasil")).toBe(true);
    expect(SLOT_ENGINE_PROVIDERS.includes("NextGen")).toBe(true);
    expect(SLOT_ENGINE_PROVIDERS.includes("AGS")).toBe(true);
    expect(SLOT_ENGINE_PROVIDERS.includes("PlayGD")).toBe(true);
    expect(SLOT_ENGINE_PROVIDERS.includes("PG Soft")).toBe(false);
    expect(SLOT_ENGINE_PROVIDERS.includes("Pragmatic Play")).toBe(false);
  });
});

describe("New Arrivals", () => {
  it("should return games ordered by createdAt descending", async () => {
    const { getDb } = await import("../server/db");
    const db = await getDb();
    expect(db).not.toBeNull();
    // The mock returns 2 games
    const games = await (db as any).select().from({}).where({}).orderBy({}).limit(12);
    expect(Array.isArray(games)).toBe(true);
    expect(games.length).toBe(2);
    expect(games[0].gameName).toBe("Vikings Go Berserk");
    expect(games[0].provider).toBe("Yggdrasil");
  });

  it("should only return active games", async () => {
    const { getDb } = await import("../server/db");
    const db = await getDb();
    const games = await (db as any).select().from({}).where({}).orderBy({}).limit(12);
    games.forEach((game: any) => {
      expect(game.isActive).toBe(1);
    });
  });

  it("should return games with required fields", async () => {
    const { getDb } = await import("../server/db");
    const db = await getDb();
    const games = await (db as any).select().from({}).where({}).orderBy({}).limit(12);
    games.forEach((game: any) => {
      expect(game).toHaveProperty("gameId");
      expect(game).toHaveProperty("gameName");
      expect(game).toHaveProperty("provider");
      expect(game).toHaveProperty("createdAt");
    });
  });
});