"""
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.
    Vector length follows the loaded Chinese-CLIP model (e.g. 1024 for ViT-H-14, 768 for ViT-L-14);
    must match ``services.embedding.image_backends.*.model_name`` and ES ``image_embedding.vector.dims``.
    """

    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) -> np.ndarray:
        """Encode a single image URL and return one float32 vector (length = model embedding dim)."""
        results = self.encode_image_urls([url], batch_size=1, normalize_embeddings=normalize_embeddings)
        if not results:
            raise RuntimeError("clip-as-service returned empty result for single image URL")
        return results[0]

    def encode_clip_texts(
        self,
        texts: List[str],
        batch_size: Optional[int] = None,
        normalize_embeddings: bool = True,
    ) -> List[np.ndarray]:
        """
        CN-CLIP 文本塔：与 encode_image_urls 输出同一向量空间（图文检索 / image_embedding）。

        仅传入自然语言字符串；HTTP 侧见 ``POST /embed/clip_text``。
        """
        if not texts:
            return []
        bs = batch_size if batch_size is not None else self._batch_size
        arr = self._client.encode(
            texts,
            batch_size=bs,
            show_progress=self._show_progress,
        )
        if arr is None or not hasattr(arr, "shape"):
            raise RuntimeError("clip-as-service encode (text) returned empty result")
        if len(arr) != len(texts):
            raise RuntimeError(
                f"clip-as-service text encode length mismatch: expected {len(texts)}, 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 text 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