/**
 * Search Provider Registry
 *
 * Defines providers that support the /v1/search endpoint.
 * Unlike LLM/embedding providers, search providers don't have "models" —
 * a provider IS the model (Serper = Google SERP, Brave = Brave index).
 *
 * API keys are stored in the same provider credentials system,
 * keyed by provider ID (e.g. "serper-search", "brave-search").
 * perplexity-search reuses credentials from the "perplexity" chat provider.
 */

import { isProviderBlockedByIdOrAlias } from "@/shared/utils/noAuthProviders";

export interface SearchProviderConfig {
  id: string;
  name: string;
  baseUrl: string;
  method: "GET" | "POST";
  authType: "apikey" | "none";
  authHeader: string;
  costPerQuery: number;
  freeMonthlyQuota: number;
  searchTypes: string[];
  defaultMaxResults: number;
  maxMaxResults: number;
  timeoutMs: number;
  cacheTTLMs: number;
  /**
   * Last-resort provider: excluded from automatic (cost-based) selection so a
   * cost-0 free provider never overrides a configured paid one. Only used when no
   * credentialed provider is available, or when requested explicitly by id.
   */
  fallbackOnly?: boolean;
  disabled?: boolean;
}

export const SEARCH_PROVIDERS: Record<string, SearchProviderConfig> = {
  "serper-search": {
    id: "serper-search",
    name: "Serper Search",
    baseUrl: "https://google.serper.dev",
    method: "POST",
    authType: "apikey",
    authHeader: "x-api-key",
    costPerQuery: 0.001,
    freeMonthlyQuota: 2500,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 100,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "brave-search": {
    id: "brave-search",
    name: "Brave Search",
    baseUrl: "https://api.search.brave.com/res/v1",
    method: "GET",
    authType: "apikey",
    authHeader: "x-subscription-token",
    costPerQuery: 0.005,
    freeMonthlyQuota: 1000,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 20,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "perplexity-search": {
    id: "perplexity-search",
    name: "Perplexity Search",
    baseUrl: "https://api.perplexity.ai/search",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0.005,
    freeMonthlyQuota: 0,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 20,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "exa-search": {
    id: "exa-search",
    name: "Exa Search",
    baseUrl: "https://api.exa.ai/search",
    method: "POST",
    authType: "apikey",
    authHeader: "x-api-key",
    costPerQuery: 0.007,
    freeMonthlyQuota: 1000,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 100,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "tavily-search": {
    id: "tavily-search",
    name: "Tavily Search",
    baseUrl: "https://api.tavily.com/search",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0.008,
    freeMonthlyQuota: 1000,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 20,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  firecrawl: {
    id: "firecrawl",
    name: "Firecrawl",
    baseUrl: "https://api.firecrawl.dev/v2/search",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0.002,
    freeMonthlyQuota: 1000,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 100,
    timeoutMs: 30_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "google-pse-search": {
    id: "google-pse-search",
    name: "Google Programmable Search",
    baseUrl: "https://www.googleapis.com/customsearch/v1",
    method: "GET",
    authType: "apikey",
    authHeader: "key",
    costPerQuery: 0.005,
    freeMonthlyQuota: 3000,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 10,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "linkup-search": {
    id: "linkup-search",
    name: "Linkup Search",
    baseUrl: "https://api.linkup.so/v1/search",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0.005,
    freeMonthlyQuota: 1000,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 50,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "searchapi-search": {
    id: "searchapi-search",
    name: "SearchAPI",
    baseUrl: "https://www.searchapi.io/api/v1/search",
    method: "GET",
    authType: "apikey",
    authHeader: "api_key",
    costPerQuery: 0.004,
    freeMonthlyQuota: 100,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 100,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "youcom-search": {
    id: "youcom-search",
    name: "You.com Search",
    baseUrl: "https://ydc-index.io/v1/search",
    method: "GET",
    authType: "apikey",
    authHeader: "x-api-key",
    costPerQuery: 0.005,
    freeMonthlyQuota: 0,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 100,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "searxng-search": {
    id: "searxng-search",
    name: "SearXNG Search",
    baseUrl: "http://localhost:8888/search",
    method: "GET",
    authType: "none",
    authHeader: "none",
    costPerQuery: 0,
    freeMonthlyQuota: 999999,
    searchTypes: ["web", "news"],
    defaultMaxResults: 5,
    maxMaxResults: 50,
    timeoutMs: 10_000,
    cacheTTLMs: 3 * 60 * 1000,
    fallbackOnly: true,
  },

  "ollama-search": {
    id: "ollama-search",
    name: "Ollama Search",
    baseUrl: "https://ollama.com/api/web_search",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0,
    freeMonthlyQuota: 1000,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 10,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  "zai-search": {
    id: "zai-search",
    name: "Z.AI Coding Plan Search",
    baseUrl: "https://api.z.ai/api/mcp/web_search_prime/mcp",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0,
    freeMonthlyQuota: 0,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 50,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  // Jina Search (s.jina.ai). No extra dashboard card — credentials reuse
  // jina-ai / jina-reader / JINA_AI_API_KEY via SEARCH_CREDENTIAL_FALLBACKS.
  "jina-search": {
    id: "jina-search",
    name: "Jina Search (s.jina.ai)",
    baseUrl: "https://s.jina.ai",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0.002,
    freeMonthlyQuota: 1000,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 50,
    timeoutMs: 15_000,
    cacheTTLMs: 5 * 60 * 1000,
  },

  // Context7 (context7.com) — library-docs search. Anonymous tier works without a
  // key (per-minute rate limit, context7-quota-tier: anonymous); a configured
  // ctx7sk-* key raises the quota, sent as Bearer when a connection exists.
  // fallbackOnly: doc-focused corpus, never auto-selected for generic web search.
  context7: {
    id: "context7",
    name: "Context7 (library docs)",
    baseUrl: "https://context7.com/api/v1",
    method: "GET",
    // authType "none" means the framework skips credential injection entirely
    // (registryUtils.ts). A configured ctx7sk-* key still reaches the builder
    // via params.token, which attaches it as Bearer manually — authHeader
    // stays "none" so the generic injector never double-writes it.
    // The Bearer attachment lives in buildContext7Request
    // (open-sse/handlers/search.ts) — keep the two in sync when editing.
    authType: "none",
    authHeader: "none",
    costPerQuery: 0,
    // Anonymous tier is unlimited per-minute (rate-limited, not metered):
    // a 0 here would let the quota preflight reject anonymous traffic (the
    // same reason DuckDuckGo uses 999999 — see its entry above).
    freeMonthlyQuota: 999999,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 20,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
    fallbackOnly: true,
  },

  // Free, no-API-key DuckDuckGo lite scraping (free-claude-code port). Last-resort
  // only (fallbackOnly): never auto-selected over a configured provider; served by
  // the dedicated HTML path in open-sse/handlers/search.ts (not the generic JSON one).
  "duckduckgo-free": {
    id: "duckduckgo-free",
    name: "DuckDuckGo (free)",
    baseUrl: "https://lite.duckduckgo.com/lite/",
    method: "POST",
    authType: "none",
    authHeader: "none",
    costPerQuery: 0,
    freeMonthlyQuota: 999999,
    searchTypes: ["web"],
    defaultMaxResults: 5,
    maxMaxResults: 25,
    timeoutMs: 10_000,
    cacheTTLMs: 5 * 60 * 1000,
    fallbackOnly: true,
  },

  // SuperGrok / xAI server-side X Search. Not web search. Explicit provider or
  // search_type "x" only — never auto-selected for generic web queries.
  "x-search": {
    id: "x-search",
    name: "X Search (Grok)",
    baseUrl: "https://api.x.ai/v1/responses",
    method: "POST",
    authType: "apikey",
    authHeader: "bearer",
    costPerQuery: 0,
    freeMonthlyQuota: 0,
    searchTypes: ["x"],
    defaultMaxResults: 5,
    maxMaxResults: 20,
    timeoutMs: 60_000,
    cacheTTLMs: 5 * 60 * 1000,
  },
};

/**
 * Credential fallback mapping — search providers that can reuse credentials
 * from a related provider (e.g., perplexity-search uses the same API key as perplexity chat).
 */
export const SEARCH_CREDENTIAL_FALLBACKS: Record<string, string | string[]> = {
  "perplexity-search": "perplexity",
  "ollama-search": "ollama-cloud",
  "zai-search": "zai",
  "jina-search": "jina-ai",
  "x-search": ["xai-oauth", "xao", "xai"],
};

export function getSearchCredentialFallbacks(providerId: string): string[] {
  const mapped = SEARCH_CREDENTIAL_FALLBACKS[providerId];
  if (!mapped) return [];
  return Array.isArray(mapped) ? mapped : [mapped];
}

/**
 * Request-only aliases for POST /v1/search.
 *
 * Do not apply these in getSearchProvider(). jina-ai is the Foundation
 * embed/rerank/classify provider; remapping it here made the models
 * catalog treat jina-ai as a search-only card (searchTypes → "web").
 */
export const SEARCH_PROVIDER_ALIASES: Record<string, string> = {
  "jina-ai": "jina-search",
  jina: "jina-search",
  brave: "brave-search",
  serper: "serper-search",
  perplexity: "perplexity-search",
  exa: "exa-search",
  tavily: "tavily-search",
  "google-pse": "google-pse-search",
  linkup: "linkup-search",
  ollama: "ollama-search",
  searchapi: "searchapi-search",
  youcom: "youcom-search",
  searxng: "searxng-search",
  zai: "zai-search",
  duckduckgo: "duckduckgo-free",
  ctx7: "context7",
  c7: "context7",
  x_search: "x-search",
  x: "x-search",
};

export function resolveSearchProviderId(providerId: string): string {
  return SEARCH_PROVIDER_ALIASES[providerId] || providerId;
}

/**
 * Exact catalog lookup. Used by model listing / static catalogs.
 * Request routing should use resolveSearchProvider() so aliases work
 * without colliding with the Foundation jina-ai provider id.
 */
const CATALOG_SEARXNG_DEFAULT_URL = "http://localhost:8888/search";

/**
 * Catalog default SearXNG URL is a desktop convenience. In Docker/K8s nothing
 * listens on :8888, and OMNIROUTE_ALLOW_PRIVATE_PROVIDER_URLS (needed for
 * ClusterIP providers) lets ProxyFetch attempt it, producing ECONNREFUSED and
 * a 502 that then burns the next fallback's quota. Skip unless the operator
 * overrode baseUrl.
 */
export function isUnconfiguredLoopbackSearchProvider(
  provider: SearchProviderConfig | null | undefined
): boolean {
  if (!provider || provider.id !== "searxng-search") return false;
  const configured = String(provider.baseUrl || "").replace(/\/+$/, "");
  const catalog = CATALOG_SEARXNG_DEFAULT_URL.replace(/\/+$/, "");
  return configured === catalog;
}

export function getSearchProvider(providerId: string): SearchProviderConfig | null {
  return SEARCH_PROVIDERS[providerId] || null;
}

/** Resolve a /v1/search provider id, including Foundation aliases. */
export function resolveSearchProvider(providerId: string): SearchProviderConfig | null {
  return SEARCH_PROVIDERS[resolveSearchProviderId(providerId)] || null;
}

export function supportsSearchType(
  providerOrId: SearchProviderConfig | string | null | undefined,
  searchType: string
): boolean {
  const provider =
    typeof providerOrId === "string" ? resolveSearchProvider(providerOrId) : providerOrId || null;
  if (!provider) return false;
  return provider.searchTypes.includes(searchType);
}

/**
 * Get all search providers as a flat list
 */
export function getAllSearchProviders(blockedProviders: string[] = []): Array<{
  id: string;
  name: string;
  searchTypes: string[];
}> {
  return Object.values(SEARCH_PROVIDERS)
    .filter((p) => !p.disabled && !isProviderBlockedByIdOrAlias(p.id, blockedProviders))
    .map((p) => ({
      id: p.id,
      name: p.name,
      searchTypes: p.searchTypes,
    }));
}

/**
 * Select the cheapest available provider.
 * If an explicit provider is given, validate and return it.
 * Otherwise, return the cheapest by costPerQuery.
 */
export function selectProvider(
  explicitProvider?: string,
  searchType?: string
): SearchProviderConfig | null {
  if (explicitProvider) {
    const provider = resolveSearchProvider(explicitProvider);
    if (!provider) return null;
    if (searchType && !supportsSearchType(provider, searchType)) return null;
    return provider;
  }

  // Auto-selection excludes fallbackOnly providers so a free cost-0 provider never
  // overrides a configured paid one — they are reached only via explicit id or the
  // route handler's last-resort step. Missing searchType follows the API default
  // (`web`) so X-only providers are never cheapest-wins for generic queries.
  const effectiveType = searchType || "web";
  const providers = Object.values(SEARCH_PROVIDERS).filter(
    (provider) => !provider.fallbackOnly && supportsSearchType(provider, effectiveType)
  );
  if (providers.length === 0) return null;

  return providers.reduce((cheapest, p) => (p.costPerQuery < cheapest.costPerQuery ? p : cheapest));
}