import { ORPCError } from "@orpc/server";
import type { EncryptedSecretStore } from "@rakazo/adapters";
import { isCatalogModelChoice, parseModelSecret } from "@rakazo/adapters";
import type { Actor, ModelTierMapping, SetModelTierInput } from "@rakazo/contracts";
import { ModelTierSchema, OPENAI_COMPATIBLE_PROVIDER_ID } from "@rakazo/contracts";
import type { PrismaClient } from "@rakazo/db";
import { listSpaceModelTiers, setSpaceModelTier } from "@rakazo/db";

const NOT_CONNECTED = "Connect that model provider first";

export async function listModelTiers(
  prisma: PrismaClient,
  actor: Actor,
): Promise<ModelTierMapping[]> {
  const rows = await listSpaceModelTiers(prisma, actor);
  return rows.flatMap((row) => {
    const tier = ModelTierSchema.safeParse(row.tier);
    return tier.success
      ? [
          {
            tier: tier.data,
            credentialId: row.credentialId,
            provider: row.credential.provider,
            modelId: row.modelId,
          },
        ]
      : [];
  });
}

export async function setModelTier(prisma: PrismaClient, actor: Actor, input: SetModelTierInput) {
  if (input.model) {
    const credential = await prisma.userModelCredential.findFirst({
      where: { id: input.model.credentialId, userId: actor.userId },
      select: { provider: true },
    });
    if (!credential) throw new ORPCError("NOT_FOUND", { message: NOT_CONNECTED });
    // An OpenAI-compatible server runs whatever ids it serves; other providers run catalog models.
    if (
      credential.provider !== OPENAI_COMPATIBLE_PROVIDER_ID &&
      !isCatalogModelChoice(credential.provider, input.model.modelId)
    ) {
      throw new ORPCError("BAD_REQUEST", { message: "Unknown model for that provider" });
    }
  }
  await setSpaceModelTier(prisma, actor, input.tier, input.model);
  return listModelTiers(prisma, actor);
}

/** The stored address and key of a connected OpenAI-compatible server, for listing its models. */
export async function connectedOpenAiCompatibleServer(
  deps: { prisma: PrismaClient; secrets: Pick<EncryptedSecretStore, "load"> },
  actor: Actor,
  credentialId: string,
) {
  const credential = await deps.prisma.userModelCredential.findFirst({
    where: { id: credentialId, userId: actor.userId, provider: OPENAI_COMPATIBLE_PROVIDER_ID },
    select: { secretId: true },
  });
  const secret = credential
    ? await deps.prisma.secret.findFirst({
        where: { id: credential.secretId, userId: actor.userId, spaceId: null },
        select: { id: true, ciphertext: true },
      })
    : null;
  if (!secret) throw new ORPCError("NOT_FOUND", { message: NOT_CONNECTED });
  let stored: ReturnType<typeof parseModelSecret>;
  try {
    stored = parseModelSecret(deps.secrets.load(secret.ciphertext, secret.id));
  } catch {
    throw new ORPCError("NOT_FOUND", { message: NOT_CONNECTED });
  }
  if (stored.kind !== "openai_compatible") {
    throw new ORPCError("NOT_FOUND", { message: NOT_CONNECTED });
  }
  return { baseUrl: stored.baseUrl, apiKey: stored.apiKey };
}