import { is } from "@atcute/lexicons/validations";
import type { OAuthUserAgent } from "@atcute/oauth-browser-client";
import { describe, expect, it, vi } from "vitest";
import { createBobbinClient } from "$lib/api/client";
import { createEntitySubscription, listNetworkVouches } from "$lib/api/graph";
import { mainSchema as subscriptionSchema } from "$lib/api/lexicons/types/org/tangled/feed/subscription";
import { createRecord } from "$lib/api/write";

vi.mock("$lib/api/write", () => ({
	createRecord: vi.fn(async () => ({
		uri: "at://did:plc:alice/org.tangled.feed.subscription/3l7abc",
		cid: "bafytest"
	})),
	deleteRecord: vi.fn(),
	putRecord: vi.fn()
}));

const response = (items: unknown[] = []) =>
	new Response(JSON.stringify({ items }), {
		status: 200,
		headers: { "content-type": "application/json" }
	});

describe("network vouches", () => {
	it("deduplicates actors and chunks requests at fifty", async () => {
		const fetch = vi.fn<typeof globalThis.fetch>(async () => response());
		const ctx = createBobbinClient({ serviceUrl: "https://bobbin.test", fetch });
		const actors = Array.from({ length: 55 }, (_, index) => `did:plc:actor${index}`);
		await listNetworkVouches(ctx, [...actors, actors[0]]);
		expect(fetch).toHaveBeenCalledTimes(2);
		expect(new URL(String(fetch.mock.calls[0][0])).searchParams.getAll("actors")).toEqual(
			actors.slice(0, 50)
		);
		expect(new URL(String(fetch.mock.calls[1][0])).searchParams.getAll("actors")).toEqual(
			actors.slice(50)
		);
	});

	it("groups tagged items by requested actor", async () => {
		const alice = "did:plc:alice";
		const bob = "did:plc:bob";
		const item = (actor: string) => ({
			actor,
			uri: `at://did:plc:viewer/org.tangled.graph.vouch/${actor}`,
			value: {
				$type: "org.tangled.graph.vouch",
				kind: "vouch",
				createdAt: "2026-01-01T00:00:00.000Z"
			}
		});
		const ctx = createBobbinClient({
			serviceUrl: "https://bobbin.test",
			fetch: async () => response([item(bob), item(alice), item(bob)])
		});
		const result = await listNetworkVouches(ctx, [alice, bob]);
		expect(result.items[alice]).toHaveLength(1);
		expect(result.items[bob]).toHaveLength(2);
	});
});

describe("entity subscriptions", () => {
	it("writes a record the subscription lexicon accepts", async () => {
		const agent = { sub: "did:plc:alice" } as unknown as OAuthUserAgent;
		await createEntitySubscription(agent, "at://did:plc:bob/org.tangled.track.ticket/3l7xyz");
		const [, , record] = vi.mocked(createRecord).mock.calls[0];
		expect(is(subscriptionSchema, record)).toBe(true);
	});
});