import { describe, expect, it, vi, beforeEach, afterEach } from "bun:test";
import { renderHook, act } from "@testing-library/react";
import { useSWR } from "../src/index";

const fetcher = vi.fn((key: string) => Promise.resolve(`data-${key}`));

describe("useSWR (React)", () => {
    beforeEach(() => {
        vi.useFakeTimers();
        fetcher.mockClear();
    });


    it("fetches data on mount", async () => {
        const { result } = renderHook(() => useSWR("test-key", fetcher));

        expect(result.current.isLoading).toBe(true);

        await act(async () => {
            await vi.runAllTimers();
        });

        expect(result.current.data).toBe("data-test-key");
        expect(result.current.isLoading).toBe(false);
    });

    it("deduplicates requests", async () => {
        const { result: r1 } = renderHook(() => useSWR("dedupe-key", fetcher));
        const { result: r2 } = renderHook(() => useSWR("dedupe-key", fetcher));

        await act(async () => {
            await vi.runAllTimers();
        });

        expect(fetcher).toHaveBeenCalledTimes(1);
        expect(r1.current.data).toBe("data-dedupe-key");
        expect(r2.current.data).toBe("data-dedupe-key");
    });

    it("mutates data manually", async () => {
        const { result } = renderHook(() => useSWR("mutate-key", fetcher));

        await act(async () => {
            await vi.runAllTimers();
        });

        expect(result.current.data).toBe("data-mutate-key");

        await act(async () => {
            await result.current.mutate("new-data");
            await vi.runAllTimers();
        });

        expect(result.current.data).toBe("new-data");
    });

    // it("handles errors", async () => {
    //     const error = new Error("failed");
    //     fetcher.mockImplementationOnce(() => Promise.reject(error));

    //     const { result } = renderHook(() => useSWR("error-key", fetcher));

    //     await act(async () => {
    //         await vi.runAllTimers();
    //     });

    //     expect(result.current.error).toBe(error);
    //     expect(result.current.isLoading).toBe(false);
    // });
});