// @ts-nocheck
import { beforeEach, expect, it, vi } from "vitest";

const state = vi.hoisted(() => ({ upstreamCalls: 0 }));

vi.mock("@/lib/imager-cache", () => ({
	avatarCacheDir: () => "/tmp/imager-test",
	imagingCacheKey: (value: string) => value,
	// Nothing is ever cached on disk, so every call reaches the render path and
	// the in-flight map is the only thing that can dedupe it.
	readImagingCache: vi.fn(async () => null),
	writeImagingCache: vi.fn(async () => {}),
}));
vi.mock("@/lib/runtime-asset-config", () => ({
	resolveImagerBase: (origin: string) => `${origin}/imager`,
}));

import { fetchAvatarImage, ImagerUnavailableError } from "./imager-upstream";

const params = new URLSearchParams({ figure: "hr-1", direction: "2" });

beforeEach(() => {
	state.upstreamCalls = 0;
	globalThis.imagingInFlight?.clear();
	// A render is not instantaneous, so every caller launched in the same tick
	// is genuinely in flight at the same time. That overlap is what the
	// in-flight map has to collapse.
	vi.stubGlobal(
		"fetch",
		vi.fn(async () => {
			state.upstreamCalls += 1;
			await new Promise((resolve) => setTimeout(resolve, 5));
			return new Response(new Uint8Array([1, 2, 3]), {
				headers: { "content-type": "image/png" },
			});
		}),
	);
});

it("renders once for many concurrent requests of the same figure", async () => {
	// This is the whole point: a page asks for dozens of avatars at once and
	// repeats figures, and a render is the most expensive thing this app does.
	const results = await Promise.all(
		Array.from({ length: 8 }, () =>
			fetchAvatarImage("https://site.test", params),
		),
	);

	expect(state.upstreamCalls).toBe(1);
	for (const result of results) {
		expect([...result.body]).toEqual([1, 2, 3]);
		expect(result.source).toBe("primary");
	}
});

it("does not dedupe different figures", async () => {
	const other = new URLSearchParams({ figure: "hr-2", direction: "2" });
	await Promise.all([
		fetchAvatarImage("https://site.test", params),
		fetchAvatarImage("https://site.test", other),
	]);
	expect(state.upstreamCalls).toBe(2);
});

it("clears the in-flight entry so a later request reads the cache again", async () => {
	// A leaked entry would pin one promise per figure for the process lifetime
	// and serve the same body forever.
	await fetchAvatarImage("https://site.test", params);
	expect(globalThis.imagingInFlight?.size ?? 0).toBe(0);
});

it("clears the in-flight entry when the render fails", async () => {
	vi.stubGlobal(
		"fetch",
		vi.fn(async () => {
			throw Error("upstream down");
		}),
	);
	await expect(
		fetchAvatarImage("https://habbo.com/habbo-imaging/avatarimage", params),
	).rejects.toThrow(ImagerUnavailableError);
	expect(globalThis.imagingInFlight?.size ?? 0).toBe(0);
});