import type { GenerationOptions } from "@editor/state";
import { generateArchitectureDefaults } from "@editor/tools";
import type { GenerateMode, GenerateModel, GenerateSettings } from "@editor/tools";

export type GenerationSelectOption<TValue extends string> = { value: TValue; label: string };

export function resolveGenerationModelOptions(settings: GenerateSettings, options: GenerationOptions | undefined): readonly GenerationSelectOption<GenerateModel>[] {
  const architecture = options?.architectures?.find((item) => item.value === settings.architecture);
  const models = architecture?.models ?? (settings.architecture === "sdxl" ? options?.models : undefined) ?? [];
  const fallbackModel = architecture?.defaultModel ?? generateArchitectureDefaults[settings.architecture].model;
  const values = unique(["auto", ...models, ...(models.length === 0 && fallbackModel !== "auto" ? [fallbackModel] : []), settings.model]);
  return values.map((model) => ({ value: model, label: model === "auto" ? "Auto" : model }));
}

export function resolveGenerationSupportOptions(settings: GenerateSettings, options: GenerationOptions | undefined) {
  const defaults = generateArchitectureDefaults[settings.architecture];
  return {
    textEncoders: resolveGenerationStringOptions([...(options?.textEncoders ?? []), defaults.textEncoder].filter((value) => value !== "auto"), settings.textEncoder),
    vaes: resolveGenerationStringOptions([...(options?.vaes ?? []), defaults.vae].filter((value) => value !== "auto"), settings.vae),
  };
}

export function resolveGenerationStringOptions(values: string[] | undefined, current: string): readonly GenerationSelectOption<string>[] {
  return unique([...(values ?? []), current]).map((value) => ({ value, label: value }));
}

export function resolveGenerationModeOptions(
  settings: GenerateSettings,
  options: GenerationOptions | undefined,
  modes: readonly GenerationSelectOption<GenerateMode>[],
): readonly GenerationSelectOption<GenerateMode>[] {
  const architecture = options?.architectures?.find((item) => item.value === settings.architecture);
  const supportedModes = architecture?.supportedModes?.length ? architecture.supportedModes : generateArchitectureDefaults[settings.architecture].supportedModes;
  const availableModes = modes.filter((mode) => supportedModes.includes(mode.value));
  if (availableModes.some((mode) => mode.value === settings.mode)) return availableModes;
  return [modes.find((mode) => mode.value === settings.mode), ...availableModes].filter((mode): mode is GenerationSelectOption<GenerateMode> => Boolean(mode));
}

function unique<T>(values: T[]): T[] {
  return Array.from(new Set(values));
}