import { getDefaultModel } from "./catalog";
import { getDecryptedApiKey } from "./settings";
import { generateWithAnthropic } from "./providers/anthropic";
import { generateWithMindavioCore } from "./providers/mindavio-core";
import { generateWithOpenAI } from "./providers/openai";
import { getWorkspaceMemory } from "./workspace-memory";
import type { AIWorkspaceContext, ConversationMessage } from "./types";

function getAutomationSystemPrompt(workspaceMemory?: string) {
  return [
    "You are Mindavio AI running inside a workspace automation.",
    "Return practical plain text only.",
    "Do not mention tools, JSON, or internal reasoning.",
    "Use the same language as the provided prompt.",
    workspaceMemory?.trim()
      ? `Current workspace memory: ${workspaceMemory.trim()}`
      : "",
    `Today's date is ${new Date().toISOString().slice(0, 10)}.`,
  ]
    .filter(Boolean)
    .join(" ");
}

async function generateAutomationTextOnce(input: {
  provider: "mindavio_core" | "openai" | "anthropic";
  apiKey?: string;
  model: string;
  systemPrompt: string;
  messages: ConversationMessage[];
}) {
  if (input.provider === "mindavio_core") {
    return generateWithMindavioCore({
      apiKey: "",
      model: input.model,
      systemPrompt: input.systemPrompt,
      messages: input.messages,
      tools: [],
    });
  }

  if (input.provider === "anthropic") {
    return generateWithAnthropic({
      apiKey: input.apiKey!,
      model: input.model,
      systemPrompt: input.systemPrompt,
      messages: input.messages,
      tools: [],
    });
  }

  return generateWithOpenAI({
    apiKey: input.apiKey!,
    model: input.model,
    systemPrompt: input.systemPrompt,
    messages: input.messages,
    tools: [],
  });
}

export async function runAutomationAIText(
  userId: string,
  prompt: string,
  context?: AIWorkspaceContext
) {
  const config = await getDecryptedApiKey(userId);
  const workspaceMemory = await getWorkspaceMemory(userId, context);
  const selectedProvider = config?.provider || "mindavio_core";
  const provider =
    selectedProvider === "openai" && config?.openaiApiKey
      ? "openai"
      : selectedProvider === "anthropic" && config?.anthropicApiKey
      ? "anthropic"
      : "mindavio_core";
  const model =
    provider === "openai"
      ? config?.model || getDefaultModel("openai")
      : provider === "anthropic"
      ? config?.model || getDefaultModel("anthropic")
      : config?.provider === "mindavio_core" && config?.model
      ? config.model
      : getDefaultModel("mindavio_core");
  const apiKey =
    provider === "openai"
      ? config?.openaiApiKey || undefined
      : provider === "anthropic"
      ? config?.anthropicApiKey || undefined
      : undefined;

  const systemPrompt = getAutomationSystemPrompt(workspaceMemory?.memory);
  const messages: ConversationMessage[] = [{ role: "user", content: prompt }];

  try {
    const result = await generateAutomationTextOnce({
      provider,
      apiKey,
      model,
      systemPrompt,
      messages,
    });

    return {
      text: result.text.trim(),
      provider,
      model,
    };
  } catch {
    if (provider !== "mindavio_core") {
      const fallback = await generateAutomationTextOnce({
        provider: "mindavio_core",
        model: getDefaultModel("mindavio_core"),
        systemPrompt,
        messages,
      });

      return {
        text: fallback.text.trim(),
        provider: "mindavio_core" as const,
        model: getDefaultModel("mindavio_core"),
      };
    }

    throw new Error("Mindavio AI could not generate automation output.");
  }
}