"""
Translation Module
Author: RSK World (https://rskworld.in)
Founder: Molla Samser
Designer & Tester: Rima Khatun
Contact: help@rskworld.in, +91 93305 39277
Year: 2026
Description: Multi-language translation with fallback support
"""

import googletrans
from googletrans import Translator as GoogleTranslator
import openai
import logging
import time
import os
from typing import Optional, Dict, List

logger = logging.getLogger(__name__)

class Translator:
    def __init__(self):
        self.google_translator = GoogleTranslator()
        self.openai_api_key = os.getenv('OPENAI_API_KEY')
        self.translation_cache = {}
        self.max_retries = 3
        self.retry_delay = 1
        
        # Language code mappings for different services
        self.google_lang_codes = {
            'en': 'en',
            'hi': 'hi',
            'bn': 'bn',
            'es': 'es',
            'fr': 'fr',
            'de': 'de',
            'zh': 'zh',
            'ja': 'ja',
            'ar': 'ar',
            'pt': 'pt',
            'ru': 'ru',
            'it': 'it'
        }
        
        self.openai_lang_names = {
            'en': 'English',
            'hi': 'Hindi',
            'bn': 'Bengali',
            'es': 'Spanish',
            'fr': 'French',
            'de': 'German',
            'zh': 'Chinese',
            'ja': 'Japanese',
            'ar': 'Arabic',
            'pt': 'Portuguese',
            'ru': 'Russian',
            'it': 'Italian'
        }
    
    def translate(self, text: str, target_language: str, source_language: str = 'auto') -> str:
        """
        Translate text from source language to target language
        Uses Google Translate as primary, OpenAI as fallback
        """
        if not text or not text.strip():
            return text
        
        # Create cache key
        cache_key = f"{text}_{source_language}_{target_language}"
        
        # Check cache first
        if cache_key in self.translation_cache:
            return self.translation_cache[cache_key]
        
        # Try Google Translate first
        result = self._translate_with_google(text, target_language, source_language)
        
        # If Google fails, try OpenAI
        if not result and self.openai_api_key:
            result = self._translate_with_openai(text, target_language, source_language)
        
        # Cache the result
        if result:
            self.translation_cache[cache_key] = result
        
        return result or text  # Return original text if translation fails
    
    def _translate_with_google(self, text: str, target_language: str, source_language: str) -> Optional[str]:
        """Translate using Google Translate"""
        try:
            # Convert language codes
            google_target = self.google_lang_codes.get(target_language, target_language)
            google_source = 'auto' if source_language == 'auto' else self.google_lang_codes.get(source_language, source_language)
            
            # Perform translation with retries
            for attempt in range(self.max_retries):
                try:
                    result = self.google_translator.translate(
                        text,
                        dest=google_target,
                        src=google_source
                    )
                    return result.text
                    
                except Exception as e:
                    if attempt < self.max_retries - 1:
                        time.sleep(self.retry_delay * (attempt + 1))
                        continue
                    else:
                        logger.error(f"Google Translate failed after {self.max_retries} attempts: {str(e)}")
                        return None
                        
        except Exception as e:
            logger.error(f"Google Translate error: {str(e)}")
            return None
    
    def _translate_with_openai(self, text: str, target_language: str, source_language: str) -> Optional[str]:
        """Translate using OpenAI GPT"""
        try:
            if not self.openai_api_key:
                return None
            
            # Get language names
            target_name = self.openai_lang_names.get(target_language, target_language)
            source_name = self.openai_lang_names.get(source_language, source_language) if source_language != 'auto' else "automatically detected language"
            
            prompt = f"Translate the following text from {source_name} to {target_name}. Only return the translated text, no explanations:\n\n{text}"
            
            for attempt in range(self.max_retries):
                try:
                    response = openai.ChatCompletion.create(
                        model="gpt-3.5-turbo",
                        messages=[
                            {"role": "system", "content": "You are a professional translator. Translate accurately while preserving meaning and tone."},
                            {"role": "user", "content": prompt}
                        ],
                        max_tokens=1000,
                        temperature=0.3
                    )
                    
                    translated_text = response.choices[0].message.content.strip()
                    return translated_text
                    
                except Exception as e:
                    if attempt < self.max_retries - 1:
                        time.sleep(self.retry_delay * (attempt + 1))
                        continue
                    else:
                        logger.error(f"OpenAI translation failed after {self.max_retries} attempts: {str(e)}")
                        return None
                        
        except Exception as e:
            logger.error(f"OpenAI translation error: {str(e)}")
            return None
    
    def translate_batch(self, texts: List[str], target_language: str, source_language: str = 'auto') -> List[str]:
        """Translate multiple texts"""
        results = []
        for text in texts:
            result = self.translate(text, target_language, source_language)
            results.append(result)
        return results
    
    def detect_language(self, text: str) -> str:
        """Detect language of text using Google Translate"""
        try:
            detection = self.google_translator.detect(text)
            return detection.lang
        except Exception as e:
            logger.error(f"Language detection error: {str(e)}")
            return 'en'
    
    def get_supported_languages(self) -> Dict[str, str]:
        """Get supported languages"""
        return {
            'en': 'English',
            'hi': 'हिन्दी (Hindi)',
            'bn': 'বাংলা (Bengali)',
            'es': 'Español (Spanish)',
            'fr': 'Français (French)',
            'de': 'Deutsch (German)',
            'zh': '中文 (Chinese)',
            'ja': '日本語 (Japanese)',
            'ar': 'العربية (Arabic)',
            'pt': 'Português (Portuguese)',
            'ru': 'Русский (Russian)',
            'it': 'Italiano (Italian)'
        }
    
    def is_language_supported(self, language_code: str) -> bool:
        """Check if language is supported"""
        return language_code in self.google_lang_codes
    
    def clear_cache(self):
        """Clear translation cache"""
        self.translation_cache.clear()
    
    def get_cache_size(self) -> int:
        """Get current cache size"""
        return len(self.translation_cache)