import type { GenerationJob } from "@/lib/types";

export const IMAGE_MODELS = ["gpt-image-2", "gpt-image-2.5-flare", "gpt-image-2.5-sunburst"] as const;

export type ImageModel = (typeof IMAGE_MODELS)[number];

export const DEFAULT_IMAGE_MODEL: ImageModel = IMAGE_MODELS[0];

export const IMAGE_MODEL_OPTIONS: ReadonlyArray<{ id: ImageModel; label: string }> = [
  { id: "gpt-image-2", label: "Image 2" },
  { id: "gpt-image-2.5-flare", label: "Image 2.5 Flare" },
  { id: "gpt-image-2.5-sunburst", label: "Image 2.5 Sunburst" }
];

export type EvolinkModelCapability = {
  reqKey?: string;
  models?: Array<{ id: string; label: string }>;
};

export function evolinkModelCapability(capability?: EvolinkModelCapability & { engine?: string; evolink?: EvolinkModelCapability }): EvolinkModelCapability | undefined {
  return capability?.evolink || (capability?.engine === "evolink" ? capability : undefined);
}

export function isImageModel(value: unknown): value is ImageModel {
  return typeof value === "string" && IMAGE_MODELS.some((model) => model === value);
}

export function imageModelLabel(model: string): string {
  return IMAGE_MODEL_OPTIONS.find((option) => option.id === model)?.label || model;
}

export function imageModelAfterHealth(
  models: ReadonlyArray<{ id: string }>,
  configuredModel: string | undefined,
  currentModel: string,
  userSelected: boolean
): string {
  if (userSelected) return currentModel;
  return configuredImageModel(models, configuredModel);
}

export function configuredImageModel(models: ReadonlyArray<{ id: string }>, configuredModel?: string): string {
  return models.find((option) => option.id === configuredModel)?.id || models[0]?.id || DEFAULT_IMAGE_MODEL;
}

export function templateImageModel(savedModel: string | undefined, runtimeDefaultModel: string): string {
  return savedModel || runtimeDefaultModel;
}

export function imageModelFromJob(job: GenerationJob): string | undefined {
  if (job.capability !== "image.generate") return undefined;
  const payload = record(job.requestPayload);
  const input = record(payload.input);
  const engine = nonemptyString(input.engine) || nonemptyString(payload.engine);
  if (engine !== "evolink" && job.provider !== "evolink") return undefined;
  return nonemptyString(job.reqKey)
    || nonemptyString(payload.model)
    || nonemptyString(input.model)
    || nonemptyString(record(input.settings).model)
    || nonemptyString(record(payload.settings).model)
    || nonemptyString(record(payload.providerPayload).model)
    || DEFAULT_IMAGE_MODEL;
}

function record(value: unknown): Record<string, unknown> {
  return typeof value === "object" && value !== null && !Array.isArray(value) ? value as Record<string, unknown> : {};
}

function nonemptyString(value: unknown): string | undefined {
  return typeof value === "string" && value.trim() ? value.trim() : undefined;
}