"""
Multi-language Support Module for Weather Chatbot
===============================================

This module provides comprehensive multi-language support for the Weather Chatbot,
including translation management, language detection, and localized responses.

Features:
- Support for multiple languages
- Automatic language detection
- Translation management
- Localized weather descriptions
- Language-specific response formatting

Author: RSK World
Website: https://rskworld.in
Email: hello@rskworld.in
Phone: +91 93305 39277
Location: Nutanhat, Mongolkote, Purba Burdwan, West Bengal, India, 713147
Year: 2026
"""

import json
import os
from typing import Dict, Optional, List, Any
from datetime import datetime
import logging

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MultiLanguageManager:
    """
    Manages multi-language support for the Weather Chatbot.
    Handles translations, language detection, and localized responses.
    """
    
    def __init__(self, translations_dir: str = "translations"):
        """
        Initialize the MultiLanguageManager.
        
        Args:
            translations_dir (str): Directory containing translation files
        """
        self.translations_dir = translations_dir
        self.translations = {}
        self.supported_languages = {
            'en': 'English',
            'es': 'Español',
            'fr': 'Français',
            'de': 'Deutsch',
            'it': 'Italiano',
            'pt': 'Português',
            'ru': 'Русский',
            'zh': '中文',
            'ja': '日本語',
            'ar': 'العربية',
            'hi': 'हिन्दी',
            'bn': 'বাংলা'
        }
        self.default_language = 'en'
        self.current_language = 'en'
        
        # Load translations
        self._load_translations()
    
    def _load_translations(self) -> None:
        """Load all translation files from the translations directory."""
        try:
            # Create translations directory if it doesn't exist
            if not os.path.exists(self.translations_dir):
                os.makedirs(self.translations_dir)
                self._create_default_translations()
            
            # Load translation files
            for lang_code in self.supported_languages.keys():
                translation_file = os.path.join(self.translations_dir, f"{lang_code}.json")
                if os.path.exists(translation_file):
                    with open(translation_file, 'r', encoding='utf-8') as f:
                        self.translations[lang_code] = json.load(f)
                else:
                    # Create default translation file
                    self.translations[lang_code] = self._get_default_translations()
                    self._save_translation(lang_code, self.translations[lang_code])
            
            logger.info(f"Loaded translations for {len(self.translations)} languages")
            
        except Exception as e:
            logger.error(f"Error loading translations: {str(e)}")
            self.translations = {'en': self._get_default_translations()}
    
    def _create_default_translations(self) -> None:
        """Create default translation files for all supported languages."""
        default_translations = self._get_default_translations()
        
        for lang_code in self.supported_languages.keys():
            translation_file = os.path.join(self.translations_dir, f"{lang_code}.json")
            if not os.path.exists(translation_file):
                with open(translation_file, 'w', encoding='utf-8') as f:
                    json.dump(default_translations, f, indent=2, ensure_ascii=False)
    
    def _get_default_translations(self) -> Dict[str, str]:
        """Get default translations (English)."""
        return {
            # Common phrases
            "welcome": "Welcome to Weather Chatbot!",
            "goodbye": "Goodbye! Have a great day!",
            "thank_you": "Thank you for using Weather Chatbot!",
            "error": "An error occurred. Please try again.",
            "loading": "Loading weather data...",
            "no_data": "No weather data available.",
            
            # Weather descriptions
            "sunny": "Sunny",
            "cloudy": "Cloudy",
            "rainy": "Rainy",
            "snowy": "Snowy",
            "stormy": "Stormy",
            "foggy": "Foggy",
            "windy": "Windy",
            "partly_cloudy": "Partly Cloudy",
            "mostly_cloudy": "Mostly Cloudy",
            "clear": "Clear",
            
            # Temperature
            "temperature": "Temperature",
            "feels_like": "Feels like",
            "min_temp": "Minimum Temperature",
            "max_temp": "Maximum Temperature",
            "humidity": "Humidity",
            "pressure": "Pressure",
            "visibility": "Visibility",
            "uv_index": "UV Index",
            
            # Wind
            "wind_speed": "Wind Speed",
            "wind_direction": "Wind Direction",
            "wind_gust": "Wind Gust",
            
            # Weather conditions
            "conditions": "Conditions",
            "description": "Description",
            "precipitation": "Precipitation",
            "chance_of_rain": "Chance of Rain",
            "chance_of_snow": "Chance of Snow",
            
            # Time
            "today": "Today",
            "tomorrow": "Tomorrow",
            "yesterday": "Yesterday",
            "morning": "Morning",
            "afternoon": "Afternoon",
            "evening": "Evening",
            "night": "Night",
            "now": "Now",
            
            # Location
            "location": "Location",
            "city": "City",
            "country": "Country",
            "coordinates": "Coordinates",
            "timezone": "Timezone",
            
            # Messages
            "weather_in": "Weather in {city}",
            "current_weather": "Current Weather",
            "forecast": "Forecast",
            "hourly_forecast": "Hourly Forecast",
            "daily_forecast": "Daily Forecast",
            "weekly_forecast": "Weekly Forecast",
            
            # Questions
            "how_is_weather": "How is the weather in {city}?",
            "what_is_temperature": "What is the temperature in {city}?",
            "will_it_rain": "Will it rain in {city}?",
            "weather_forecast": "Weather forecast for {city}",
            
            # Responses
            "temp_is": "The temperature in {city} is {temp}°{unit}",
            "weather_is": "The weather in {city} is {condition}",
            "rain_expected": "Rain is expected in {city}",
            "no_rain_expected": "No rain expected in {city}",
            
            # Error messages
            "city_not_found": "City not found. Please check the spelling.",
            "api_error": "Weather API error. Please try again later.",
            "network_error": "Network error. Please check your connection.",
            "invalid_location": "Invalid location provided.",
            
            # UI elements
            "search": "Search",
            "search_city": "Search for a city...",
            "get_weather": "Get Weather",
            "refresh": "Refresh",
            "settings": "Settings",
            "language": "Language",
            "units": "Units",
            "celsius": "Celsius",
            "fahrenheit": "Fahrenheit",
            "kelvin": "Kelvin",
            
            # Notifications
            "weather_alert": "Weather Alert",
            "severe_weather": "Severe Weather Warning",
            "temperature_alert": "Temperature Alert",
            "precipitation_alert": "Precipitation Alert",
            
            # Analytics
            "weather_trends": "Weather Trends",
            "temperature_trend": "Temperature Trend",
            "precipitation_trend": "Precipitation Trend",
            "weather_comparison": "Weather Comparison",
            "city_comparison": "City Comparison",
            
            # Authentication
            "login": "Login",
            "logout": "Logout",
            "register": "Register",
            "username": "Username",
            "password": "Password",
            "email": "Email",
            "profile": "Profile",
            
            # General
            "ok": "OK",
            "cancel": "Cancel",
            "yes": "Yes",
            "no": "No",
            "save": "Save",
            "delete": "Delete",
            "edit": "Edit",
            "close": "Close",
            "back": "Back",
            "next": "Next",
            "previous": "Previous",
            "home": "Home",
            "about": "About",
            "help": "Help",
            "contact": "Contact"
        }
    
    def _save_translation(self, lang_code: str, translations: Dict[str, str]) -> None:
        """
        Save translations to file.
        
        Args:
            lang_code (str): Language code
            translations (Dict[str, str]): Translation dictionary
        """
        try:
            translation_file = os.path.join(self.translations_dir, f"{lang_code}.json")
            with open(translation_file, 'w', encoding='utf-8') as f:
                json.dump(translations, f, indent=2, ensure_ascii=False)
        except Exception as e:
            logger.error(f"Error saving translation for {lang_code}: {str(e)}")
    
    def set_language(self, lang_code: str) -> bool:
        """
        Set the current language.
        
        Args:
            lang_code (str): Language code
            
        Returns:
            bool: True if language was set successfully
        """
        if lang_code in self.supported_languages:
            self.current_language = lang_code
            logger.info(f"Language set to: {self.supported_languages[lang_code]}")
            return True
        return False
    
    def get_language(self) -> str:
        """
        Get the current language code.
        
        Returns:
            str: Current language code
        """
        return self.current_language
    
    def get_supported_languages(self) -> Dict[str, str]:
        """
        Get supported languages.
        
        Returns:
            Dict[str, str]: Dictionary of language codes and names
        """
        return self.supported_languages.copy()
    
    def translate(self, key: str, lang_code: Optional[str] = None, **kwargs) -> str:
        """
        Translate a key to the specified language.
        
        Args:
            key (str): Translation key
            lang_code (Optional[str]): Language code (uses current if None)
            **kwargs: Variables for string formatting
            
        Returns:
            str: Translated text
        """
        if lang_code is None:
            lang_code = self.current_language
        
        # Fallback to default language if translation not found
        if lang_code not in self.translations:
            lang_code = self.default_language
        
        # Get translation
        translation = self.translations.get(lang_code, {}).get(key, key)
        
        # Format with variables if provided
        try:
            if kwargs:
                translation = translation.format(**kwargs)
        except (KeyError, ValueError) as e:
            logger.warning(f"Error formatting translation '{key}': {str(e)}")
        
        return translation
    
    def detect_language(self, text: str) -> str:
        """
        Detect the language of the given text.
        
        Args:
            text (str): Text to analyze
            
        Returns:
            str: Detected language code
        """
        # Simple language detection based on common words/phrases
        # In a real implementation, you might use a library like langdetect
        
        text_lower = text.lower()
        
        # Language indicators
        language_indicators = {
            'es': ['hola', 'buenos', 'días', 'gracias', 'por favor', 'clima', 'tiempo'],
            'fr': ['bonjour', 'merci', 's\'il', 'vous', 'plaît', 'météo', 'temps'],
            'de': ['hallo', 'danke', 'bitte', 'wetter', 'klima'],
            'it': ['ciao', 'grazie', 'per', 'favore', 'tempo', 'meteo'],
            'pt': ['olá', 'obrigado', 'por', 'favor', 'tempo', 'clima'],
            'ru': ['привет', 'спасибо', 'пожалуйста', 'погода'],
            'zh': ['你好', '谢谢', '天气', '气候'],
            'ja': ['こんにちは', 'ありがとう', '天気', '気候'],
            'ar': ['مرحبا', 'شكرا', 'الطقس', 'المناخ'],
            'hi': ['नमस्ते', 'धन्यवाद', 'मौसम', 'जलवायु'],
            'bn': ['হ্যালো', 'ধন্যবাদ', 'আবহাওয়া', 'জলবায়ু']
        }
        
        # Check for language indicators
        for lang_code, indicators in language_indicators.items():
            for indicator in indicators:
                if indicator in text_lower:
                    return lang_code
        
        # Default to English if no indicators found
        return 'en'
    
    def get_localized_weather_description(self, weather_code: str, lang_code: Optional[str] = None) -> str:
        """
        Get localized weather description based on weather code.
        
        Args:
            weather_code (str): Weather condition code
            lang_code (Optional[str]): Language code
            
        Returns:
            str: Localized weather description
        """
        if lang_code is None:
            lang_code = self.current_language
        
        # Weather code to description mapping
        weather_descriptions = {
            '01d': 'clear',
            '01n': 'clear',
            '02d': 'partly_cloudy',
            '02n': 'partly_cloudy',
            '03d': 'cloudy',
            '03n': 'cloudy',
            '04d': 'mostly_cloudy',
            '04n': 'mostly_cloudy',
            '09d': 'rainy',
            '09n': 'rainy',
            '10d': 'rainy',
            '10n': 'rainy',
            '11d': 'stormy',
            '11n': 'stormy',
            '13d': 'snowy',
            '13n': 'snowy',
            '50d': 'foggy',
            '50n': 'foggy'
        }
        
        description_key = weather_descriptions.get(weather_code, 'clear')
        return self.translate(description_key, lang_code)
    
    def format_temperature(self, temp: float, unit: str = 'C', lang_code: Optional[str] = None) -> str:
        """
        Format temperature according to language conventions.
        
        Args:
            temp (float): Temperature value
            unit (str): Temperature unit (C, F, K)
            lang_code (Optional[str]): Language code
            
        Returns:
            str: Formatted temperature string
        """
        if lang_code is None:
            lang_code = self.current_language
        
        # Different languages have different formatting conventions
        if lang_code in ['de', 'fr', 'es', 'it', 'pt']:
            # Use comma as decimal separator
            temp_str = f"{temp:.1f}".replace('.', ',')
        else:
            # Use dot as decimal separator
            temp_str = f"{temp:.1f}"
        
        return f"{temp_str}°{unit}"
    
    def format_datetime(self, dt: datetime, lang_code: Optional[str] = None) -> str:
        """
        Format datetime according to language conventions.
        
        Args:
            dt (datetime): Datetime object
            lang_code (Optional[str]): Language code
            
        Returns:
            str: Formatted datetime string
        """
        if lang_code is None:
            lang_code = self.current_language
        
        # Different date formats for different languages
        formats = {
            'en': '%Y-%m-%d %H:%M',
            'es': '%d/%m/%Y %H:%M',
            'fr': '%d/%m/%Y %H:%M',
            'de': '%d.%m.%Y %H:%M',
            'it': '%d/%m/%Y %H:%M',
            'pt': '%d/%m/%Y %H:%M',
            'ru': '%d.%m.%Y %H:%M',
            'zh': '%Y年%m月%d日 %H:%M',
            'ja': '%Y年%m月%d日 %H:%M',
            'ar': '%d/%m/%Y %H:%M',
            'hi': '%d/%m/%Y %H:%M',
            'bn': '%d/%m/%Y %H:%M'
        }
        
        date_format = formats.get(lang_code, formats['en'])
        return dt.strftime(date_format)
    
    def add_translation(self, lang_code: str, key: str, value: str) -> bool:
        """
        Add or update a translation.
        
        Args:
            lang_code (str): Language code
            key (str): Translation key
            value (str): Translation value
            
        Returns:
            bool: True if translation was added successfully
        """
        try:
            if lang_code not in self.translations:
                self.translations[lang_code] = {}
            
            self.translations[lang_code][key] = value
            self._save_translation(lang_code, self.translations[lang_code])
            logger.info(f"Added translation for {lang_code}: {key} = {value}")
            return True
        except Exception as e:
            logger.error(f"Error adding translation: {str(e)}")
            return False
    
    def remove_translation(self, lang_code: str, key: str) -> bool:
        """
        Remove a translation.
        
        Args:
            lang_code (str): Language code
            key (str): Translation key
            
        Returns:
            bool: True if translation was removed successfully
        """
        try:
            if lang_code in self.translations and key in self.translations[lang_code]:
                del self.translations[lang_code][key]
                self._save_translation(lang_code, self.translations[lang_code])
                logger.info(f"Removed translation for {lang_code}: {key}")
                return True
            return False
        except Exception as e:
            logger.error(f"Error removing translation: {str(e)}")
            return False
    
    def get_translation_stats(self) -> Dict[str, Any]:
        """
        Get statistics about translations.
        
        Returns:
            Dict[str, Any]: Translation statistics
        """
        stats = {
            'total_languages': len(self.translations),
            'supported_languages': len(self.supported_languages),
            'current_language': self.current_language,
            'default_language': self.default_language,
            'translations_per_language': {}
        }
        
        for lang_code, translations in self.translations.items():
            stats['translations_per_language'][lang_code] = len(translations)
        
        return stats
    
    def export_translations(self, lang_code: str, file_path: str) -> bool:
        """
        Export translations to a file.
        
        Args:
            lang_code (str): Language code
            file_path (str): Output file path
            
        Returns:
            bool: True if export was successful
        """
        try:
            if lang_code in self.translations:
                with open(file_path, 'w', encoding='utf-8') as f:
                    json.dump(self.translations[lang_code], f, indent=2, ensure_ascii=False)
                logger.info(f"Exported translations for {lang_code} to {file_path}")
                return True
            return False
        except Exception as e:
            logger.error(f"Error exporting translations: {str(e)}")
            return False
    
    def import_translations(self, lang_code: str, file_path: str) -> bool:
        """
        Import translations from a file.
        
        Args:
            lang_code (str): Language code
            file_path (str): Input file path
            
        Returns:
            bool: True if import was successful
        """
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                translations = json.load(f)
            
            self.translations[lang_code] = translations
            self._save_translation(lang_code, translations)
            logger.info(f"Imported translations for {lang_code} from {file_path}")
            return True
        except Exception as e:
            logger.error(f"Error importing translations: {str(e)}")
            return False


# Global instance for easy access
multilang_manager = MultiLanguageManager()

# Convenience functions
def translate(key: str, lang_code: Optional[str] = None, **kwargs) -> str:
    """Convenience function for translation."""
    return multilang_manager.translate(key, lang_code, **kwargs)

def set_language(lang_code: str) -> bool:
    """Convenience function for setting language."""
    return multilang_manager.set_language(lang_code)

def get_language() -> str:
    """Convenience function for getting current language."""
    return multilang_manager.get_language()

def detect_language(text: str) -> str:
    """Convenience function for language detection."""
    return multilang_manager.detect_language(text)

def get_localized_weather_description(weather_code: str, lang_code: Optional[str] = None) -> str:
    """Convenience function for localized weather descriptions."""
    return multilang_manager.get_localized_weather_description(weather_code, lang_code)

def format_temperature(temp: float, unit: str = 'C', lang_code: Optional[str] = None) -> str:
    """Convenience function for temperature formatting."""
    return multilang_manager.format_temperature(temp, unit, lang_code)

def format_datetime(dt: datetime, lang_code: Optional[str] = None) -> str:
    """Convenience function for datetime formatting."""
    return multilang_manager.format_datetime(dt, lang_code)