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

import { createServerStateScopeRuntime } from "../../src/adapters/query-cache/server-state-scope-runtime.ts";

describe("server-state session generation runtime", () => {
  it("fences the old generation before reset and publishes the new scope after reset", async () => {
    let sessionListener: () => void = () => {};
    let completeReset: () => void = () => {};
    const reset = new Promise<void>((resolve) => {
      completeReset = resolve;
    });
    const resetLocal = vi.fn(() => reset);
    let tokenSequence = 0;
    const runtime = createServerStateScopeRuntime({
      session: {
        subscribe(listener) {
          sessionListener = listener;
          return () => {};
        },
      },
      queryInvalidation: {
        invalidate: async () => {},
        beginMutation: () => ({ release: async () => {} }),
        resetLocal,
        dispose() {},
      },
      tokenFactory: () => `scope-token-${String(tokenSequence++).padStart(8, "0")}`,
    });
    const changed = vi.fn();
    runtime.subscribe(changed);
    const before = runtime.getSnapshot();
    const identity = before.identities.intern({ id: "private" });
    identity.acquire();

    sessionListener();
    expect(before.isCurrent()).toBe(false);
    expect(runtime.getSnapshot()).toBe(before);
    expect(changed).not.toHaveBeenCalled();
    await vi.waitFor(() => expect(resetLocal).toHaveBeenCalledOnce());

    completeReset();
    await vi.waitFor(() => expect(changed).toHaveBeenCalledOnce());
    const after = runtime.getSnapshot();
    expect(after.generation).toBe(before.generation + 1);
    expect(after.fingerprint).not.toBe(before.fingerprint);
    expect(after.isCurrent()).toBe(true);
    expect(before.identities.inspect().closed).toBe(true);

    runtime.dispose();
    expect(after.identities.inspect().closed).toBe(true);
  });
});