"""TEI text embedding backend client."""
  
  from __future__ import annotations
  

  from typing import Any, List, Union

  
  import numpy as np
  import requests
  
  
  class TEITextModel:
      """
      Text embedding backend implemented via Hugging Face TEI HTTP API.
  
      Expected TEI endpoint:
        POST {base_url}/embed
        body: {"inputs": ["text1", "text2", ...]}
        response: [[...], [...], ...]
      """
  
      def __init__(self, base_url: str, timeout_sec: int = 60):
          if not base_url or not str(base_url).strip():
              raise ValueError("TEI base_url must not be empty")
          self.base_url = str(base_url).rstrip("/")
          self.endpoint = f"{self.base_url}/embed"
          self.timeout_sec = int(timeout_sec)
          self._health_check()
  
      def _health_check(self) -> None:
          health_url = f"{self.base_url}/health"
          response = requests.get(health_url, timeout=5)
          response.raise_for_status()

          # Probe one tiny embedding at startup so runtime requests do not fail later
          # with opaque "Invalid TEI embedding" errors.
          probe_resp = requests.post(
              self.endpoint,
              json={"inputs": ["health check"]},
              timeout=min(self.timeout_sec, 15),
          )
          probe_resp.raise_for_status()
          self._parse_payload(probe_resp.json(), expected_len=1)

  
      @staticmethod
      def _normalize(embedding: np.ndarray) -> np.ndarray:
          norm = np.linalg.norm(embedding)
          if norm <= 0:
              raise RuntimeError("TEI returned zero-norm embedding")
          return embedding / norm
  
      def encode(
          self,
          sentences: Union[str, List[str]],
          normalize_embeddings: bool = True,
          device: str = "cuda",
          batch_size: int = 32,
      ) -> np.ndarray:
          if isinstance(sentences, str):
              sentences = [sentences]
          return self.encode_batch(
              texts=sentences,
              batch_size=batch_size,
              device=device,
              normalize_embeddings=normalize_embeddings,
          )
  
      def encode_batch(
          self,
          texts: List[str],
          batch_size: int = 32,
          device: str = "cuda",
          normalize_embeddings: bool = True,
      ) -> np.ndarray:
          del batch_size  # TEI performs its own batching.
          del device      # Not used by HTTP backend.
  
          if texts is None or len(texts) == 0:
              return np.array([], dtype=object)
          for i, t in enumerate(texts):
              if not isinstance(t, str) or not t.strip():
                  raise ValueError(f"Invalid input text at index {i}: {t!r}")
  
          response = requests.post(
              self.endpoint,
              json={"inputs": texts},
              timeout=self.timeout_sec,
          )
          response.raise_for_status()
          payload = response.json()

          vectors = self._parse_payload(payload, expected_len=len(texts))
          if normalize_embeddings:
              vectors = [self._normalize(vec) for vec in vectors]
          return np.array(vectors, dtype=object)

      def _parse_payload(self, payload: Any, expected_len: int) -> List[np.ndarray]:
          if not isinstance(payload, list) or len(payload) != expected_len:
              got = 0 if payload is None else (len(payload) if isinstance(payload, list) else "non-list")

              raise RuntimeError(

                  f"TEI response length mismatch: expected {expected_len}, got {got}. "
                  f"Response type={type(payload).__name__}"

              )
  
          vectors: List[np.ndarray] = []

          for i, item in enumerate(payload):
              emb = item.get("embedding") if isinstance(item, dict) else item
              try:
                  vec = np.asarray(emb, dtype=np.float32)
              except (TypeError, ValueError) as exc:
                  raise RuntimeError(
                      f"Invalid TEI embedding at index {i}: cannot convert to float array "
                      f"(item_type={type(item).__name__})"
                  ) from exc
  
              if vec.ndim != 1 or vec.size == 0:
                  raise RuntimeError(
                      f"Invalid TEI embedding at index {i}: shape={vec.shape}, size={vec.size}"
                  )
              if not np.isfinite(vec).all():
                  preview = vec[:8].tolist()
                  raise RuntimeError(
                      f"Invalid TEI embedding at index {i}: contains non-finite values, "
                      f"preview={preview}. This often indicates TEI backend/model runtime issues "
                      f"(for example an incompatible dtype or model config)."
                  )

              vectors.append(vec)

          return vectors