/*
  author: Yagnik Poshiya
  organization: Webbrains Technologies Private Limited
*/

/**
 * Conversational Agent AI settings: the project's own LLM and embedding provider /
 * model / API key, and a per-visitor chat rate limit.
 *
 * Pure module — imported by the Connected Agents card (draft + early validation) and by
 * the server (authoritative validation). Keys are write-only: the browser only ever
 * sees the last four characters of a saved key.
 */

export const LLM_PROVIDERS = ['google', 'openai', 'anthropic', 'openrouter'] as const;
export type LlmProvider = (typeof LLM_PROVIDERS)[number];

/** Providers with an embeddings API that can produce 1536-dimensional vectors. */
export const EMBEDDING_PROVIDERS = ['google', 'openai'] as const;
export type EmbeddingProvider = (typeof EMBEDDING_PROVIDERS)[number];

export const RATE_LIMIT_WINDOWS = ['minute', 'second'] as const;
export type RateLimitWindow = (typeof RATE_LIMIT_WINDOWS)[number];

export const MIN_RATE_LIMIT_REQUESTS = 1;
export const MAX_RATE_LIMIT_REQUESTS = 1000;
const MAX_MODEL_NAME_LENGTH = 200;
const MAX_API_KEY_LENGTH = 500;

/** `agent_types.name` of the Conversational Agent. */
export const CONVERSATIONAL_AGENT_TYPE_NAME = 'rag';

export const LLM_PROVIDER_OPTIONS: ReadonlyArray<{
  value: LlmProvider;
  label: string;
  modelPlaceholder: string;
}> = [
  { value: 'google', label: 'Google (Gemini)', modelPlaceholder: 'gemini-2.5-flash' },
  { value: 'openai', label: 'OpenAI', modelPlaceholder: 'gpt-4o-mini' },
  { value: 'anthropic', label: 'Anthropic (Claude)', modelPlaceholder: 'claude-sonnet-5-5' },
  { value: 'openrouter', label: 'OpenRouter', modelPlaceholder: 'openai/gpt-4o-mini' },
];

export const EMBEDDING_PROVIDER_OPTIONS: ReadonlyArray<{
  value: EmbeddingProvider;
  label: string;
  modelPlaceholder: string;
}> = [
  { value: 'google', label: 'Google (Gemini)', modelPlaceholder: 'gemini-embedding-001' },
  { value: 'openai', label: 'OpenAI', modelPlaceholder: 'text-embedding-3-small' },
];

export const RATE_LIMIT_WINDOW_OPTIONS: ReadonlyArray<{ value: RateLimitWindow; label: string }> = [
  { value: 'minute', label: 'Per minute' },
  { value: 'second', label: 'Per second' },
];

/** What the server knows about the saved settings (keys only as presence + last four). */
export type ConnectedAgentAiSettings = {
  llmProvider: LlmProvider | null;
  llmModel: string | null;
  llmApiKeyLast4: string | null;
  embeddingProvider: EmbeddingProvider | null;
  embeddingModel: string | null;
  /** Null when no own embedding key is saved (the LLM key is reused for the same provider). */
  embeddingApiKeyLast4: string | null;
  rateLimitWindow: RateLimitWindow | null;
  rateLimitMaxRequests: number | null;
  /** Embedded documents of this agent grouped by `provider/model`. */
  embeddedDocuments: Array<{ embeddingModel: string; count: number }>;
};

/** Editable state in the card. Key fields hold only a newly typed key ('' = keep saved). */
export type AiSettingsDraft = {
  llmProvider: LlmProvider | '';
  llmModel: string;
  llmApiKey: string;
  embeddingProvider: EmbeddingProvider | '';
  embeddingModel: string;
  embeddingApiKey: string;
  rateLimitWindow: RateLimitWindow;
  /** Text of the number box; '' = no limit. */
  rateLimitMaxRequests: string;
};

/** Body sent to the server. Empty key strings mean "keep the saved key". */
export type AiSettingsInput = {
  llmProvider: string;
  llmModel: string;
  llmApiKey: string;
  embeddingProvider: string;
  embeddingModel: string;
  embeddingApiKey: string;
  rateLimitWindow: string;
  rateLimitMaxRequests: string;
};

export type SavedAiSettingsState = {
  llmProvider: LlmProvider | null;
  llmModel: string | null;
  hasLlmApiKey: boolean;
  embeddingProvider: EmbeddingProvider | null;
  embeddingModel: string | null;
  hasOwnEmbeddingApiKey: boolean;
  rateLimitWindow: RateLimitWindow | null;
  rateLimitMaxRequests: number | null;
};

export type AiSettingsPlan = {
  llm: { provider: LlmProvider; model: string } | null;
  embedding: { provider: EmbeddingProvider; model: string } | null;
  rateLimit: { window: RateLimitWindow; maxRequests: number } | null;
  /** Newly typed keys to store; null = keep what is saved. */
  newLlmApiKey: string | null;
  newEmbeddingApiKey: string | null;
  /** Drop the saved own embedding key (the embedding now reuses the LLM key). */
  clearOwnEmbeddingApiKey: boolean;
  /** Embedding will reuse the LLM key (same provider, no own key). */
  embeddingReusesLlmKey: boolean;
  /** Which parts need a live test call before saving. */
  validateLlm: boolean;
  validateEmbedding: boolean;
  /** Provider or model of the embedding differs from what was saved. */
  embeddingModelChanged: boolean;
  changed: boolean;
};

export function isLlmProvider(value: unknown): value is LlmProvider {
  return typeof value === 'string' && (LLM_PROVIDERS as readonly string[]).includes(value);
}

export function isEmbeddingProvider(value: unknown): value is EmbeddingProvider {
  return typeof value === 'string' && (EMBEDDING_PROVIDERS as readonly string[]).includes(value);
}

export function isRateLimitWindow(value: unknown): value is RateLimitWindow {
  return typeof value === 'string' && (RATE_LIMIT_WINDOWS as readonly string[]).includes(value);
}

export function isConversationalAgentType(typeName: string | null | undefined): boolean {
  return String(typeName ?? '').trim().toLowerCase() === CONVERSATIONAL_AGENT_TYPE_NAME;
}

export function llmProviderLabel(provider: string | null | undefined): string {
  return LLM_PROVIDER_OPTIONS.find((o) => o.value === provider)?.label ?? String(provider ?? '');
}

export function embeddingModelKey(provider: string, model: string): string {
  return `${provider}/${model}`;
}

export function apiKeyLast4(key: string): string {
  return key.trim().slice(-4);
}

export function maskedKeyHint(last4: string | null | undefined): string {
  return last4 ? `••••${last4}` : '';
}

type AiSettingsKeyState = Pick<
  ConnectedAgentAiSettings,
  'llmProvider' | 'llmModel' | 'llmApiKeyLast4' | 'embeddingProvider' | 'embeddingModel' | 'embeddingApiKeyLast4'
>;

/** Documents can be embedded: provider + model + a key (own, or the LLM key of the same provider). */
export function isEmbeddingConfigured(s: AiSettingsKeyState | null | undefined): boolean {
  if (!s?.embeddingProvider || !s.embeddingModel) return false;
  return Boolean(s.embeddingApiKeyLast4) || (Boolean(s.llmApiKeyLast4) && s.embeddingProvider === s.llmProvider);
}

/** The agent can run (and the embed script can be shown) only with both parts complete. */
export function isAiSettingsComplete(s: AiSettingsKeyState | null | undefined): boolean {
  return Boolean(s?.llmProvider && s.llmModel && s.llmApiKeyLast4) && isEmbeddingConfigured(s);
}

export function savedStateFromAiSettings(s: ConnectedAgentAiSettings | null | undefined): SavedAiSettingsState {
  return {
    llmProvider: s?.llmProvider ?? null,
    llmModel: s?.llmModel ?? null,
    hasLlmApiKey: Boolean(s?.llmApiKeyLast4),
    embeddingProvider: s?.embeddingProvider ?? null,
    embeddingModel: s?.embeddingModel ?? null,
    hasOwnEmbeddingApiKey: Boolean(s?.embeddingApiKeyLast4),
    rateLimitWindow: s?.rateLimitWindow ?? null,
    rateLimitMaxRequests: s?.rateLimitMaxRequests ?? null,
  };
}

export function aiSettingsDraftFromSaved(s: ConnectedAgentAiSettings | null | undefined): AiSettingsDraft {
  return {
    llmProvider: s?.llmProvider ?? '',
    llmModel: s?.llmModel ?? '',
    llmApiKey: '',
    embeddingProvider: s?.embeddingProvider ?? '',
    embeddingModel: s?.embeddingModel ?? '',
    embeddingApiKey: '',
    rateLimitWindow: s?.rateLimitWindow ?? 'minute',
    rateLimitMaxRequests: s?.rateLimitMaxRequests != null ? String(s.rateLimitMaxRequests) : '',
  };
}

/**
 * A model name belongs to its provider: switching provider clears it so the new
 * provider's placeholder shows, and switching back restores the saved model.
 */
export function draftWithLlmProvider(
  draft: AiSettingsDraft,
  provider: LlmProvider,
  saved: ConnectedAgentAiSettings | null | undefined,
): AiSettingsDraft {
  if (provider === draft.llmProvider) return draft;
  const llmModel = provider === saved?.llmProvider ? (saved.llmModel ?? '') : '';
  return { ...draft, llmProvider: provider, llmModel };
}

export function draftWithEmbeddingProvider(
  draft: AiSettingsDraft,
  provider: EmbeddingProvider,
  saved: ConnectedAgentAiSettings | null | undefined,
): AiSettingsDraft {
  if (provider === draft.embeddingProvider) return draft;
  const embeddingModel = provider === saved?.embeddingProvider ? (saved.embeddingModel ?? '') : '';
  return { ...draft, embeddingProvider: provider, embeddingModel };
}

export function aiSettingsInputFromDraft(d: AiSettingsDraft): AiSettingsInput {
  return {
    llmProvider: d.llmProvider,
    llmModel: d.llmModel,
    llmApiKey: d.llmApiKey,
    embeddingProvider: d.embeddingProvider,
    embeddingModel: d.embeddingModel,
    embeddingApiKey: d.embeddingApiKey,
    rateLimitWindow: d.rateLimitWindow,
    rateLimitMaxRequests: d.rateLimitMaxRequests,
  };
}

export function isAiSettingsDraftDirty(
  saved: ConnectedAgentAiSettings | null | undefined,
  draft: AiSettingsDraft,
): boolean {
  const base = aiSettingsDraftFromSaved(saved);
  const noLimit = (v: string) => v.trim() === '';
  const rateLimitDirty =
    base.rateLimitMaxRequests.trim() !== draft.rateLimitMaxRequests.trim() ||
    (!noLimit(draft.rateLimitMaxRequests) && base.rateLimitWindow !== draft.rateLimitWindow);
  return (
    base.llmProvider !== draft.llmProvider ||
    base.llmModel.trim() !== draft.llmModel.trim() ||
    draft.llmApiKey.trim() !== '' ||
    base.embeddingProvider !== draft.embeddingProvider ||
    base.embeddingModel.trim() !== draft.embeddingModel.trim() ||
    draft.embeddingApiKey.trim() !== '' ||
    rateLimitDirty
  );
}

function validModelName(model: string): string | null {
  if (!model) return 'is required';
  if (model.length > MAX_MODEL_NAME_LENGTH) return `must be at most ${MAX_MODEL_NAME_LENGTH} characters`;
  if (/\s/.test(model)) return 'must not contain spaces';
  return null;
}

function validApiKey(key: string): string | null {
  if (key.length > MAX_API_KEY_LENGTH) return 'is too long';
  if (/\s/.test(key)) return 'must not contain spaces';
  return null;
}

/**
 * Decide what a save does, or why it is refused. Used by the card for early feedback
 * and by the server as the authority (with `saved` read from the database).
 */
export function planAiSettingsUpdate(
  saved: SavedAiSettingsState,
  input: AiSettingsInput,
): { ok: true; plan: AiSettingsPlan } | { ok: false; message: string } {
  const llmProviderRaw = String(input.llmProvider ?? '').trim().toLowerCase();
  const llmModel = String(input.llmModel ?? '').trim();
  const newLlmKey = String(input.llmApiKey ?? '').trim();
  const embProviderRaw = String(input.embeddingProvider ?? '').trim().toLowerCase();
  const embModel = String(input.embeddingModel ?? '').trim();
  const newEmbKey = String(input.embeddingApiKey ?? '').trim();
  const rateMaxRaw = String(input.rateLimitMaxRequests ?? '').trim();
  const rateWindowRaw = String(input.rateLimitWindow ?? '').trim().toLowerCase();

  // --- LLM -----------------------------------------------------------------------
  let llm: AiSettingsPlan['llm'] = null;
  const llmTouched = Boolean(llmProviderRaw || llmModel || newLlmKey);
  if (!llmTouched) {
    if (saved.llmProvider) return { ok: false, message: 'LLM provider, model and API key cannot be removed.' };
  } else {
    if (!isLlmProvider(llmProviderRaw)) return { ok: false, message: 'Choose an LLM provider.' };
    const modelErr = validModelName(llmModel);
    if (modelErr) return { ok: false, message: `LLM model name ${modelErr}.` };
    if (newLlmKey) {
      const keyErr = validApiKey(newLlmKey);
      if (keyErr) return { ok: false, message: `LLM API key ${keyErr}.` };
    } else if (!saved.hasLlmApiKey || saved.llmProvider !== llmProviderRaw) {
      return { ok: false, message: `Enter the ${llmProviderLabel(llmProviderRaw)} API key.` };
    }
    llm = { provider: llmProviderRaw, model: llmModel };
  }
  const llmKeyAvailable = Boolean(llm && (newLlmKey || saved.hasLlmApiKey));

  // --- Embedding -----------------------------------------------------------------
  let embedding: AiSettingsPlan['embedding'] = null;
  let embeddingReusesLlmKey = false;
  let clearOwnEmbeddingApiKey = false;
  const embTouched = Boolean(embProviderRaw || embModel || newEmbKey);
  if (!embTouched) {
    if (saved.embeddingProvider) {
      return { ok: false, message: 'Embedding provider, model and API key cannot be removed.' };
    }
  } else {
    if (!isEmbeddingProvider(embProviderRaw)) {
      return { ok: false, message: 'Choose an embedding provider (Google or OpenAI).' };
    }
    const modelErr = validModelName(embModel);
    if (modelErr) return { ok: false, message: `Embedding model name ${modelErr}.` };
    if (newEmbKey) {
      const keyErr = validApiKey(newEmbKey);
      if (keyErr) return { ok: false, message: `Embedding API key ${keyErr}.` };
    } else if (saved.hasOwnEmbeddingApiKey && saved.embeddingProvider === embProviderRaw) {
      // keep the saved own key
    } else if (llm && llm.provider === embProviderRaw && llmKeyAvailable) {
      embeddingReusesLlmKey = true;
      clearOwnEmbeddingApiKey = saved.hasOwnEmbeddingApiKey;
    } else {
      const llmLabel = llm ? llmProviderLabel(llm.provider) : null;
      return {
        ok: false,
        message: llmLabel
          ? `Enter the ${llmProviderLabel(embProviderRaw)} embedding API key — a ${llmLabel} key can't be used for ${llmProviderLabel(embProviderRaw)} embeddings.`
          : `Enter the ${llmProviderLabel(embProviderRaw)} embedding API key.`,
      };
    }
    embedding = { provider: embProviderRaw, model: embModel };
  }

  // --- Rate limit ----------------------------------------------------------------
  let rateLimit: AiSettingsPlan['rateLimit'] = null;
  if (rateMaxRaw) {
    if (!/^\d+$/.test(rateMaxRaw)) return { ok: false, message: 'Rate limit must be a whole number.' };
    const n = Number(rateMaxRaw);
    if (n < MIN_RATE_LIMIT_REQUESTS || n > MAX_RATE_LIMIT_REQUESTS) {
      return {
        ok: false,
        message: `Rate limit must be between ${MIN_RATE_LIMIT_REQUESTS} and ${MAX_RATE_LIMIT_REQUESTS} requests.`,
      };
    }
    if (!isRateLimitWindow(rateWindowRaw)) return { ok: false, message: 'Choose per second or per minute.' };
    rateLimit = { window: rateWindowRaw, maxRequests: n };
  }

  // --- What changed --------------------------------------------------------------
  const llmChanged =
    (llm?.provider ?? null) !== saved.llmProvider || (llm?.model ?? null) !== saved.llmModel || Boolean(newLlmKey);
  const embeddingModelChanged =
    (embedding?.provider ?? null) !== saved.embeddingProvider || (embedding?.model ?? null) !== saved.embeddingModel;
  const embeddingKeyChanged = Boolean(newEmbKey) || clearOwnEmbeddingApiKey || (embeddingReusesLlmKey && Boolean(newLlmKey));
  const rateLimitChanged =
    (rateLimit?.window ?? null) !== saved.rateLimitWindow ||
    (rateLimit?.maxRequests ?? null) !== saved.rateLimitMaxRequests;

  return {
    ok: true,
    plan: {
      llm,
      embedding,
      rateLimit,
      newLlmApiKey: newLlmKey || null,
      newEmbeddingApiKey: newEmbKey || null,
      clearOwnEmbeddingApiKey,
      embeddingReusesLlmKey,
      validateLlm: Boolean(llm) && llmChanged,
      validateEmbedding: Boolean(embedding) && (embeddingModelChanged || embeddingKeyChanged),
      embeddingModelChanged: Boolean(embedding) && embeddingModelChanged,
      changed: llmChanged || embeddingModelChanged || embeddingKeyChanged || rateLimitChanged,
    },
  };
}

/** Embedded documents that would stop matching if the agent switched to `provider/model`. */
export function incompatibleEmbeddedDocuments(
  embeddedDocuments: ConnectedAgentAiSettings['embeddedDocuments'],
  provider: string,
  model: string,
): number {
  const target = embeddingModelKey(provider, model);
  return embeddedDocuments.filter((d) => d.embeddingModel !== target).reduce((n, d) => n + d.count, 0);
}

/**
 * Uploaded documents a pending embedding change would leave unsearchable, or null.
 * Switching away from the saved provider strands every document at once — no model of
 * another provider matches the stored vectors — so it warns before a model is typed.
 */
export function embeddingChangeConflict(
  saved: ConnectedAgentAiSettings | null | undefined,
  draft: AiSettingsDraft,
): { count: number; currentModels: string[]; target: string } | null {
  const provider = draft.embeddingProvider;
  if (!provider) return null;
  const model = draft.embeddingModel.trim();
  const providerChanged = provider !== saved?.embeddingProvider;
  if (model ? !providerChanged && model === saved?.embeddingModel : !providerChanged || !saved?.embeddingProvider) {
    return null;
  }
  const target = model ? embeddingModelKey(provider, model) : null;
  const stranded = (saved?.embeddedDocuments ?? []).filter((d) => d.embeddingModel !== target);
  const count = stranded.reduce((n, d) => n + d.count, 0);
  if (count === 0) return null;
  return {
    count,
    currentModels: stranded.map((d) => d.embeddingModel),
    target: target ?? `the ${llmProviderLabel(provider)} model`,
  };
}

export function deleteDocumentsFirstMessage(count: number, currentModels: string[], target: string): string {
  const docs = count === 1 ? '1 uploaded document' : `${count} uploaded documents`;
  const current = currentModels.length > 0 ? ` embedded with ${currentModels.join(', ')}` : '';
  return `This agent has ${docs}${current}. Delete ${count === 1 ? 'it' : 'them'} in Storage first, then save ${target} and upload the documents again.`;
}
