"""
Image embedding encoder using network service.

Generates embeddings via HTTP API service (default localhost:6005).
"""

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__)

from config.services_config import get_embedding_base_url


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: Optional[str] = None):
        with cls._lock:
            if cls._instance is None:
                cls._instance = super(CLIPImageEncoder, cls).__new__(cls)
                resolved_url = service_url or os.getenv("EMBEDDING_SERVICE_URL") or get_embedding_base_url()
                logger.info(f"Creating CLIPImageEncoder instance with service URL: {resolved_url}")
                cls._instance.service_url = resolved_url
                cls._instance.endpoint = f"{resolved_url}/embed/image"
        return cls._instance

    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