import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { renderHook, act } from "@testing-library/react";
import { useTauriEvent, useTauriEvents } from "@/hooks/useTauriEvents";

// Mock the listen function
const mockUnlisten = vi.fn();
const mockListen = vi.fn().mockResolvedValue(mockUnlisten);

vi.mock("@tauri-apps/api/event", () => ({
  listen: (...args: unknown[]) => mockListen(...args),
}));

describe("useTauriEvent", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  afterEach(() => {
    vi.clearAllMocks();
  });

  it("subscribes to the specified event on mount", async () => {
    const handler = vi.fn();
    renderHook(() => useTauriEvent("lore-data-changed", handler));

    // Wait for the listen promise to resolve
    await vi.waitFor(() => {
      expect(mockListen).toHaveBeenCalledWith(
        "lore-data-changed",
        expect.any(Function)
      );
    });
  });

  it("calls the handler when event is received", async () => {
    const handler = vi.fn();
    renderHook(() => useTauriEvent("global-shortcut-triggered", handler));

    // Get the callback that was passed to listen
    await vi.waitFor(() => {
      expect(mockListen).toHaveBeenCalled();
    });

    const eventCallback = mockListen.mock.calls[0][1];

    // Simulate receiving an event
    act(() => {
      eventCallback({ payload: "quick-capture" });
    });

    expect(handler).toHaveBeenCalledWith("quick-capture");
  });

  it("calls unlisten on unmount", async () => {
    const handler = vi.fn();
    const { unmount } = renderHook(() =>
      useTauriEvent("lore-data-changed", handler)
    );

    // Wait for subscription to be set up
    await vi.waitFor(() => {
      expect(mockListen).toHaveBeenCalled();
    });

    unmount();

    expect(mockUnlisten).toHaveBeenCalled();
  });
});

describe("useTauriEvents", () => {
  beforeEach(() => {
    vi.clearAllMocks();
  });

  it("subscribes to multiple events", async () => {
    const handlers = {
      "lore-data-changed": vi.fn(),
      "sync-status": vi.fn(),
    };

    renderHook(() => useTauriEvents(handlers));

    await vi.waitFor(() => {
      expect(mockListen).toHaveBeenCalledTimes(2);
    });

    expect(mockListen).toHaveBeenCalledWith(
      "lore-data-changed",
      expect.any(Function)
    );
    expect(mockListen).toHaveBeenCalledWith("sync-status", expect.any(Function));
  });

  it("cleans up all subscriptions on unmount", async () => {
    const handlers = {
      "lore-data-changed": vi.fn(),
      "sync-status": vi.fn(),
    };

    const { unmount } = renderHook(() => useTauriEvents(handlers));

    await vi.waitFor(() => {
      expect(mockListen).toHaveBeenCalledTimes(2);
    });

    unmount();

    // Should call unlisten for each subscription
    expect(mockUnlisten).toHaveBeenCalledTimes(2);
  });
});