"""
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 pickle
import redis
from datetime import timedelta
from typing import List, Union, Dict, Any, Optional
import logging

logger = logging.getLogger(__name__)

# Try to import REDIS_CONFIG, but allow import to fail
try:
    from config.env_config import REDIS_CONFIG
except ImportError:
    REDIS_CONFIG = {}


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"
                
                # Initialize Redis cache
                try:
                    cls._instance.redis_client = redis.Redis(
                        host=REDIS_CONFIG.get('host', 'localhost'),
                        port=REDIS_CONFIG.get('port', 6479),
                        password=REDIS_CONFIG.get('password'),
                        decode_responses=False,  # Keep binary data as is
                        socket_timeout=REDIS_CONFIG.get('socket_timeout', 1),
                        socket_connect_timeout=REDIS_CONFIG.get('socket_connect_timeout', 1),
                        retry_on_timeout=REDIS_CONFIG.get('retry_on_timeout', False),
                        health_check_interval=10  # 避免复用坏连接
                    )
                    # Test connection
                    cls._instance.redis_client.ping()
                    cls._instance.expire_time = timedelta(days=REDIS_CONFIG.get('cache_expire_days', 180))
                    logger.info("Redis cache initialized for embeddings")
                except Exception as e:
                    logger.warning(f"Failed to initialize Redis cache for embeddings: {e}, continuing without cache")
                    cls._instance.redis_client = None
        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 with Redis caching.

        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]

        # Check cache first
        cached_embeddings = []
        uncached_indices = []
        uncached_texts = []
        
        for i, text in enumerate(sentences):
            cached = self._get_cached_embedding(text, 'en')  # Use 'en' as default language for title embedding
            if cached is not None:
                cached_embeddings.append((i, cached))
            else:
                uncached_indices.append(i)
                uncached_texts.append(text)
        
        # Prepare request data for uncached texts
        request_data = []
        for i, text in enumerate(uncached_texts):
            request_item = {
                "id": str(uncached_indices[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)

        # Process response
        embeddings = [None] * len(sentences)
        
        # Fill in cached embeddings
        for idx, cached_emb in cached_embeddings:
            embeddings[idx] = cached_emb
        
        # If there are uncached texts, call service
        if uncached_texts:
            try:
                # Call service
                response_data = self._call_service(request_data)

                # Process response
                for i, text in enumerate(uncached_texts):
                    original_idx = uncached_indices[i]
                    # Find corresponding response by ID
                    response_item = None
                    for item in response_data:
                        if str(item.get("id")) == str(original_idx):
                            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:
                            embedding_array = np.array(embedding, dtype=np.float32)
                            embeddings[original_idx] = embedding_array
                            # Cache the embedding
                            self._set_cached_embedding(text, 'en', embedding_array)
                        else:
                            logger.warning(f"No embedding found for text {original_idx}: {text[:50]}...")
                            embeddings[original_idx] = np.zeros(1024, dtype=np.float32)
                    else:
                        logger.warning(f"No response found for text {original_idx}")
                        embeddings[original_idx] = np.zeros(1024, dtype=np.float32)

            except Exception as e:
                logger.error(f"Failed to encode texts: {e}", exc_info=True)
                # Fill missing embeddings with zeros
                for idx in uncached_indices:
                    if embeddings[idx] is None:
                        embeddings[idx] = np.zeros(1024, dtype=np.float32)
        
        # Convert to numpy array
        return np.array(embeddings, 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)
    
    def _get_cache_key(self, query: str, language: str) -> str:
        """Generate a cache key for the query"""
        return f"embedding:{language}:{query}"
    
    def _get_cached_embedding(self, query: str, language: str) -> Optional[np.ndarray]:
        """Get embedding from cache if exists (with sliding expiration)"""
        if not self.redis_client:
            return None
            
        try:
            cache_key = self._get_cache_key(query, language)
            cached_data = self.redis_client.get(cache_key)
            if cached_data:
                logger.debug(f"Cache hit for embedding: {query}")
                # Update expiration time on access (sliding expiration)
                self.redis_client.expire(cache_key, self.expire_time)
                return pickle.loads(cached_data)
            return None
        except Exception as e:
            logger.error(f"Error retrieving embedding from cache: {e}")
            return None
    
    def _set_cached_embedding(self, query: str, language: str, embedding: np.ndarray) -> bool:
        """Store embedding in cache"""
        if not self.redis_client:
            return False
            
        try:
            cache_key = self._get_cache_key(query, language)
            serialized_data = pickle.dumps(embedding)
            self.redis_client.setex(
                cache_key,
                self.expire_time,
                serialized_data
            )
            logger.debug(f"Successfully cached embedding for query: {query}")
            return True
        except (redis.exceptions.BusyLoadingError, redis.exceptions.ConnectionError, 
                redis.exceptions.TimeoutError, redis.exceptions.RedisError) as e:
            logger.warning(f"Redis error storing embedding in cache: {e}")
            return False
        except Exception as e:
            logger.error(f"Error storing embedding in cache: {e}")
            return False