"""

  Image embedding encoder using network service.

  Generates embeddings via HTTP API service running on localhost:5001.

  """
  
  import sys
  import os

  import requests

  import numpy as np
  from PIL import Image
  import logging
  import threading

  from typing import List, Optional, Union, Dict, Any

  logger = logging.getLogger(__name__)

  
  
  class CLIPImageEncoder:
      """

      Image Encoder for generating image embeddings using network service.

  
      Thread-safe singleton pattern.
      """
  
      _instance = None
      _lock = threading.Lock()
  

      def __new__(cls, service_url='http://localhost:5001'):

          with cls._lock:
              if cls._instance is None:
                  cls._instance = super(CLIPImageEncoder, cls).__new__(cls)

                  logger.info(f"Creating CLIPImageEncoder instance with service URL: {service_url}")
                  cls._instance.service_url = service_url
                  cls._instance.endpoint = f"{service_url}/embedding/generate_image_embeddings"

          return cls._instance
  

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

          Args:
              request_data: List of dictionaries with id and pic_url fields

          Returns:
              List of dictionaries with id, pic_url, embedding and error fields
          """

          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:
              # Prepare request data
              request_data = [{
                  "id": "image_0",
                  "pic_url": url
              }]
  
              # Call service
              response_data = self._call_service(request_data)
  
              # Process response
              if response_data and len(response_data) > 0:
                  response_item = response_data[0]
                  if response_item.get("embedding"):
                      return np.array(response_item["embedding"], dtype=np.float32)
                  else:
                      logger.warning(f"No embedding for URL {url}, error: {response_item.get('error', 'Unknown error')}")
                      return None
              else:
                  logger.warning(f"No response 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]
  
              # Prepare request data
              request_data = []
              for j, url in enumerate(batch_urls):
                  request_data.append({
                      "id": f"image_{j}",
                      "pic_url": url
                  })
  
              try:
                  # Call service
                  response_data = self._call_service(request_data)
  
                  # Process response
                  batch_results = []
                  for j, url in enumerate(batch_urls):
                      response_item = None
                      for item in response_data:
                          if str(item.get("id")) == f"image_{j}":
                              response_item = item
                              break
  
                      if response_item and response_item.get("embedding"):
                          batch_results.append(np.array(response_item["embedding"], dtype=np.float32))
                      else:
                          error_msg = response_item.get("error", "Unknown error") if response_item else "No response"
                          logger.warning(f"Failed to encode URL {url}: {error_msg}")
                          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