"""
author: Yagnik Poshiya
organization: Webbrains Technologies Private Limited

Loads the customer-supplied AI settings for one project agent: LLM provider, model
and API key, plus embedding provider, model and API key.

There is no platform key. A project agent without its own key cannot run, and every
LLM and embedding call for that project is made with the customer's key.

Non-secret settings live on public.project_agents; the keys live in
public.project_agent_llm_secrets (service role only).
"""

from __future__ import annotations

from dataclasses import dataclass
from typing import Any

from supabase import Client

SUPPORTED_LLM_PROVIDERS = frozenset({"google", "openai", "anthropic", "openrouter"})
SUPPORTED_EMBEDDING_PROVIDERS = frozenset({"google", "openai"})


class LlmNotConfiguredError(RuntimeError):
    """The project agent has no usable LLM / embedding configuration."""


@dataclass(frozen=True)
class ProjectLlmConfig:
    llm_provider: str
    llm_model: str
    llm_api_key: str
    embedding_provider: str
    embedding_model: str
    embedding_api_key: str


def resolve_embedding_api_key(
    *,
    llm_provider: str | None,
    llm_api_key: str | None,
    embedding_provider: str | None,
    embedding_api_key: str | None,
) -> str:
    """The embedding key, falling back to the LLM key when both use the same provider."""
    own = (embedding_api_key or "").strip()
    if own:
        return own
    same_provider = (embedding_provider or "").strip().lower() == (llm_provider or "").strip().lower()
    return (llm_api_key or "").strip() if same_provider else ""


def build_project_llm_config(
    settings_row: dict[str, Any] | None,
    secret_row: dict[str, Any] | None,
) -> ProjectLlmConfig:
    """Validate one project agent's settings + secrets; raise LlmNotConfiguredError if unusable."""
    row = settings_row or {}
    secret = secret_row or {}
    llm_provider = str(row.get("llm_provider") or "").strip().lower()
    llm_model = str(row.get("llm_model") or "").strip()
    llm_api_key = str(secret.get("llm_api_key") or "").strip()
    embedding_provider = str(row.get("embedding_provider") or "").strip().lower()
    embedding_model = str(row.get("embedding_model") or "").strip()
    embedding_api_key = resolve_embedding_api_key(
        llm_provider=llm_provider,
        llm_api_key=llm_api_key,
        embedding_provider=embedding_provider,
        embedding_api_key=secret.get("embedding_api_key"),
    )

    if llm_provider not in SUPPORTED_LLM_PROVIDERS or not llm_model or not llm_api_key:
        raise LlmNotConfiguredError("LLM provider, model or API key is not configured.")
    if embedding_provider not in SUPPORTED_EMBEDDING_PROVIDERS or not embedding_model or not embedding_api_key:
        raise LlmNotConfiguredError("Embedding provider, model or API key is not configured.")

    return ProjectLlmConfig(
        llm_provider=llm_provider,
        llm_model=llm_model,
        llm_api_key=llm_api_key,
        embedding_provider=embedding_provider,
        embedding_model=embedding_model,
        embedding_api_key=embedding_api_key,
    )


def load_project_llm_config(supabase: Client, project_agent_id: str) -> ProjectLlmConfig:
    settings_res = (
        supabase.table("project_agents")
        .select("llm_provider, llm_model, embedding_provider, embedding_model")
        .eq("id", project_agent_id)
        .eq("is_deleted", False)
        .limit(1)
        .execute()
    )
    settings_rows = list(settings_res.data or [])
    if not settings_rows:
        raise LlmNotConfiguredError(f"Project agent not found: {project_agent_id}")

    secret_res = (
        supabase.table("project_agent_llm_secrets")
        .select("llm_api_key, embedding_api_key")
        .eq("project_agent_id", project_agent_id)
        .limit(1)
        .execute()
    )
    secret_rows = list(secret_res.data or [])
    return build_project_llm_config(settings_rows[0], secret_rows[0] if secret_rows else None)
