import type { Logger } from "../../core/logger";
import type { AppContext } from "../../app-context";
import { Effect } from "effect";
import type { Recipe } from "../models/types";
import { buildInferenceUrl } from "../../http/local-fetch";
import {
  DEFAULT_CHAT_PROVIDER,
  parseProviderModel,
  resolveConfiguredProviderConfig,
  type ProviderRouteConfig,
} from "../../services/provider-routing";
const PROXY_SESSION_HEADER_NAMES = [
  "x-vllm-session-id",
  "x-session-id",
  "x-chat-session-id",
  "openai-conversation-id",
];

const NON_RUNNING_MODEL_WARN_INTERVAL_MS = 10 * 60_000;

interface NonRunningModelWarningState {
  lastWarnAt: number;
  suppressed: number;
}

export interface NonRunningModelWarnDetails {
  requestedModel: string | null;
  requestedRecipeId: string;
  activeModel: string | null;
  source: string | null;
}

export const createNonRunningModelWarner = (
  logger: Pick<Logger, "warn">,
): ((details: NonRunningModelWarnDetails) => void) => {
  const warnings = new Map<string, NonRunningModelWarningState>();
  return (details) => {
    const key = [
      details.requestedRecipeId,
      details.requestedModel ?? "",
      details.activeModel ?? "",
      details.source ?? "",
    ].join("\u0000");
    const now = Date.now();
    const state = warnings.get(key) ?? { lastWarnAt: 0, suppressed: 0 };
    if (now - state.lastWarnAt < NON_RUNNING_MODEL_WARN_INTERVAL_MS) {
      state.suppressed += 1;
      warnings.set(key, state);
      return;
    }

    const suppressed = state.suppressed;
    warnings.set(key, { lastWarnAt: now, suppressed: 0 });
    logger.warn("Rejected chat request for non-running model", {
      requested_model: details.requestedModel,
      requested_recipe_id: details.requestedRecipeId,
      active_model: details.activeModel,
      source: details.source,
      ...(suppressed > 0 ? { suppressed_requests: suppressed } : {}),
    });
  };
};

export const extractSessionId = (
  parsedBody: Record<string, unknown>,
  header: (name: string) => string | undefined,
): string | null => {
  const fromHeader = PROXY_SESSION_HEADER_NAMES.map((name) => header(name)).find(Boolean);
  if (fromHeader?.trim()) return fromHeader.trim();

  const direct = parsedBody["session_id"] ?? parsedBody["sessionId"] ?? parsedBody["chat_id"];
  if (typeof direct === "string" && direct.trim()) return direct.trim();

  const metadata = parsedBody["metadata"];
  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
    const record = metadata as Record<string, unknown>;
    const fromMetadata = record["session_id"] ?? record["sessionId"] ?? record["chat_id"];
    if (typeof fromMetadata === "string" && fromMetadata.trim()) return fromMetadata.trim();
  }

  return null;
};

export const findRecipeByModel = (
  modelName: string,
  context: Pick<AppContext, "stores">,
): Effect.Effect<Recipe | null, unknown> =>
  context.stores.recipeStore.list().pipe(
    Effect.map((recipes) => {
      const lower = modelName.toLowerCase();
      return (
        recipes.find((recipe) => {
          const served = (recipe.served_model_name ?? "").toLowerCase();
          const name = (recipe.name ?? "").toLowerCase();
          return served === lower || recipe.id.toLowerCase() === lower || (name && name === lower);
        }) ?? null
      );
    }),
  );

export interface UpstreamResolution {
  upstreamUrl: string;
  auth: Record<string, string>;
  requestProvider: string;
  providerRouting: ProviderRouteConfig | null;
  rewroteModel: boolean;
}

/**
 * Resolve where a requested model's traffic goes and how it authenticates.
 * A "provider/model" id routes to that configured provider with its key, and
 * anything else reaches the local inference engine with INFERENCE_API_KEY
 * when one is set. When provider-routed, the request body's model field is
 * rewritten to the provider-local id.
 */
export const resolveUpstreamForModel = (
  requestedModel: string | null,
  parsed: Record<string, unknown>,
  path: string,
  context: AppContext,
  options: { includeXApiKey?: boolean } = {},
): UpstreamResolution => {
  const providerModel = requestedModel
    ? parseProviderModel(requestedModel)
    : { provider: DEFAULT_CHAT_PROVIDER, modelId: "" };
  const requestProvider = providerModel.provider;
  const providerRouting =
    requestProvider !== DEFAULT_CHAT_PROVIDER
      ? resolveConfiguredProviderConfig(requestProvider, context.config.providers)
      : null;
  if (providerRouting) {
    parsed["model"] = providerModel.modelId;
    return {
      upstreamUrl: `${providerRouting.baseUrl.replace(/\/+$/, "")}${path}`,
      auth: {
        Authorization: `Bearer ${providerRouting.apiKey}`,
        // The Anthropic dialect authenticates with x-api-key; sending both
        // lets one configured key reach either kind of upstream.
        ...(options.includeXApiKey ? { "x-api-key": providerRouting.apiKey } : {}),
      },
      requestProvider,
      providerRouting,
      rewroteModel: true,
    };
  }
  const inferenceKey = process.env["INFERENCE_API_KEY"] ?? "";
  return {
    upstreamUrl: buildInferenceUrl(context, path),
    auth: inferenceKey ? { Authorization: `Bearer ${inferenceKey}` } : {},
    requestProvider,
    providerRouting: null,
    rewroteModel: false,
  };
};

export const ensureStreamingUsageIncluded = (payload: Record<string, unknown>): boolean => {
  if (!Boolean(payload["stream"])) return false;
  const existingStreamOptions =
    payload["stream_options"] &&
    typeof payload["stream_options"] === "object" &&
    !Array.isArray(payload["stream_options"])
      ? (payload["stream_options"] as Record<string, unknown>)
      : {};
  if (existingStreamOptions["include_usage"] === true) return false;
  payload["stream_options"] = {
    ...existingStreamOptions,
    include_usage: true,
  };
  return true;
};