"""
Text embedding encoder using network service.

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

import sys
import requests
import time
import threading
import numpy as np
import logging
from typing import List, Union, Dict, Any

logger = logging.getLogger(__name__)


class BgeEncoder:
    """
    Singleton text encoder using network service.

    Thread-safe singleton pattern ensures only one instance exists.
    """
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, service_url='http://localhost:5001'):
        with cls._lock:
            if cls._instance is None:
                cls._instance = super(BgeEncoder, cls).__new__(cls)
                logger.info(f"Creating BgeEncoder instance with service URL: {service_url}")
                cls._instance.service_url = service_url
                cls._instance.endpoint = f"{service_url}/embedding/generate_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 text fields

        Returns:
            List of dictionaries with id and embedding 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"BgeEncoder service request failed: {e}", exc_info=True)
            raise

    def encode(
        self,
        sentences: Union[str, List[str]],
        normalize_embeddings: bool = True,
        device: str = 'cpu',
        batch_size: int = 32
    ) -> np.ndarray:
        """
        Encode text into embeddings via network service.

        Args:
            sentences: Single string or list of strings to encode
            normalize_embeddings: Whether to normalize embeddings (ignored for service)
            device: Device parameter ignored for service compatibility
            batch_size: Batch size for processing (used for service requests)

        Returns:
            numpy array of shape (n, 1024) containing embeddings
        """
        # Convert single string to list
        if isinstance(sentences, str):
            sentences = [sentences]

        # Prepare request data
        request_data = []
        for i, text in enumerate(sentences):
            request_item = {
                "id": str(i),
                "name_zh": text
            }

            # Add English and Russian fields as empty for now
            # Could be enhanced with language detection in the future
            request_item["name_en"] = None
            request_item["name_ru"] = None

            request_data.append(request_item)

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

            # Process response
            embeddings = []
            for i, text in enumerate(sentences):
                # Find corresponding response by ID
                response_item = None
                for item in response_data:
                    if str(item.get("id")) == str(i):
                        response_item = item
                        break

                if response_item:
                    # Try Chinese embedding first, then English, then Russian
                    embedding = None
                    for lang in ["embedding_zh", "embedding_en", "embedding_ru"]:
                        if lang in response_item and response_item[lang] is not None:
                            embedding = response_item[lang]
                            break

                    if embedding is not None:
                        embeddings.append(embedding)
                    else:
                        logger.warning(f"No embedding found for text {i}: {text[:50]}...")
                        embeddings.append([0.0] * 1024)
                else:
                    logger.warning(f"No response found for text {i}")
                    embeddings.append([0.0] * 1024)

            return np.array(embeddings, dtype=np.float32)

        except Exception as e:
            logger.error(f"Failed to encode texts: {e}", exc_info=True)
            # Return zero embeddings as fallback
            return np.zeros((len(sentences), 1024), dtype=np.float32)

    def encode_batch(
        self,
        texts: List[str],
        batch_size: int = 32,
        device: str = 'cpu'
    ) -> np.ndarray:
        """
        Encode a batch of texts efficiently via network service.

        Args:
            texts: List of texts to encode
            batch_size: Batch size for processing
            device: Device parameter ignored for service compatibility

        Returns:
            numpy array of embeddings
        """
        return self.encode(texts, batch_size=batch_size, device=device)