import { getActiveAIConfig } from "./config";
import { estimateTextCostUsd, estimateImageCostUsd, type AiOperationKind } from "./cost-tracking";
import { PostAiUsageTracker } from "./usage-logger";
import { runImageProviderChain } from "./image-provider-chain";
import { anthropicProvider } from "./providers/anthropic";
import { openaiProvider } from "./providers/openai";
import type { SocialImageContext } from "@/lib/generation/social-image";
import type {
  AIProvider,
  ImageGenerationResult,
  TextGenerationRequest,
  TextGenerationResult,
} from "./types";

export function getAIProvider(): AIProvider {
  const config = getActiveAIConfig();
  return config.provider === "openai" ? openaiProvider : anthropicProvider;
}

export interface GenerateTextMeta {
  operation: AiOperationKind;
  tracker?: PostAiUsageTracker;
}

export async function generateText(
  request: TextGenerationRequest,
  meta?: GenerateTextMeta,
): Promise<TextGenerationResult> {
  const start = Date.now();
  const result = await getAIProvider().generateText(request);
  const estimatedCostUsd = estimateTextCostUsd({
    model: result.model,
    inputTokens: result.inputTokens,
    outputTokens: result.outputTokens,
  });

  if (meta?.tracker) {
    meta.tracker.add({
      operation: meta.operation,
      provider: result.provider,
      model: result.model,
      inputTokens: result.inputTokens,
      outputTokens: result.outputTokens,
      totalTokens: result.totalTokens,
      estimatedCostUsd,
      durationMs: Date.now() - start,
    });
  }

  return result;
}

/** Gemini → OpenAI → branded template (order configurable via IMAGE_PROVIDER / IMAGE_PROVIDER_CHAIN). */
export async function generateImage(
  imagePrompt: string,
  socialContext?: SocialImageContext,
  tracker?: PostAiUsageTracker,
): Promise<ImageGenerationResult> {
  const start = Date.now();
  const result = await runImageProviderChain(imagePrompt, socialContext);
  const estimatedCostUsd =
    result.estimatedCostUsd ??
    estimateImageCostUsd(result.provider, result.imageModel);

  if (tracker) {
    tracker.add({
      operation: "image",
      provider: result.provider,
      model: result.imageModel ?? result.provider,
      estimatedCostUsd,
      durationMs: Date.now() - start,
    });
  }

  return { ...result, estimatedCostUsd };
}

export { getPublicAIConfig, formatImageProviderChain, resolveImageProviderChain } from "./config";
export type { TextGenerationResult, ImageGenerationResult } from "./types";
export { PostAiUsageTracker, readAiUsageLogs } from "./usage-logger";
export { formatCostUsd, summarizeUsage, type AiUsageSummary, type AiCallUsage } from "./cost-tracking";