import { describe, expect, it, vi } from "vitest";
import { createBobbinClient, type BobbinContext } from "./client";
import { IdentityCache, type MiniDoc } from "./identity";

const DOC: MiniDoc = { did: "did:plc:x", handle: "alice.test" };

const docResponse = (doc: MiniDoc): Response =>
	new Response(JSON.stringify(doc), {
		status: 200,
		headers: { "content-type": "application/json" }
	});

const makeCtx = (fetchMock: typeof globalThis.fetch): BobbinContext =>
	createBobbinClient({ serviceUrl: "https://bobbin.test", fetch: fetchMock });

const deferred = <T>(): { promise: Promise<T>; resolve: (value: T) => void } => {
	let resolve!: (value: T) => void;
	const promise = new Promise<T>((r) => {
		resolve = r;
	});
	return { promise, resolve };
};

describe("IdentityCache.resolve", () => {
	it("fetches on the first miss then serves the cached document", async () => {
		const fetchMock = vi.fn<typeof globalThis.fetch>().mockResolvedValue(docResponse(DOC));
		const cache = new IdentityCache(makeCtx(fetchMock));

		const first = await cache.resolve("alice.test");
		const second = await cache.resolve("alice.test");

		expect(first).toEqual(DOC);
		expect(second).toEqual(DOC);
		expect(fetchMock).toHaveBeenCalledTimes(1);
		expect((fetchMock.mock.calls[0][0] as URL).searchParams.get("identifier")).toBe("alice.test");
	});

	it("coalesces concurrent misses for the same key into one in-flight fetch", async () => {
		const gate = deferred<Response>();
		const fetchMock = vi.fn<typeof globalThis.fetch>().mockReturnValue(gate.promise);
		const cache = new IdentityCache(makeCtx(fetchMock));

		const a = cache.resolve("alice.test");
		const b = cache.resolve("alice.test");
		expect(fetchMock).toHaveBeenCalledTimes(1);

		gate.resolve(docResponse(DOC));
		const [ra, rb] = await Promise.all([a, b]);
		expect(ra).toEqual(DOC);
		expect(rb).toEqual(DOC);
		expect(fetchMock).toHaveBeenCalledTimes(1);
	});

	it("re-fetches after the in-flight promise settles (no permanent stampede lock)", async () => {
		const fetchMock = vi.fn<typeof globalThis.fetch>().mockResolvedValue(docResponse(DOC));
		const cache = new IdentityCache(makeCtx(fetchMock));

		await cache.resolve("bob.test");
		fetchMock.mockResolvedValueOnce(docResponse({ did: "did:plc:y", handle: "carol.test" }));
		await cache.resolve("carol.test");
		expect(fetchMock).toHaveBeenCalledTimes(2);
	});

	it("populates both directions of the index from a resolved document", async () => {
		const fetchMock = vi.fn<typeof globalThis.fetch>().mockResolvedValue(docResponse(DOC));
		const cache = new IdentityCache(makeCtx(fetchMock));

		await cache.resolve("alice.test");
		expect(cache.didFor("alice.test")).toBe("did:plc:x");
		expect(cache.handleFor("did:plc:x")).toBe("alice.test");
	});
});

describe("IdentityCache.prime & map selection", () => {
	it("seeds both directions without any fetch", () => {
		const fetchMock = vi.fn<typeof globalThis.fetch>();
		const cache = new IdentityCache(makeCtx(fetchMock));

		cache.prime(DOC);
		expect(cache.didFor("alice.test")).toBe("did:plc:x");
		expect(cache.handleFor("did:plc:x")).toBe("alice.test");
		expect(fetchMock).not.toHaveBeenCalled();
	});

	it("resolves a DID against the did map and a handle against the handle map", async () => {
		const fetchMock = vi.fn<typeof globalThis.fetch>();
		const cache = new IdentityCache(makeCtx(fetchMock));
		cache.prime(DOC);

		await expect(cache.resolve("did:plc:x")).resolves.toEqual(DOC);
		await expect(cache.resolve("alice.test")).resolves.toEqual(DOC);
		expect(fetchMock).not.toHaveBeenCalled();

		// unknown dids miss the handle map and fetch.
		fetchMock.mockResolvedValueOnce(docResponse({ did: "did:plc:z", handle: "dan.test" }));
		await cache.resolve("did:plc:z");
		expect(fetchMock).toHaveBeenCalledTimes(1);
		expect((fetchMock.mock.calls[0][0] as URL).searchParams.get("identifier")).toBe("did:plc:z");
	});
});