import { serializeModelSecret } from "@rakazo/adapters";
import type { Actor } from "@rakazo/contracts";
import type { PrismaClient } from "@rakazo/db";
import { describe, expect, it, vi } from "vitest";
import { connectedOpenAiCompatibleServer, setModelTier } from "./model-tiers.js";

const actor = { userId: "user", spaceId: "space" } as Actor;

function setup(provider: string | null) {
  const upsert = vi.fn(async () => ({}));
  const deleteMany = vi.fn(async () => ({ count: 1 }));
  const credentialFindFirst = vi.fn(async () =>
    provider ? { provider, secretId: "router-secret" } : null,
  );
  const prisma = {
    userModelCredential: { findFirst: credentialFindFirst },
    spaceModelTier: { upsert, deleteMany, findMany: vi.fn(async () => []) },
    secret: {
      findFirst: vi.fn(async () => ({ id: "router-secret", ciphertext: "fake-ciphertext" })),
    },
  } as unknown as PrismaClient;
  return { prisma, upsert, deleteMany, credentialFindFirst };
}

describe("model tier settings", () => {
  it("maps a tier to any model an OpenAI-compatible server serves", async () => {
    const { prisma, upsert, credentialFindFirst } = setup("openai-compatible");

    await setModelTier(prisma, actor, {
      tier: "code",
      model: { credentialId: "router", modelId: "router-code" },
    });

    expect(credentialFindFirst).toHaveBeenCalledWith(
      expect.objectContaining({ where: { id: "router", userId: "user" } }),
    );
    expect(upsert).toHaveBeenCalledWith(
      expect.objectContaining({
        create: expect.objectContaining({
          tier: "code",
          credentialId: "router",
          modelId: "router-code",
        }),
      }),
    );
  });

  it("refuses another user's credential and models a catalog provider does not run", async () => {
    const missing = setup(null);
    await expect(
      setModelTier(missing.prisma, actor, {
        tier: "fast",
        model: { credentialId: "someone-else", modelId: "router-fast" },
      }),
    ).rejects.toMatchObject({ code: "NOT_FOUND" });
    expect(missing.upsert).not.toHaveBeenCalled();

    const catalog = setup("xai");
    await expect(
      setModelTier(catalog.prisma, actor, {
        tier: "fast",
        model: { credentialId: "xai", modelId: "not-a-model" },
      }),
    ).rejects.toMatchObject({ code: "BAD_REQUEST" });
    await setModelTier(catalog.prisma, actor, {
      tier: "fast",
      model: { credentialId: "xai", modelId: "grok-4.6" },
    });
    expect(catalog.upsert).toHaveBeenCalledTimes(1);
  });

  it("clears a tier without looking up a credential", async () => {
    const { prisma, deleteMany, credentialFindFirst } = setup("openai-compatible");

    await expect(setModelTier(prisma, actor, { tier: "standard", model: null })).resolves.toEqual(
      [],
    );

    expect(credentialFindFirst).not.toHaveBeenCalled();
    expect(deleteMany).toHaveBeenCalledWith({
      where: { spaceId: "space", userId: "user", tier: "standard" },
    });
  });

  it("probes a connected server with its stored address and key, for its owner only", async () => {
    const { prisma, credentialFindFirst } = setup("openai-compatible");
    const secrets = {
      load: vi.fn(() =>
        serializeModelSecret({
          kind: "openai_compatible",
          baseUrl: "https://router.example.test/v1",
          apiKey: "fake-router-key",
        }),
      ),
    };

    await expect(
      connectedOpenAiCompatibleServer({ prisma, secrets }, actor, "router"),
    ).resolves.toEqual({ baseUrl: "https://router.example.test/v1", apiKey: "fake-router-key" });
    expect(credentialFindFirst).toHaveBeenCalledWith(
      expect.objectContaining({
        where: { id: "router", userId: "user", provider: "openai-compatible" },
      }),
    );

    const missing = setup(null);
    await expect(
      connectedOpenAiCompatibleServer({ prisma: missing.prisma, secrets }, actor, "router"),
    ).rejects.toMatchObject({ code: "NOT_FOUND" });
  });
});