import type { AIProviderConfig, AIProviderName } from "./types";
import { getPublicVideoConfig } from "@/lib/generation/video-config";

export type ImageProviderMode = "auto" | "openai" | "gemini" | "placeholder";
export type ChainProviderId = "gemini" | "openai" | "placeholder";
function parseChainEnv(): ChainProviderId[] | null {
  const raw = process.env.IMAGE_PROVIDER_CHAIN?.trim();
  if (!raw) return null;

  const allowed = new Set<ChainProviderId>(["gemini", "openai", "placeholder"]);
  const parsed = raw
    .split(",")
    .map((part) => part.trim().toLowerCase())
    .filter((part): part is ChainProviderId => allowed.has(part as ChainProviderId));

  return parsed.length > 0 ? parsed : null;
}

/** Resolve provider order for the active IMAGE_PROVIDER mode. */
export function resolveImageProviderChain(): ChainProviderId[] {
  const geminiEnabled =
    process.env.GEMINI_IMAGE_ENABLED !== "false" &&
    Boolean(process.env.GEMINI_API_KEY?.trim());

  const mode = getImageProviderMode();
  // Explicit openai mode wins — do not let a leftover gemini,… chain override disable intent.
  if (mode === "openai") {
    return ["openai", "placeholder"];
  }
  if (mode === "placeholder") {
    return ["placeholder"];
  }

  const custom = parseChainEnv();
  let chain: ChainProviderId[];

  if (custom) {
    chain = custom;
  } else {
    switch (mode) {
      case "gemini":
        chain = ["gemini", "openai", "placeholder"];
        break;
      case "auto":
      default:
        chain = geminiEnabled
          ? ["gemini", "openai", "placeholder"]
          : ["openai", "placeholder"];
        break;
    }
  }

  if (!geminiEnabled || mode !== "gemini") {
    // When Gemini is disabled (or not selected), never call it.
    if (!geminiEnabled) {
      chain = chain.filter((p) => p !== "gemini");
    }
  }
  if (chain.length === 0) {
    chain = ["placeholder"];
  }
  return chain;
}

export function formatImageProviderChain(chain: ChainProviderId[]): string {
  return chain.join(" → ");
}
function parseProvider(value: string | undefined): AIProviderName {
  return value === "openai" ? "openai" : "anthropic";
}

function parseImageProvider(value: string | undefined): ImageProviderMode {
  if (
    value === "openai" ||
    value === "gemini" ||
    value === "placeholder" ||
    value === "auto"
  ) {
    return value;
  }
  // auto: try Gemini then OpenAI when keys exist (see generateImage cascade).
  return "auto";
}

export function getActiveAIConfig(): AIProviderConfig {
  const provider = parseProvider(process.env.AI_PROVIDER);

  if (provider === "openai") {
    return {
      provider: "openai",
      model: process.env.OPENAI_MODEL ?? "gpt-4o",
      timeoutMs: Number(process.env.OPENAI_TIMEOUT ?? 120) * 1000,
      apiKey: process.env.OPENAI_API_KEY ?? "",
    };
  }

  return {
    provider: "anthropic",
    model: process.env.ANTHROPIC_MODEL ?? "claude-opus-4-1-20250805",
    timeoutMs: Number(process.env.ANTHROPIC_TIMEOUT ?? 120) * 1000,
    apiKey: process.env.ANTHROPIC_API_KEY ?? "",
  };
}

export function getImageProviderMode(): ImageProviderMode {
  return parseImageProvider(process.env.IMAGE_PROVIDER);
}

export function getOpenAIImageConfig() {
  const mode = getImageProviderMode();
  return {
    apiKey: process.env.OPENAI_API_KEY ?? "",
    // GPT Image is the default for social creatives; DALL·E remains an
    // OpenAI-only fallback for accounts that do not yet expose gpt-image-1.
    model: process.env.OPENAI_IMAGE_MODEL ?? "gpt-image-1",
    timeoutMs: Number(process.env.OPENAI_TIMEOUT ?? 120) * 1000,
    enabled: mode !== "placeholder",
    mode,
  };
}

/** Gemini image API — same host as generateContent curl (image-capable model required). */
export function getGeminiImageConfig() {
  const apiKey =
    process.env.GEMINI_API_KEY?.trim() ||
    process.env.GOOGLE_AI_API_KEY?.trim() ||
    process.env.GOOGLE_GENERATIVE_AI_API_KEY?.trim() ||
    "";

  const mode = getImageProviderMode();
  const inChain = resolveImageProviderChain().includes("gemini");

  return {
    apiKey,
    model: process.env.GEMINI_IMAGE_MODEL ?? "gemini-2.5-flash-image",
    timeoutMs: Number(process.env.GEMINI_TIMEOUT ?? process.env.OPENAI_TIMEOUT ?? 120) * 1000,
    // Enable whenever Gemini is in the active chain and a key exists.
    enabled: Boolean(apiKey) && inChain && mode !== "placeholder",
    mode,
  };
}

export function getPublicAIConfig() {
  const config = getActiveAIConfig();
  const mode = getImageProviderMode();
  const chain = resolveImageProviderChain();

  let imageProvider: string;

  if (mode === "gemini") {
    imageProvider = `${formatImageProviderChain(chain)} (gemini first)`;
  } else if (mode === "openai") {
    imageProvider = `${formatImageProviderChain(chain)} (openai first)`;
  } else if (mode === "auto") {
    imageProvider = `${formatImageProviderChain(chain)} (auto chain)`;
  } else {
    imageProvider = "placeholder (branded template only)";
  }

  return {
    provider: config.provider,
    model: config.model,
    timeoutSeconds: config.timeoutMs / 1000,
    imageProvider,
    imageProviderMode: mode,
    ...getPublicVideoConfig(),
  };
}

export function assertAIConfigured(config: AIProviderConfig) {
  if (!config.apiKey) {
    throw new Error(
      `${config.provider.toUpperCase()} API key is not configured. Set it in .env.local`,
    );
  }
}