"""Translation provider factory and HTTP provider implementation."""
from __future__ import annotations

import logging
from typing import Any, Dict, Optional
import requests

from config.services_config import get_translation_config, get_translation_base_url

logger = logging.getLogger(__name__)


class HttpTranslationProvider:
    """Translation via HTTP service."""

    def __init__(
        self,
        base_url: str,
        model: str = "qwen",
        timeout_sec: float = 10.0,
    ):
        self.base_url = (base_url or "").rstrip("/")
        self.model = model or "qwen"
        self.timeout_sec = float(timeout_sec or 10.0)

    def _translate_once(
        self,
        text: str,
        target_lang: str,
        source_lang: Optional[str] = None,
        context: Optional[str] = None,
        prompt: Optional[str] = None,
    ) -> Optional[str]:
        if not text or not str(text).strip():
            return text
        try:
            url = f"{self.base_url}/translate"
            payload = {
                "text": text,
                "target_lang": target_lang,
                "source_lang": source_lang or "auto",
                "model": self.model,
            }
            if context:
                payload["context"] = context
            if prompt:
                payload["prompt"] = prompt
            response = requests.post(url, json=payload, timeout=self.timeout_sec)
            if response.status_code != 200:
                logger.warning(
                    "HTTP translator failed: status=%s body=%s",
                    response.status_code,
                    (response.text or "")[:200],
                )
                return None
            data = response.json()
            translated = data.get("translated_text")
            return translated if translated is not None else None
        except Exception as exc:
            logger.warning("HTTP translator request failed: %s", exc, exc_info=True)
            return None

    def translate(
        self,
        text: str,
        target_lang: str,
        source_lang: Optional[str] = None,
        context: Optional[str] = None,
        prompt: Optional[str] = None,
    ) -> Optional[str]:
        return self._translate_once(
            text=text,
            target_lang=target_lang,
            source_lang=source_lang,
            context=context,
            prompt=prompt,
        )


def create_translation_provider(query_config: Any = None) -> Any:
    """
    Create translation provider from services config.

    query_config: optional, for api_key/glossary_id/context (used by direct provider).
    """
    cfg = get_translation_config()
    provider = cfg.provider
    pc = cfg.get_provider_cfg()

    if provider in ("qwen-mt", "direct", "local", "inprocess"):
        from query.qwen_mt_translate import Translator
        model = pc.get("model") or "qwen-mt-flash"
        qc = query_config or _empty_query_config()
        return Translator(
            model=model,
            api_key=getattr(qc, "translation_api_key", None),
            use_cache=True,
            glossary_id=getattr(qc, "translation_glossary_id", None),
            translation_context=getattr(qc, "translation_context", "e-commerce product search"),
        )

    elif provider in ("http", "service"):
        base_url = get_translation_base_url()
        model = pc.get("model") or "qwen"
        timeout = pc.get("timeout_sec", 10.0)
        qc = query_config or _empty_query_config()
        return HttpTranslationProvider(
            base_url=base_url,
            model=model,
            timeout_sec=float(timeout),
        )

    elif provider == "llm":
        from query.llm_translate import LLMTranslatorProvider
        model = pc.get("model")
        timeout = float(pc.get("timeout_sec", 30.0))
        base_url = (pc.get("base_url") or "").strip() or None
        return LLMTranslatorProvider(
            model=model,
            timeout_sec=timeout,
            base_url=base_url,
        )

    elif provider == "deepl":
        from query.deepl_provider import DeepLProvider
        qc = query_config or _empty_query_config()
        return DeepLProvider(
            api_key=getattr(qc, "translation_api_key", None),
            timeout=float(pc.get("timeout_sec", 10.0)),
            glossary_id=pc.get("glossary_id") or getattr(qc, "translation_glossary_id", None),
        )

    raise ValueError(f"Unsupported translation provider: {provider}")


def _empty_query_config() -> Any:
    """Minimal object with default translation attrs."""
    class _QC:
        translation_api_key = None
        translation_glossary_id = None
        translation_context = "e-commerce product search"
    return _QC()