"""
  Image encoder using third-party clip-as-service (Jina CLIP server).
  
  Requires clip-as-service server to be running. The client is loaded from
  third-party/clip-as-service/client so no separate pip install is needed
  if that path is on sys.path or the package is installed in development mode.
  """
  
  import logging
  import os
  import sys
  from typing import List, Optional
  
  import numpy as np
  
  logger = logging.getLogger(__name__)
  
  # Ensure third-party clip client is importable
  def _ensure_clip_client_path():
      repo_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
      client_path = os.path.join(repo_root, "third-party", "clip-as-service", "client")
      if os.path.isdir(client_path) and client_path not in sys.path:
          sys.path.insert(0, client_path)

      # Skip client version check to avoid importing helper (pkg_resources); no conda/separate env
      os.environ.setdefault("NO_VERSION_CHECK", "1")

  
  
  def _normalize_image_url(url: str) -> str:
      """Normalize image URL for clip-as-service (e.g. //host/path -> https://host/path)."""
      if not url or not isinstance(url, str):
          return ""
      url = url.strip()
      if url.startswith("//"):
          return "https:" + url
      return url
  
  
  class ClipAsServiceImageEncoder:
      """
      Image embedding encoder using clip-as-service Client.
      Encodes image URLs in batch; returns 1024-dim vectors (server model must match).
      """
  
      def __init__(
          self,
          server: str = "grpc://127.0.0.1:51000",
          batch_size: int = 8,
          show_progress: bool = False,
      ):
          """
          Args:
              server: clip-as-service server URI (e.g. grpc://127.0.0.1:51000 or http://127.0.0.1:51000).
              batch_size: batch size for encode requests.
              show_progress: whether to show progress bar when encoding.
          """
          _ensure_clip_client_path()

          
          from clip_client import Client

  
          self._server = server
          self._batch_size = batch_size
          self._show_progress = show_progress

          try:
              self._client = Client(server)
          except ModuleNotFoundError as e:
              if str(e) == "No module named 'pkg_resources'":
                  raise RuntimeError(
                      "clip-as-service requires pkg_resources via jina/hubble. "
                      "Install compatible setuptools (<82) in current venv."
                  ) from e
              raise

  
      def encode_image_urls(
          self,
          urls: List[str],
          batch_size: Optional[int] = None,

          normalize_embeddings: bool = True,

      ) -> List[np.ndarray]:

          """
          Encode a list of image URLs to vectors.
  
          Args:
              urls: list of image URLs (http/https or //host/path).
              batch_size: override instance batch_size for this call.
  
          Returns:

              List of vectors (float32), same length as urls.

          """
          if not urls:
              return []
  
          normalized = [_normalize_image_url(u) for u in urls]

          bs = batch_size if batch_size is not None else self._batch_size

          invalid_indices = [i for i, u in enumerate(normalized) if not u]
          if invalid_indices:
              raise ValueError(f"Invalid empty image URL at indices: {invalid_indices}")
  
          # Client.encode(iterable of str) returns np.ndarray [N, D] for string input
          arr = self._client.encode(
              normalized,
              batch_size=bs,
              show_progress=self._show_progress,
          )
          if arr is None or not hasattr(arr, "shape"):
              raise RuntimeError("clip-as-service encode returned empty result")
          if len(arr) != len(normalized):
              raise RuntimeError(
                  f"clip-as-service encode length mismatch: expected {len(normalized)}, got {len(arr)}"

              )

          out: List[np.ndarray] = []
          for row in arr:
              vec = np.asarray(row, dtype=np.float32)
              if vec.ndim != 1 or vec.size == 0 or not np.isfinite(vec).all():
                  raise RuntimeError("clip-as-service returned invalid embedding vector")

              if normalize_embeddings:
                  norm = float(np.linalg.norm(vec))
                  if not np.isfinite(norm) or norm <= 0.0:
                      raise RuntimeError("clip-as-service returned zero/invalid norm vector")
                  vec = vec / norm

              out.append(vec)

          return out
  

      def encode_image_from_url(self, url: str, normalize_embeddings: bool = True) -> Optional[np.ndarray]:

          """Encode a single image URL. Returns 1024-dim vector or None."""

          results = self.encode_image_urls([url], batch_size=1, normalize_embeddings=normalize_embeddings)

          return results[0] if results else None