"""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]) -> 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,
                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) -> Optional[np.ndarray]:
        """
        Encode image to embedding vector using network service.

        Note: This method is kept for compatibility but the service only works with URLs.
        """
        logger.warning("encode_image with PIL Image not supported by service, returning None")
        return None

    def encode_image_from_url(self, url: str) -> Optional[np.ndarray]:
        """
        Generate image embedding via network service using URL.

        Args:
            url: Image URL to process

        Returns:
            Embedding vector or None if failed
        """
        try:
            response_data = self._call_service([url])
            if response_data and len(response_data) > 0 and response_data[0] is not None:
                return np.array(response_data[0], dtype=np.float32)
            logger.warning(f"No embedding for URL {url}")
            return None

        except Exception as e:
            logger.error(f"Failed to process image from URL {url}: {str(e)}", exc_info=True)
            return None

    def encode_batch(
        self,
        images: List[Union[str, Image.Image]],
        batch_size: int = 8
    ) -> List[Optional[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 (or None for failed images)
        """
        # Initialize results with None for all images
        results = [None] * len(images)

        # Filter out PIL Images since service only supports URLs
        url_images = []
        url_indices = []

        for i, img in enumerate(images):
            if isinstance(img, str):
                url_images.append(img)
                url_indices.append(i)
            elif isinstance(img, Image.Image):
                logger.warning(f"PIL Image at index {i} not supported by service, returning None")
                # results[i] is already None

        # Process URLs in batches
        for i in range(0, len(url_images), batch_size):
            batch_urls = url_images[i:i + batch_size]
            batch_indices = url_indices[i:i + batch_size]

            try:
                # Call service
                response_data = self._call_service(batch_urls)

                # Process response (aligned list)
                batch_results = []
                for j, url in enumerate(batch_urls):
                    if response_data and j < len(response_data) and response_data[j] is not None:
                        batch_results.append(np.array(response_data[j], dtype=np.float32))
                    else:
                        logger.warning(f"Failed to encode URL {url}: no embedding")
                        batch_results.append(None)

                # Insert results at the correct positions
                for j, result in enumerate(batch_results):
                    results[batch_indices[j]] = result

            except Exception as e:
                logger.error(f"Batch processing failed: {e}", exc_info=True)
                # Fill with None for this batch
                for j in range(len(batch_urls)):
                    results[batch_indices[j]] = None

        return results

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

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

        Returns:
            与 urls 等长的向量列表，失败为 None
        """
        return self.encode_batch(urls, batch_size=batch_size or 8)