"""Factory de sélection du fournisseur de synthèse IA."""

from __future__ import annotations

import logging
from urllib.parse import parse_qsl, urlparse

from pronote_sync.config.settings import AISettings
from pronote_sync.synthesis.openai import OpenAISynthesisProvider
from pronote_sync.synthesis.provider import SynthesisProvider
from pronote_sync.utils.redaction import redact_url

logger = logging.getLogger(__name__)

__all__ = ["get_synthesis_provider", "SynthesisProvider", "OpenAISynthesisProvider"]


def _validate_openai_compatible_config(
    url: str | None, model: str | None, allow_insecure_http: bool
) -> str | None:
    """Valide la configuration du provider ``openai-compatible``.

    Vérifie la présence de l'URL de base et du modèle, le schéma de l'URL
    (HTTPS obligatoire, HTTP accepté uniquement si ``allow_insecure_http``
    vaut ``True``), la présence d'un hostname non vide, l'absence
    d'identifiants dans le netloc et de paramètres sensibles dans la
    requête (y compris les paramètres sans valeur). Une URL malformée
    (``ValueError`` levé par ``urlparse``) est également rejetée. En cas
    d'échec, un avertissement est journalisé (l'URL est toujours masquée
    via :func:`redact_url`) et ``None`` est retourné : la synthèse IA se
    dégrade silencieusement, sans jamais lever d'exception.

    :param url: URL de base de l'API compatible OpenAI.
    :param model: Identifiant du modèle à utiliser.
    :param allow_insecure_http: Autorise ou non les URLs en HTTP.
    :return: L'URL validée, inchangée (aucune manipulation du chemin ou du
        suffixe ``/v1``), ou ``None`` si la configuration est invalide.
    :rtype: str | None
    """
    if not url:
        logger.warning("URL de base requise pour le provider openai-compatible")
        return None
    if not model:
        logger.warning("Modèle requis pour le provider openai-compatible")
        return None

    try:
        parsed = urlparse(url)
    except ValueError:
        logger.warning(
            "URL invalide pour le provider openai-compatible : %s",
            redact_url(url),
        )
        return None
    if not parsed.hostname:
        logger.warning(
            "URL sans hostname pour le provider openai-compatible : %s",
            redact_url(url),
        )
        return None
    if parsed.scheme not in ("http", "https"):
        logger.warning(
            "Schéma d'URL non supporté pour le provider openai-compatible : %s",
            redact_url(url),
        )
        return None
    if parsed.scheme == "http" and not allow_insecure_http:
        logger.warning(
            "URL HTTP non autorisée sans AI_ALLOW_INSECURE_HTTP=true : %s",
            redact_url(url),
        )
        return None
    if parsed.username is not None or parsed.password is not None:
        logger.warning("Credentials dans l'URL refusés : %s", redact_url(url))
        return None
    sensitive_names = {"token", "key", "api_key", "secret", "password", "auth"}
    param_names = [name.lower() for name, _ in parse_qsl(parsed.query, keep_blank_values=True)]
    if any(name in sensitive_names for name in param_names):
        logger.warning("Paramètres sensibles dans l'URL refusés : %s", redact_url(url))
        return None
    return url


def get_synthesis_provider(settings: AISettings) -> SynthesisProvider | None:
    """Sélectionne le fournisseur de synthèse IA selon la configuration.

    Retourne ``None`` lorsque la synthèse IA est désactivée ou qu'aucune clé
    API n'est configurée. Pour le provider ``litellm``, le paquet ``litellm``
    (extra ``ai-litellm``) est requis : s'il est absent, un avertissement est
    journalisé et ``None`` est retourné. Pour le provider
    ``openai-compatible``, la configuration (URL de base et modèle) est
    validée par :func:`_validate_openai_compatible_config` ; en cas de
    rejet, ``None`` est retourné avec un avertissement.

    :param settings: Paramètres IA.
    :return: Le fournisseur configuré, ou ``None`` si désactivé, sans clé API
        ou avec une configuration ``openai-compatible`` invalide.
    :rtype: SynthesisProvider | None
    """
    if not settings.enabled:
        return None
    if not settings.api_key:
        return None

    base_url = settings.base_url
    model = settings.model or "gpt-4o-mini"

    if settings.provider == "litellm":
        try:
            from pronote_sync.synthesis.litellm import LiteLLMSynthesisProvider
        except ImportError:
            logger.warning("Extra 'ai-litellm' requis pour le provider litellm")
            return None
        return LiteLLMSynthesisProvider(api_key=settings.api_key, base_url=base_url, model=model)

    if settings.provider == "openai-compatible":
        url = _validate_openai_compatible_config(
            settings.base_url, settings.model, settings.allow_insecure_http
        )
        if url is None:
            return None
        return OpenAISynthesisProvider(api_key=settings.api_key, base_url=url, model=model)

    return OpenAISynthesisProvider(api_key=settings.api_key, base_url=base_url, model=model)