"""Image embedding client for the local embedding HTTP service."""

import os
import logging
from typing import Any, List, Optional, Union

import numpy as np
import requests
from PIL import Image

logger = logging.getLogger(__name__)

from config.services_config import get_embedding_base_url


class CLIPImageEncoder:
    """
    Image Encoder for generating image embeddings using network service.

    This client is stateless and safe to instantiate per caller.
    """

    def __init__(self, service_url: Optional[str] = None):
        resolved_url = service_url or os.getenv("EMBEDDING_SERVICE_URL") or get_embedding_base_url()
        self.service_url = str(resolved_url).rstrip("/")
        self.endpoint = f"{self.service_url}/embed/image"
        logger.info("Creating CLIPImageEncoder instance with service URL: %s", self.service_url)

    def _call_service(self, request_data: List[str], normalize_embeddings: bool = True) -> List[Any]:
        """
        Call the embedding service API.

        Args:
            request_data: List of image URLs / local file paths

        Returns:
            List of embeddings (list[float]) or nulls (None), aligned to input order
        """
        try:
            response = requests.post(
                self.endpoint,
                params={"normalize": "true" if normalize_embeddings else "false"},
                json=request_data,
                timeout=60
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            logger.error(f"CLIPImageEncoder service request failed: {e}", exc_info=True)
            raise

    def encode_image(self, image: Image.Image) -> np.ndarray:
        """
        Encode image to embedding vector using network service.

        Note: This method is kept for compatibility but the service only works with URLs.
        """
        raise NotImplementedError("encode_image with PIL Image is not supported by embedding service")

    def encode_image_from_url(self, url: str, normalize_embeddings: bool = True) -> np.ndarray:
        """
        Generate image embedding via network service using URL.

        Args:
            url: Image URL to process

        Returns:
            Embedding vector
        """
        response_data = self._call_service([url], normalize_embeddings=normalize_embeddings)
        if not response_data or len(response_data) != 1 or response_data[0] is None:
            raise RuntimeError(f"No image embedding returned for URL: {url}")
        vec = np.array(response_data[0], dtype=np.float32)
        if vec.ndim != 1 or vec.size == 0 or not np.isfinite(vec).all():
            raise RuntimeError(f"Invalid image embedding returned for URL: {url}")
        return vec

    def encode_batch(
        self,
        images: List[Union[str, Image.Image]],
        batch_size: int = 8,
        normalize_embeddings: bool = True,
    ) -> List[np.ndarray]:
        """
        Encode a batch of images efficiently via network service.

        Args:
            images: List of image URLs or PIL Images
            batch_size: Batch size for processing (used for service requests)

        Returns:
            List of embeddings
        """
        for i, img in enumerate(images):
            if isinstance(img, Image.Image):
                raise NotImplementedError(f"PIL Image at index {i} is not supported by service")
            if not isinstance(img, str) or not img.strip():
                raise ValueError(f"Invalid image URL/path at index {i}: {img!r}")

        results: List[np.ndarray] = []
        for i in range(0, len(images), batch_size):
            batch_urls = [str(u).strip() for u in images[i:i + batch_size]]
            response_data = self._call_service(batch_urls, normalize_embeddings=normalize_embeddings)
            if not response_data or len(response_data) != len(batch_urls):
                raise RuntimeError(
                    f"Image embedding response length mismatch: expected {len(batch_urls)}, "
                    f"got {0 if response_data is None else len(response_data)}"
                )
            for j, url in enumerate(batch_urls):
                embedding = response_data[j]
                if embedding is None:
                    raise RuntimeError(f"No image embedding returned for URL: {url}")
                vec = np.array(embedding, dtype=np.float32)
                if vec.ndim != 1 or vec.size == 0 or not np.isfinite(vec).all():
                    raise RuntimeError(f"Invalid image embedding returned for URL: {url}")
                results.append(vec)

        return results

    def encode_image_urls(
        self,
        urls: List[str],
        batch_size: Optional[int] = None,
        normalize_embeddings: bool = True,
    ) -> List[np.ndarray]:
        """
        与 ClipImageModel / ClipAsServiceImageEncoder 一致的接口，供索引器 document_transformer 调用。

        Args:
            urls: 图片 URL 列表
            batch_size: 批大小（默认 8）

        Returns:
            与 urls 等长的向量列表
        """
        return self.encode_batch(
            urls,
            batch_size=batch_size or 8,
            normalize_embeddings=normalize_embeddings,
        )