import { describe, expect, it, vi } from "vitest";
import { loadWithRecovery } from "./lazy-recovery.js";

function fakeStorage(initial: Record<string, string> = {}) {
  const values = new Map(Object.entries(initial));
  return {
    getItem: (key: string) => values.get(key) ?? null,
    setItem: (key: string, value: string) => void values.set(key, value),
    removeItem: (key: string) => void values.delete(key),
    values,
  };
}

const fetchFailure = () => new TypeError("Failed to fetch dynamically imported module");
const flag = "rakazo:module-reload:pages/Onboarding";

describe("loadWithRecovery", () => {
  it("returns the module and clears the reload flag when the import succeeds", async () => {
    const storage = fakeStorage({ [flag]: "1" });
    const reload = vi.fn();
    const loaded = await loadWithRecovery("pages/Onboarding", async () => "module", {
      storage,
      reload,
    });
    expect(loaded).toBe("module");
    expect(storage.values.has(flag)).toBe(false);
    expect(reload).not.toHaveBeenCalled();
  });

  it("retries the import in place before touching the page", async () => {
    const storage = fakeStorage();
    const reload = vi.fn();
    const load = vi
      .fn<() => Promise<string>>()
      .mockRejectedValueOnce(fetchFailure())
      .mockResolvedValueOnce("module");
    const loaded = await loadWithRecovery("pages/Onboarding", load, {
      storage,
      reload,
      retryDelayMs: 0,
    });
    expect(loaded).toBe("module");
    expect(load).toHaveBeenCalledTimes(2);
    expect(reload).not.toHaveBeenCalled();
    expect(storage.values.has(flag)).toBe(false);
  });

  it("reloads the page once when the retry fails as well", async () => {
    const storage = fakeStorage();
    const reload = vi.fn();
    const load = vi.fn<() => Promise<string>>().mockRejectedValue(fetchFailure());
    const pending = loadWithRecovery("pages/Onboarding", load, {
      storage,
      reload,
      retryDelayMs: 0,
    });
    const outcome = await Promise.race([
      pending.then(() => "resolved"),
      new Promise<string>((resolve) => setTimeout(() => resolve("still pending"), 20)),
    ]);
    expect(outcome).toBe("still pending");
    expect(load).toHaveBeenCalledTimes(2);
    expect(reload).toHaveBeenCalledTimes(1);
    expect(storage.values.get(flag)).toBe("1");
  });

  it("surfaces the failure instead of reloading again after a reload did not help", async () => {
    const storage = fakeStorage({ [flag]: "1" });
    const reload = vi.fn();
    const failure = fetchFailure();
    const load = vi.fn<() => Promise<string>>().mockRejectedValue(failure);
    await expect(
      loadWithRecovery("pages/Onboarding", load, { storage, reload, retryDelayMs: 0 }),
    ).rejects.toBe(failure);
    expect(reload).not.toHaveBeenCalled();
    expect(storage.values.get(flag)).toBe("1");
  });
});