import { OperationFailure } from "./operation-result.ts";
import { Secret } from "../configuration/secrets.ts";
import {
  MODEL_CATALOG,
  MODEL_PROVIDERS,
  isModelProvider,
  isCredentialProvider,
  modelEfforts,
  type CredentialProvider,
  type ModelEffort,
  type ModelConfiguration,
  type ModelProvider,
} from "../shared/model-providers.ts";
export {
  MODEL_CATALOG,
  type ModelConfiguration,
} from "../shared/model-providers.ts";

export interface ModelSettings {
  configuration: ModelConfiguration;
  credentials: Record<CredentialProvider, "configured" | "missing">;
  providers: Record<ModelProvider, boolean>;
  providerSetupUrl: string | null;
}

export interface ConversationModelSettings extends ModelSettings {
  override: ModelConfiguration | null;
}

export const DEFAULT_MODEL: ModelConfiguration = {
  provider: "workers-ai",
  model: MODEL_CATALOG["workers-ai"][0],
};

export function parseModelConfiguration(value: unknown): ModelConfiguration {
  if (typeof value !== "object" || value === null || Array.isArray(value))
    throw new OperationFailure("invalid_model");
  const record = value as Record<string, unknown>;
  if (
    Object.keys(record).some(
      (key) => !["provider", "model", "effort"].includes(key),
    ) ||
    !Object.hasOwn(record, "provider") ||
    !Object.hasOwn(record, "model") ||
    !isModelProvider(record.provider) ||
    typeof record.model !== "string" ||
    !(MODEL_CATALOG[record.provider] as readonly string[]).includes(
      record.model,
    )
  )
    throw new OperationFailure("invalid_model");
  if (
    Object.hasOwn(record, "effort") &&
    !modelEfforts(record as ModelConfiguration).includes(
      record.effort as ModelEffort,
    )
  )
    throw new OperationFailure("invalid_effort");
  return {
    provider: record.provider,
    model: record.model,
    ...(record.effort === undefined ? {} : { effort: record.effort }),
  } as ModelConfiguration;
}

export function parseProviderKey(
  provider: unknown,
  value: unknown,
): Secret | null {
  if (!isCredentialProvider(provider))
    throw new Error("Unsupported credential provider");
  if (value === null) return null;
  if (
    typeof value !== "string" ||
    value.length < 20 ||
    value.length > 512 ||
    !/^[\x21-\x7e]+$/.test(value)
  )
    throw new Error(
      `${MODEL_PROVIDERS[provider].name} API key must be 20–512 printable characters without spaces`,
    );
  return new Secret(value);
}

export {
  CredentialFailure,
  decryptProviderKey,
  encryptProviderKey,
} from "./credential-crypto.ts";