import { describe, expect, it, vi } from "vitest";
import type { PrismaClient } from "./client.js";
import { findSpaceModelTier, listSpaceModelTiers, setSpaceModelTier } from "./model-tiers.js";

const scope = { userId: "user", spaceId: "space" };
const credential = {
  id: "router",
  userId: "user",
  provider: "openai-compatible",
  label: "Router",
  secretId: "router-secret",
  supportsImages: true,
  createdAt: new Date(0),
  updatedAt: new Date(0),
};

describe("space model tiers", () => {
  it("finds a tier within the user's space with its credential shaped for model resolution", async () => {
    const findUnique = vi.fn().mockResolvedValue({
      tier: "code",
      credentialId: "router",
      modelId: "router-code",
      credential: { ...credential, preferences: [{ isDefault: true, modelId: "router-default" }] },
    });
    const prisma = { spaceModelTier: { findUnique } } as unknown as PrismaClient;

    await expect(findSpaceModelTier(prisma, scope, "code")).resolves.toEqual({
      tier: "code",
      credentialId: "router",
      modelId: "router-code",
      // The space's saved model stays the credential default, so its image support does not
      // spread to the tier's model.
      credential: { ...credential, isDefault: true, defaultModel: "router-default" },
    });
    expect(findUnique).toHaveBeenCalledWith({
      where: { spaceId_userId_tier: { spaceId: "space", userId: "user", tier: "code" } },
      include: {
        credential: {
          include: {
            preferences: {
              where: { spaceId: "space", userId: "user" },
              select: { isDefault: true, modelId: true },
            },
          },
        },
      },
    });
  });

  it("reports an unmapped tier as null", async () => {
    const prisma = {
      spaceModelTier: { findUnique: vi.fn().mockResolvedValue(null) },
    } as unknown as PrismaClient;

    await expect(findSpaceModelTier(prisma, scope, "fast")).resolves.toBeNull();
  });

  it("lists only the user's tiers in the space", async () => {
    const findMany = vi.fn().mockResolvedValue([
      {
        tier: "fast",
        credentialId: "router",
        modelId: "router-fast",
        credential: { ...credential, preferences: [] },
      },
    ]);
    const prisma = { spaceModelTier: { findMany } } as unknown as PrismaClient;

    await expect(listSpaceModelTiers(prisma, scope)).resolves.toEqual([
      {
        tier: "fast",
        credentialId: "router",
        modelId: "router-fast",
        credential: { ...credential, isDefault: false, defaultModel: null },
      },
    ]);
    expect(findMany).toHaveBeenCalledWith(
      expect.objectContaining({ where: { spaceId: "space", userId: "user" } }),
    );
  });

  it("maps a tier with an upsert and clears it with a scoped delete", async () => {
    const upsert = vi.fn().mockResolvedValue({});
    const deleteMany = vi.fn().mockResolvedValue({ count: 1 });
    const prisma = { spaceModelTier: { upsert, deleteMany } } as unknown as PrismaClient;

    await setSpaceModelTier(prisma, scope, "code", {
      credentialId: "router",
      modelId: "router-code",
    });
    expect(upsert).toHaveBeenCalledWith({
      where: { spaceId_userId_tier: { spaceId: "space", userId: "user", tier: "code" } },
      create: {
        spaceId: "space",
        userId: "user",
        tier: "code",
        credentialId: "router",
        modelId: "router-code",
      },
      update: { credentialId: "router", modelId: "router-code" },
    });

    await setSpaceModelTier(prisma, scope, "code", null);
    expect(deleteMany).toHaveBeenCalledWith({
      where: { spaceId: "space", userId: "user", tier: "code" },
    });
  });
});