"""
Online suggestion query service.
"""

import logging
import time
from typing import Any, Dict, List, Optional

from config.tenant_config_loader import get_tenant_config_loader
from suggestion.builder import (
    get_suggestion_alias_name,
    get_suggestion_index_name,
    get_suggestion_legacy_index_name,
)
from utils.es_client import ESClient

logger = logging.getLogger(__name__)


class SuggestionService:
    def __init__(self, es_client: ESClient):
        self.es_client = es_client

    def _resolve_language(self, tenant_id: str, language: str) -> str:
        cfg = get_tenant_config_loader().get_tenant_config(tenant_id)
        index_languages = cfg.get("index_languages") or ["en", "zh"]
        primary = cfg.get("primary_language") or "en"
        lang = (language or "").strip().lower().replace("-", "_")
        if lang in {"zh_tw", "pt_br"}:
            normalized = lang
        else:
            normalized = lang.split("_")[0] if lang else ""
        if normalized in index_languages:
            return normalized
        if primary in index_languages:
            return primary
        return index_languages[0]

    def _resolve_search_target(self, tenant_id: str) -> Optional[str]:
        alias_name = get_suggestion_alias_name(tenant_id)
        if self.es_client.alias_exists(alias_name):
            return alias_name

        # Fallback for pre-Phase2 deployments
        legacy = get_suggestion_legacy_index_name(tenant_id)
        if self.es_client.index_exists(legacy):
            return legacy

        # Last fallback: current naming helper
        candidate = get_suggestion_index_name(tenant_id)
        if self.es_client.index_exists(candidate):
            return candidate
        return None

    def _completion_suggest(
        self,
        index_name: str,
        query: str,
        lang: str,
        size: int,
        tenant_id: str,
    ) -> List[Dict[str, Any]]:
        """
        Query ES completion suggester from `completion.<lang>`.

        Returns items in the same shape as search hits -> dicts with "text"/"lang"/"score"/"rank_score"/"sources".
        """
        field_name = f"completion.{lang}"
        body = {
            "suggest": {
                "s": {
                    "prefix": query,
                    "completion": {
                        "field": field_name,
                        "size": size,
                        "skip_duplicates": True,
                    },
                }
            },
            "_source": [
                "text",
                "lang",
                "rank_score",
                "sources",
                "lang_source",
                "lang_confidence",
                "lang_conflict",
            ],
        }
        try:
            resp = self.es_client.client.search(index=index_name, body=body, routing=str(tenant_id))
        except Exception as e:
            # completion is an optimization path; never hard-fail the whole endpoint
            logger.warning("Completion suggest failed for index=%s field=%s: %s", index_name, field_name, e)
            return []

        entries = (resp.get("suggest", {}) or {}).get("s", []) or []
        if not entries:
            return []
        options = entries[0].get("options", []) or []
        out: List[Dict[str, Any]] = []
        for opt in options:
            src = opt.get("_source", {}) or {}
            out.append(
                {
                    "text": src.get("text") or opt.get("text"),
                    "lang": src.get("lang") or lang,
                    "score": opt.get("_score", 0.0),
                    "rank_score": src.get("rank_score"),
                    "sources": src.get("sources", []),
                    "lang_source": src.get("lang_source"),
                    "lang_confidence": src.get("lang_confidence"),
                    "lang_conflict": src.get("lang_conflict", False),
                }
            )
        return out

    def search(
        self,
        tenant_id: str,
        query: str,
        language: str,
        size: int = 10,
    ) -> Dict[str, Any]:
        start = time.time()
        resolved_lang = self._resolve_language(tenant_id, language)
        index_name = self._resolve_search_target(tenant_id)
        if not index_name:
            # On a fresh ES cluster the suggestion index might not be built yet.
            # Keep endpoint stable for frontend autocomplete: return empty list instead of 500.
            took_ms = int((time.time() - start) * 1000)
            return {
                "query": query,
                "language": language,
                "resolved_language": resolved_lang,
                "suggestions": [],
                "took_ms": took_ms,
            }

        sat_field = f"sat.{resolved_lang}"
        dsl = {
            "track_total_hits": False,
            "query": {
                "function_score": {
                    "query": {
                        "bool": {
                            "filter": [
                                {"term": {"lang": resolved_lang}},
                                {"term": {"status": 1}},
                            ],
                            "should": [
                                {
                                    "multi_match": {
                                        "query": query,
                                        "type": "bool_prefix",
                                        "fields": [sat_field, f"{sat_field}._2gram", f"{sat_field}._3gram"],
                                    }
                                }
                            ],
                            "minimum_should_match": 1,
                        }
                    },
                    "field_value_factor": {
                        "field": "rank_score",
                        "factor": 1.0,
                        "modifier": "log1p",
                        "missing": 0.0,
                    },
                    "boost_mode": "sum",
                    "score_mode": "sum",
                }
            },
            "_source": [
                "text",
                "lang",
                "rank_score",
                "sources",
                "lang_source",
                "lang_confidence",
                "lang_conflict",
            ],
        }
        # Recall path A: bool_prefix on search_as_you_type
        es_resp = self.es_client.search(
            index_name=index_name,
            body=dsl,
            size=size,
            from_=0,
            routing=str(tenant_id),
        )
        hits = es_resp.get("hits", {}).get("hits", []) or []

        # Recall path B: completion suggester (optional optimization)
        completion_items = self._completion_suggest(
            index_name=index_name,
            query=query,
            lang=resolved_lang,
            size=size,
            tenant_id=tenant_id,
        )

        suggestions: List[Dict[str, Any]] = []
        seen_text_norm: set = set()

        def _norm_text(v: Any) -> str:
            return str(v or "").strip().lower()

        # Put completion results first (usually better prefix UX), then fill with sat results.
        for item in completion_items:
            text_val = item.get("text")
            norm = _norm_text(text_val)
            if not norm or norm in seen_text_norm:
                continue
            seen_text_norm.add(norm)
            suggestions.append(dict(item))

        for hit in hits:
            src = hit.get("_source", {}) or {}
            text_val = src.get("text")
            norm = _norm_text(text_val)
            if not norm or norm in seen_text_norm:
                continue
            seen_text_norm.add(norm)
            item = {
                "text": text_val,
                "lang": src.get("lang"),
                "score": hit.get("_score", 0.0),
                "rank_score": src.get("rank_score"),
                "sources": src.get("sources", []),
                "lang_source": src.get("lang_source"),
                "lang_confidence": src.get("lang_confidence"),
                "lang_conflict": src.get("lang_conflict", False),
            }
            suggestions.append(item)

        took_ms = int((time.time() - start) * 1000)
        return {
            "query": query,
            "language": language,
            "resolved_language": resolved_lang,
            "suggestions": suggestions[:size],
            "took_ms": took_ms,
        }