import { createDbProxyServer } from "@suaveplan/api-db-worker-proxy/main-side";
import { createInMemoryAdminDb } from "@suaveplan/api-db-worker-proxy/testing";
import type { TenantId } from "@suaveplan/api-types/tenant";
import { createInProcessPortPair } from "@suaveplan/api-worker-rpc";
import { describe, expect, it } from "@suaveplan/testing/runner";
import { createDbAdapterWorkerProxy } from "./create-db-adapter-worker-proxy.js";

const ACME = "acme" as TenantId;

describe("createDbAdapterWorkerProxy", () => {
    it("admin proxy round-trips queries over a MessagePort", {
        timeout: 5000,
    }, async () => {
        const db = createInMemoryAdminDb({ seed: [["a", { v: 1 }]] });
        const ports = createInProcessPortPair();
        const server = createDbProxyServer(ports.serverPort, db);
        try {
            const proxy = createDbAdapterWorkerProxy({
                port: ports.clientPort,
                engine: db.engine,
            });
            const rows = await proxy.admin.query<unknown[]>("SELECT *");
            expect(rows).toEqual([{ v: 1 }]);
            proxy.close();
        } finally {
            server.close("test teardown");
            ports.close();
        }
    });

    it("scoped wrapper exposes engine + tenantId", { timeout: 5000 }, () => {
        // Stand up our own server+port pair so we don't double-consume frames
        const db = createInMemoryAdminDb();
        const ports = createInProcessPortPair();
        const server = createDbProxyServer(ports.serverPort, db);
        try {
            const proxy = createDbAdapterWorkerProxy({
                port: ports.clientPort,
                engine: "sqlite",
            });
            const scoped = proxy.scoped(ACME);
            expect(scoped.engine).toBe("sqlite");
            expect(scoped.tenantId).toBe(ACME);
            proxy.close();
        } finally {
            server.close("test teardown");
            ports.close();
        }
    });

    it("close() severs the underlying client", { timeout: 5000 }, async () => {
        const db = createInMemoryAdminDb();
        const ports = createInProcessPortPair();
        const server = createDbProxyServer(ports.serverPort, db);
        const proxy = createDbAdapterWorkerProxy({
            port: ports.clientPort,
            engine: "sqlite",
        });
        proxy.close();
        await expect(proxy.admin.query("SELECT *")).rejects.toBeDefined();
        server.close("test teardown");
        ports.close();
    });

    it("accepts clientOptions passthrough", { timeout: 5000 }, () => {
        const db = createInMemoryAdminDb();
        const ports = createInProcessPortPair();
        const server = createDbProxyServer(ports.serverPort, db);
        const proxy = createDbAdapterWorkerProxy({
            port: ports.clientPort,
            engine: "sqlite",
            clientOptions: {},
        });
        expect(proxy.admin.engine).toBe("sqlite");
        proxy.close();
        server.close("test teardown");
        ports.close();
    });
});