"""
Services configuration - single source for translation, embedding, rerank providers.

All provider selection and endpoint resolution is centralized here.
Priority: env vars > config.yaml.
"""

from __future__ import annotations

import os
from dataclasses import dataclass, field
from functools import lru_cache
from pathlib import Path
from typing import Any, Dict, Optional

import yaml


@dataclass
class ServiceConfig:
    """Config for one capability (translation/embedding/rerank)."""
    provider: str
    providers: Dict[str, Any] = field(default_factory=dict)

    def get_provider_cfg(self) -> Dict[str, Any]:
        """Get config for current provider."""
        p = (self.provider or "").strip().lower()
        return self.providers.get(p, {}) if isinstance(self.providers, dict) else {}


def _load_services_raw(config_path: Optional[Path] = None) -> Dict[str, Any]:
    """Load services block from config.yaml."""
    if config_path is None:
        config_path = Path(__file__).parent / "config.yaml"
    path = Path(config_path)
    if not path.exists():
        raise FileNotFoundError(f"services config file not found: {path}")
    try:
        with open(path, "r", encoding="utf-8") as f:
            data = yaml.safe_load(f)
    except Exception as exc:
        raise RuntimeError(f"failed to parse services config from {path}: {exc}") from exc
    if not isinstance(data, dict):
        raise RuntimeError(f"invalid config format in {path}: expected mapping root")
    services = data.get("services")
    if not isinstance(services, dict):
        raise RuntimeError("config.yaml must contain a valid 'services' mapping")
    return services


def _resolve_provider_name(
    env_name: str,
    config_provider: Any,
    capability: str,
) -> str:
    provider = os.getenv(env_name) or config_provider
    if not provider:
        raise ValueError(
            f"services.{capability}.provider is required "
            f"(or set env override {env_name})"
        )
    return str(provider).strip().lower()


def _resolve_translation() -> ServiceConfig:
    raw = _load_services_raw()
    cfg = raw.get("translation", {}) if isinstance(raw.get("translation"), dict) else {}
    providers = cfg.get("providers", {}) if isinstance(cfg.get("providers"), dict) else {}

    provider = _resolve_provider_name(
        env_name="TRANSLATION_PROVIDER",
        config_provider=cfg.get("provider"),
        capability="translation",
    )
    if provider not in ("qwen-mt", "deepl", "direct", "local", "inprocess", "http", "service", "llm"):
        raise ValueError(f"Unsupported translation provider: {provider}")

    # Env override for http base_url
    env_url = os.getenv("TRANSLATION_SERVICE_URL")
    if env_url and provider in ("http", "service"):
        providers = dict(providers)
        providers["http"] = dict(providers.get("http", {}))
        providers["http"]["base_url"] = env_url.rstrip("/")

    return ServiceConfig(provider=provider, providers=providers)


def _resolve_embedding() -> ServiceConfig:
    raw = _load_services_raw()
    cfg = raw.get("embedding", {}) if isinstance(raw.get("embedding"), dict) else {}
    providers = cfg.get("providers", {}) if isinstance(cfg.get("providers"), dict) else {}

    provider = _resolve_provider_name(
        env_name="EMBEDDING_PROVIDER",
        config_provider=cfg.get("provider"),
        capability="embedding",
    )
    if provider != "http":
        raise ValueError(f"Unsupported embedding provider: {provider}")

    env_url = os.getenv("EMBEDDING_SERVICE_URL")
    if env_url and provider == "http":
        providers = dict(providers)
        providers["http"] = dict(providers.get("http", {}))
        providers["http"]["base_url"] = env_url.rstrip("/")

    return ServiceConfig(provider=provider, providers=providers)


def _resolve_rerank() -> ServiceConfig:
    raw = _load_services_raw()
    cfg = raw.get("rerank", {}) if isinstance(raw.get("rerank"), dict) else {}
    providers = cfg.get("providers", {}) if isinstance(cfg.get("providers"), dict) else {}

    provider = _resolve_provider_name(
        env_name="RERANK_PROVIDER",
        config_provider=cfg.get("provider"),
        capability="rerank",
    )
    if provider != "http":
        raise ValueError(f"Unsupported rerank provider: {provider}")

    env_url = os.getenv("RERANKER_SERVICE_URL")
    if env_url:
        url = env_url.rstrip("/")
        if not url.endswith("/rerank"):
            url = f"{url}/rerank" if "/rerank" not in url else url
        providers = dict(providers)
        providers["http"] = dict(providers.get("http", {}))
        providers["http"]["base_url"] = url.replace("/rerank", "")
        providers["http"]["service_url"] = url

    return ServiceConfig(provider=provider, providers=providers)


def get_rerank_backend_config() -> tuple[str, dict]:
    """
    Resolve reranker backend name and config for the reranker service process.
    Returns (backend_name, backend_cfg).
    Env RERANK_BACKEND overrides config.
    """
    raw = _load_services_raw()
    cfg = raw.get("rerank", {}) if isinstance(raw.get("rerank"), dict) else {}
    backends = cfg.get("backends", {}) if isinstance(cfg.get("backends"), dict) else {}
    name = (
        os.getenv("RERANK_BACKEND")
        or cfg.get("backend")
    )
    if not name:
        raise ValueError("services.rerank.backend is required (or env RERANK_BACKEND)")
    name = str(name).strip().lower()
    backend_cfg = backends.get(name, {}) if isinstance(backends.get(name), dict) else {}
    if not backend_cfg:
        raise ValueError(f"services.rerank.backends.{name} is required")
    return name, backend_cfg


def get_embedding_backend_config() -> tuple[str, dict]:
    """
    Resolve embedding backend name and config for the embedding service process.
    Returns (backend_name, backend_cfg).
    Env EMBEDDING_BACKEND overrides config.
    """
    raw = _load_services_raw()
    cfg = raw.get("embedding", {}) if isinstance(raw.get("embedding"), dict) else {}
    backends = cfg.get("backends", {}) if isinstance(cfg.get("backends"), dict) else {}
    name = (
        os.getenv("EMBEDDING_BACKEND")
        or cfg.get("backend")
    )
    if not name:
        raise ValueError("services.embedding.backend is required (or env EMBEDDING_BACKEND)")
    name = str(name).strip().lower()
    backend_cfg = backends.get(name, {}) if isinstance(backends.get(name), dict) else {}
    if not backend_cfg:
        raise ValueError(f"services.embedding.backends.{name} is required")
    return name, backend_cfg


@lru_cache(maxsize=1)
def get_translation_config() -> ServiceConfig:
    """Get translation service config."""
    return _resolve_translation()


@lru_cache(maxsize=1)
def get_embedding_config() -> ServiceConfig:
    """Get embedding service config."""
    return _resolve_embedding()


@lru_cache(maxsize=1)
def get_rerank_config() -> ServiceConfig:
    """Get rerank service config."""
    return _resolve_rerank()


def get_translation_base_url() -> str:
    """Resolve translation HTTP base URL (for http provider)."""
    base = (
        os.getenv("TRANSLATION_SERVICE_URL")
        or get_translation_config().providers.get("http", {}).get("base_url")
    )
    if not base:
        raise ValueError("Translation HTTP base_url is not configured")
    return str(base).rstrip("/")


def get_translation_cache_config() -> Dict[str, Any]:
    """
    Resolve translation cache policy from services.translation.cache.

    All translation cache key/TTL behavior should be configured in config.yaml,
    not hardcoded in code.
    """
    raw = _load_services_raw()
    cfg = raw.get("translation", {}) if isinstance(raw.get("translation"), dict) else {}
    cache_cfg = cfg.get("cache", {}) if isinstance(cfg.get("cache"), dict) else {}
    return {
        "enabled": bool(cache_cfg.get("enabled", True)),
        "key_prefix": str(cache_cfg.get("key_prefix", "trans:v2")),
        "ttl_seconds": int(cache_cfg.get("ttl_seconds", 360 * 24 * 3600)),
        "sliding_expiration": bool(cache_cfg.get("sliding_expiration", True)),
        "key_include_context": bool(cache_cfg.get("key_include_context", True)),
        "key_include_prompt": bool(cache_cfg.get("key_include_prompt", True)),
        "key_include_source_lang": bool(cache_cfg.get("key_include_source_lang", True)),
    }


def get_embedding_base_url() -> str:
    """Resolve embedding HTTP base URL."""
    base = (
        os.getenv("EMBEDDING_SERVICE_URL")
        or get_embedding_config().providers.get("http", {}).get("base_url")
    )
    if not base:
        raise ValueError("Embedding HTTP base_url is not configured")
    return str(base).rstrip("/")


def get_rerank_service_url() -> str:
    """Resolve rerank service URL (full path including /rerank)."""
    base = (
        os.getenv("RERANKER_SERVICE_URL")
        or get_rerank_config().providers.get("http", {}).get("service_url")
        or get_rerank_config().providers.get("http", {}).get("base_url")
    )
    if not base:
        raise ValueError("Rerank HTTP service_url/base_url is not configured")
    base = str(base).rstrip("/")
    return base if base.endswith("/rerank") else f"{base}/rerank"


def clear_services_cache() -> None:
    """Clear cached config (for tests)."""
    get_translation_config.cache_clear()
    get_embedding_config.cache_clear()
    get_rerank_config.cache_clear()