"""DeepSeek provider — OpenAI-compatible AsyncOpenAI client."""

from __future__ import annotations

from openai import AsyncOpenAI

from app.core.config import settings
from app.generation.llm_client import LLMAuthError, LLMClient, LLMClientError
from app.llm.providers.openai import OpenAIProvider


class DeepSeekProvider(OpenAIProvider):
    """DeepSeek chat provider using the OpenAI-compatible HTTP API."""

    def __init__(
        self,
        *,
        api_key: str | None = None,
        base_url: str | None = None,
        default_model: str | None = None,
        timeout_sec: int | None = None,
        max_retries: int | None = None,
        backoff_factor: float | None = None,
        client: AsyncOpenAI | None = None,
    ):
        key = api_key if api_key is not None else settings.DEEPSEEK_API_KEY
        if not str(key).strip():
            if settings.is_local():
                key = "local-dev"
            else:
                raise LLMAuthError(
                    "DEEPSEEK_API_KEY is required outside local/dev",
                    status_code=401,
                )

        resolved_timeout = timeout_sec or settings.LLM_REQUEST_TIMEOUT_SEC
        resolved_base = base_url or settings.DEEPSEEK_BASE_URL
        if not str(resolved_base).strip():
            raise LLMClientError("DEEPSEEK_BASE_URL is required for DeepSeekProvider")

        openai_client = client or AsyncOpenAI(
            api_key=key,
            base_url=resolved_base,
            timeout=resolved_timeout,
        )

        # Bypass LLMClient's OPENAI_API_KEY check by injecting key + client.
        LLMClient.__init__(
            self,
            api_key=key,
            default_model=default_model or "deepseek-chat",
            timeout_sec=resolved_timeout,
            max_retries=max_retries,
            backoff_factor=backoff_factor,
            client=openai_client,
        )