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

import type { SupabaseClient } from '@supabase/supabase-js';

import {
  type AiSettingsInput,
  type ConnectedAgentAiSettings,
  apiKeyLast4,
  deleteDocumentsFirstMessage,
  embeddingModelKey,
  isEmbeddingConfigured,
  isEmbeddingProvider,
  isLlmProvider,
  isRateLimitWindow,
  planAiSettingsUpdate,
} from '@/lib/connected-agents/agent-ai-settings';
import { validateLlmConfigViaRagAgent } from '@/lib/rag-agent/validate-llm-config';
import { getSupabaseServiceRoleClient } from '@/lib/supabase/service-role';

const AI_SETTINGS_COLUMNS =
  'id, llm_provider, llm_model, llm_api_key_last4, embedding_provider, embedding_model, embedding_api_key_last4, rate_limit_window, rate_limit_max_requests';

type AiSettingsRow = {
  id: string;
  llm_provider: string | null;
  llm_model: string | null;
  llm_api_key_last4: string | null;
  embedding_provider: string | null;
  embedding_model: string | null;
  embedding_api_key_last4: string | null;
  rate_limit_window: string | null;
  rate_limit_max_requests: number | null;
};

type SecretRow = { llm_api_key: string | null; embedding_api_key: string | null };

function toAiSettings(
  row: AiSettingsRow,
  embeddedDocuments: ConnectedAgentAiSettings['embeddedDocuments'],
): ConnectedAgentAiSettings {
  return {
    llmProvider: isLlmProvider(row.llm_provider) ? row.llm_provider : null,
    llmModel: row.llm_model,
    llmApiKeyLast4: row.llm_api_key_last4,
    embeddingProvider: isEmbeddingProvider(row.embedding_provider) ? row.embedding_provider : null,
    embeddingModel: row.embedding_model,
    embeddingApiKeyLast4: row.embedding_api_key_last4,
    rateLimitWindow: isRateLimitWindow(row.rate_limit_window) ? row.rate_limit_window : null,
    rateLimitMaxRequests: row.rate_limit_max_requests,
    embeddedDocuments,
  };
}

async function loadEmbeddedDocumentGroups(
  supabase: SupabaseClient,
  projectAgentIds: string[],
): Promise<
  { ok: true; byAgent: Map<string, ConnectedAgentAiSettings['embeddedDocuments']> } | { ok: false; message: string }
> {
  const byAgent = new Map<string, ConnectedAgentAiSettings['embeddedDocuments']>();
  if (projectAgentIds.length === 0) return { ok: true, byAgent };
  const { data, error } = await supabase
    .from('documents')
    .select('project_agent_id, embedding_provider, embedding_model')
    .in('project_agent_id', projectAgentIds)
    .eq('is_deleted', false)
    .gt('chunk_count', 0);
  if (error) return { ok: false, message: error.message };

  const counts = new Map<string, Map<string, number>>();
  for (const d of (data ?? []) as Array<{
    project_agent_id: string;
    embedding_provider: string | null;
    embedding_model: string | null;
  }>) {
    const key = d.embedding_model
      ? embeddingModelKey(d.embedding_provider ?? 'unknown', d.embedding_model)
      : 'unknown model';
    const perAgent = counts.get(d.project_agent_id) ?? new Map<string, number>();
    perAgent.set(key, (perAgent.get(key) ?? 0) + 1);
    counts.set(d.project_agent_id, perAgent);
  }
  for (const [agentId, perAgent] of counts) {
    byAgent.set(
      agentId,
      [...perAgent.entries()].map(([embeddingModel, count]) => ({ embeddingModel, count })),
    );
  }
  return { ok: true, byAgent };
}

/** AI settings for the given project agents (no keys — only their last four characters). */
export async function fetchConnectedAgentAiSettings(
  supabase: SupabaseClient,
  projectAgentIds: string[],
): Promise<{ ok: true; byAgent: Map<string, ConnectedAgentAiSettings> } | { ok: false; message: string }> {
  const byAgent = new Map<string, ConnectedAgentAiSettings>();
  if (projectAgentIds.length === 0) return { ok: true, byAgent };

  const [{ data, error }, docs] = await Promise.all([
    supabase.from('project_agents').select(AI_SETTINGS_COLUMNS).in('id', projectAgentIds),
    loadEmbeddedDocumentGroups(supabase, projectAgentIds),
  ]);
  if (error) return { ok: false, message: error.message };
  if (!docs.ok) return docs;

  for (const row of (data ?? []) as AiSettingsRow[]) {
    byAgent.set(row.id, toAiSettings(row, docs.byAgent.get(row.id) ?? []));
  }
  return { ok: true, byAgent };
}

/**
 * Validate, test-call and store the Conversational Agent's AI settings. The caller has
 * already checked that the user is an org owner/admin. Keys are written with the
 * service role into project_agent_llm_secrets and never returned.
 */
export async function saveConversationalAgentAiSettings(
  projectAgentId: string,
  input: AiSettingsInput,
): Promise<{ ok: true } | { ok: false; message: string }> {
  const admin = getSupabaseServiceRoleClient();

  const [{ data: row, error: rowErr }, { data: secret, error: secretErr }] = await Promise.all([
    admin.from('project_agents').select(AI_SETTINGS_COLUMNS).eq('id', projectAgentId).maybeSingle(),
    admin
      .from('project_agent_llm_secrets')
      .select('llm_api_key, embedding_api_key')
      .eq('project_agent_id', projectAgentId)
      .maybeSingle(),
  ]);
  if (rowErr) return { ok: false, message: rowErr.message };
  if (secretErr) return { ok: false, message: secretErr.message };
  if (!row) return { ok: false, message: 'Connected agent not found.' };

  const current = row as AiSettingsRow;
  const savedSecret = (secret as SecretRow | null) ?? { llm_api_key: null, embedding_api_key: null };
  const saved = toAiSettings(current, []);
  const planned = planAiSettingsUpdate(
    {
      llmProvider: saved.llmProvider,
      llmModel: saved.llmModel,
      hasLlmApiKey: Boolean(savedSecret.llm_api_key),
      embeddingProvider: saved.embeddingProvider,
      embeddingModel: saved.embeddingModel,
      hasOwnEmbeddingApiKey: Boolean(savedSecret.embedding_api_key),
      rateLimitWindow: saved.rateLimitWindow,
      rateLimitMaxRequests: saved.rateLimitMaxRequests,
    },
    input,
  );
  if (!planned.ok) return planned;
  const plan = planned.plan;
  if (!plan.changed) return { ok: true };

  // A different embedding model makes existing vectors unsearchable: refuse until the
  // documents embedded with another model are deleted.
  if (plan.embedding && plan.embeddingModelChanged) {
    const docs = await loadEmbeddedDocumentGroups(admin, [projectAgentId]);
    if (!docs.ok) return docs;
    const target = embeddingModelKey(plan.embedding.provider, plan.embedding.model);
    const incompatible = (docs.byAgent.get(projectAgentId) ?? []).filter((d) => d.embeddingModel !== target);
    const count = incompatible.reduce((n, d) => n + d.count, 0);
    if (count > 0) {
      return {
        ok: false,
        message: deleteDocumentsFirstMessage(
          count,
          incompatible.map((d) => d.embeddingModel),
          target,
        ),
      };
    }
  }

  const llmKey = plan.newLlmApiKey ?? savedSecret.llm_api_key ?? '';
  const embeddingKey = plan.newEmbeddingApiKey ?? (plan.embeddingReusesLlmKey ? llmKey : savedSecret.embedding_api_key ?? '');

  const check = await validateLlmConfigViaRagAgent({
    llm: plan.validateLlm && plan.llm ? { ...plan.llm, apiKey: llmKey } : null,
    embedding: plan.validateEmbedding && plan.embedding ? { ...plan.embedding, apiKey: embeddingKey } : null,
  });
  if (!check.ok) return check;

  const storedEmbeddingKey = plan.newEmbeddingApiKey
    ? plan.newEmbeddingApiKey
    : plan.clearOwnEmbeddingApiKey || plan.embeddingReusesLlmKey
      ? null
      : savedSecret.embedding_api_key;

  if (plan.newLlmApiKey || plan.newEmbeddingApiKey || plan.clearOwnEmbeddingApiKey) {
    const { error: upsertErr } = await admin.from('project_agent_llm_secrets').upsert(
      {
        project_agent_id: projectAgentId,
        llm_api_key: plan.newLlmApiKey ?? savedSecret.llm_api_key,
        embedding_api_key: storedEmbeddingKey,
        updated_at: new Date().toISOString(),
      },
      { onConflict: 'project_agent_id' },
    );
    if (upsertErr) return { ok: false, message: upsertErr.message };
  }

  const { error: updateErr } = await admin
    .from('project_agents')
    .update({
      llm_provider: plan.llm?.provider ?? null,
      llm_model: plan.llm?.model ?? null,
      llm_api_key_last4: plan.newLlmApiKey ? apiKeyLast4(plan.newLlmApiKey) : current.llm_api_key_last4,
      embedding_provider: plan.embedding?.provider ?? null,
      embedding_model: plan.embedding?.model ?? null,
      embedding_api_key_last4: storedEmbeddingKey ? apiKeyLast4(storedEmbeddingKey) : null,
      rate_limit_window: plan.rateLimit?.window ?? null,
      rate_limit_max_requests: plan.rateLimit?.maxRequests ?? null,
    })
    .eq('id', projectAgentId);
  if (updateErr) return { ok: false, message: updateErr.message };

  return { ok: true };
}

/**
 * Refuse document embedding for agents without their own embedding key (there is no
 * platform key). Returns the message to show, or null when every agent is ready.
 */
export async function missingEmbeddingKeysMessage(
  supabase: SupabaseClient,
  projectAgentIds: string[],
): Promise<{ ok: true; message: string | null } | { ok: false; message: string }> {
  const res = await fetchConnectedAgentAiSettings(supabase, projectAgentIds);
  if (!res.ok) return res;
  const missing = projectAgentIds.filter((id) => !isEmbeddingConfigured(res.byAgent.get(id)));
  if (missing.length === 0) return { ok: true, message: null };
  return {
    ok: true,
    message:
      'Add the embedding provider, model and API key in Connected Agents → Conversational Agent before uploading documents. Agent Engine does not provide an embedding key.',
  };
}
