"""
  Online suggestion query service.
  """
  
  import logging
  import time
  from typing import Any, Dict, List, Optional
  

  from config.loader import get_app_config
  from config.schema import SuggestionConfig

  from config.tenant_config_loader import get_tenant_config_loader

  from query.tokenization import simple_tokenize_query

  from suggestion.builder import get_suggestion_alias_name

  from utils.es_client import ESClient
  
  logger = logging.getLogger(__name__)
  
  

  def _suggestion_length_factor(text: str) -> float:
      """Down-weight longer strings at query time: factor 1 / sqrt(token_len)."""
      n = max(len(simple_tokenize_query(str(text or ""))), 1)
      return 1.0 / (n ** 0.5)
  
  
  def _score_with_token_length_penalty(item: Dict[str, Any]) -> float:
      base = float(item.get("score") or 0.0)
      return base * _suggestion_length_factor(str(item.get("text") or ""))
  
  

  def _resolve_suggestion_config_for_tenant(tenant_id: str) -> SuggestionConfig:
      """Merge root ``suggestion`` with ``tenant_config.default`` / per-tenant ``suggestion`` overrides."""
      app = get_app_config()
      base = app.suggestion
      d = app.tenants.default if isinstance(app.tenants.default, dict) else {}
      d_s = d.get("suggestion") if isinstance(d.get("suggestion"), dict) else {}
      t = app.tenants.tenants.get(str(tenant_id), {}) or {}
      t_s = t.get("suggestion") if isinstance(t.get("suggestion"), dict) else {}
  
      def _i(key: str, fallback: int) -> int:
          if key in t_s and t_s[key] is not None:
              return int(t_s[key])
          if key in d_s and d_s[key] is not None:
              return int(d_s[key])
          return fallback
  
      mn = _i("sat_recall_min", base.sat_recall_min)
      cap = _i("sat_recall_cap", base.sat_recall_cap)
      if mn < 1:
          mn = 1
      if cap < mn:
          cap = mn
      return SuggestionConfig(sat_recall_min=mn, sat_recall_cap=cap)
  
  
  def _sat_es_size(client_size: int, cfg: SuggestionConfig) -> int:
      """ES size for SAT (bool_prefix) recall: ``min(max(client_size, sat_recall_min), sat_recall_cap)``."""
      c = max(int(client_size), 0)
      return min(max(c, cfg.sat_recall_min), cfg.sat_recall_cap)
  
  

  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

          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()

          query_text = str(query or "").strip()

          resolved_lang = self._resolve_language(tenant_id, language)

          sugg_cfg = _resolve_suggestion_config_for_tenant(tenant_id)
          sat_es_size = _sat_es_size(size, sugg_cfg)

          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,
              }

          # Recall path A: completion suggester (fast path, usually enough for short prefix typing)
          t_completion_start = time.time()
          completion_items = self._completion_suggest(
              index_name=index_name,
              query=query_text,
              lang=resolved_lang,
              size=size,
              tenant_id=tenant_id,
          )
          completion_ms = int((time.time() - t_completion_start) * 1000)
  
          suggestions: List[Dict[str, Any]] = []
          seen_text_norm: set = set()
  
          def _norm_text(v: Any) -> str:
              return str(v or "").strip().lower()
  
          def _append_items(items: List[Dict[str, Any]]) -> None:
              for item in 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))
  

          def _finalize_suggestion_list(items: List[Dict[str, Any]], limit: int) -> List[Dict[str, Any]]:
              out = list(items)
              out.sort(
                  key=lambda x: (
                      _score_with_token_length_penalty(x),
                      float(x.get("rank_score") or 0.0),
                  ),
                  reverse=True,
              )
              return out[:limit]
  

          _append_items(completion_items)
  
          # Fast path: avoid a second ES query for short prefixes or when completion already full.
          if len(query_text) <= 2 or len(suggestions) >= size:
              took_ms = int((time.time() - start) * 1000)
              logger.info(
                  "suggest completion-fast-return | tenant=%s lang=%s q=%s completion=%d took_ms=%d completion_ms=%d",
                  tenant_id,
                  resolved_lang,
                  query_text,
                  len(suggestions),
                  took_ms,
                  completion_ms,
              )
              return {
                  "query": query,
                  "language": language,
                  "resolved_language": resolved_lang,

                  "suggestions": _finalize_suggestion_list(suggestions, size),

                  "took_ms": took_ms,
              }
  
          # Recall path B: bool_prefix on search_as_you_type (fallback/recall补全)

          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_text,

                                          "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",
              ],
          }

          t_sat_start = time.time()

          es_resp = self.es_client.search(
              index_name=index_name,
              body=dsl,

              size=sat_es_size,

              from_=0,
              routing=str(tenant_id),
          )

          sat_ms = int((time.time() - t_sat_start) * 1000)

          hits = es_resp.get("hits", {}).get("hits", []) or []
  

          sat_items: List[Dict[str, Any]] = []

          for hit in hits:
              src = hit.get("_source", {}) or {}

              sat_items.append(
                  {
                      "text": src.get("text"),
                      "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),
                  }
              )
          _append_items(sat_items)

  
          took_ms = int((time.time() - start) * 1000)

          logger.info(

              "suggest completion+sat-return | tenant=%s lang=%s q=%s completion=%d sat_hits=%d sat_es_size=%d took_ms=%d completion_ms=%d sat_ms=%d",

              tenant_id,
              resolved_lang,
              query_text,
              len(completion_items),
              len(hits),

              sat_es_size,

              took_ms,
              completion_ms,
              sat_ms,
          )

          return {
              "query": query,
              "language": language,
              "resolved_language": resolved_lang,

              "suggestions": _finalize_suggestion_list(suggestions, size),

              "took_ms": took_ms,
          }