import json
from typing import Dict, Any, Optional

from flask import session

from common.extensions import cache_manager
from common.utils.business_event import BusinessEvent
from common.utils.business_event_context import current_event

class TranslationServices:

    @staticmethod
    def translate_config(tenant_id: int, config_data: Dict[str, Any], field_config: str, target_language: str,
                         source_language: Optional[str] = None, context: Optional[str] = None) -> Dict[str, Any]:
        """
        Vertaalt een configuratie op basis van een veld-configuratie.

        Args:
            tenant_id: Identificatie van de tenant waarvoor we de vertaling doen.
            config_data: Een dictionary of JSON (die dan wordt geconverteerd naar een dictionary) met configuratiegegevens
            field_config: De naam van een veld-configuratie (bijv. 'fields')
            target_language: De taal waarnaar vertaald moet worden
            source_language: Optioneel, de brontaal van de configuratie
            context: Optioneel, een specifieke context voor de vertaling

        Returns:
            Een dictionary met de vertaalde configuratie
        """
        config_type = config_data.get('type', 'Unknown')
        config_version = config_data.get('version', 'Unknown')
        span_name = f"{config_type}-{config_version}-{field_config}"

        if current_event:
            with current_event.create_span(span_name):
                translated_config = TranslationServices._translate_config(tenant_id, config_data, field_config,
                                                                          target_language, source_language, context)
                return translated_config
        else:
            with BusinessEvent('Config Translation Service', tenant_id):
                with current_event.create_span(span_name):
                    translated_config = TranslationServices._translate_config(tenant_id, config_data, field_config,
                                                                              target_language, source_language, context)
                    return translated_config

    @staticmethod
    def _translate_config(tenant_id: int, config_data: Dict[str, Any], field_config: str, target_language: str,
                          source_language: Optional[str] = None, context: Optional[str] = None) -> Dict[str, Any]:

        # Zorg ervoor dat we een dictionary hebben
        if isinstance(config_data, str):
            config_data = json.loads(config_data)

        # Maak een kopie van de originele data om te wijzigen
        translated_config = config_data.copy()

        # Haal type en versie op voor de Business Event span
        config_type = config_data.get('type', 'Unknown')
        config_version = config_data.get('version', 'Unknown')

        if field_config in config_data:
            fields = config_data[field_config]

            # Haal description uit metadata voor context als geen context is opgegeven
            description_context = ""
            if not context and 'metadata' in config_data and 'description' in config_data['metadata']:
                description_context = config_data['metadata']['description']

            # Loop door elk veld in de configuratie
            for field_name, field_data in fields.items():
                # Vertaal name als het bestaat en niet leeg is
                if 'name' in field_data and field_data['name']:
                    # Gebruik context indien opgegeven, anders description_context
                    field_context = context if context else description_context
                    translated_name = cache_manager.translation_cache.get_translation(
                        text=field_data['name'],
                        target_lang=target_language,
                        source_lang=source_language,
                        context=field_context
                    )
                    if translated_name:
                        translated_config[field_config][field_name]['name'] = translated_name.translated_text

                if 'title' in field_data and field_data['title']:
                    # Gebruik context indien opgegeven, anders description_context
                    field_context = context if context else description_context
                    translated_title = cache_manager.translation_cache.get_translation(
                        text=field_data['title'],
                        target_lang=target_language,
                        source_lang=source_language,
                        context=field_context
                    )
                    if translated_title:
                        translated_config[field_config][field_name]['title'] = translated_title.translated_text

                # Vertaal description als het bestaat en niet leeg is
                if 'description' in field_data and field_data['description']:
                    # Gebruik context indien opgegeven, anders description_context
                    field_context = context if context else description_context
                    translated_desc = cache_manager.translation_cache.get_translation(
                        text=field_data['description'],
                        target_lang=target_language,
                        source_lang=source_language,
                        context=field_context
                    )
                    if translated_desc:
                        translated_config[field_config][field_name]['description'] = translated_desc.translated_text

                # Vertaal context als het bestaat en niet leeg is
                if 'context' in field_data and field_data['context']:
                    translated_ctx = cache_manager.translation_cache.get_translation(
                        text=field_data['context'],
                        target_lang=target_language,
                        source_lang=source_language,
                        context=context
                    )
                    if translated_ctx:
                        translated_config[field_config][field_name]['context'] = translated_ctx.translated_text

                # vertaal allowed values als het veld bestaat en de waarden niet leeg zijn.
                if 'allowed_values' in field_data and field_data['allowed_values']:
                    translated_allowed_values = []
                    for allowed_value in field_data['allowed_values']:
                        translated_allowed_value = cache_manager.translation_cache.get_translation(
                            text=allowed_value,
                            target_lang=target_language,
                            source_lang=source_language,
                            context=context
                        )
                        translated_allowed_values.append(translated_allowed_value.translated_text)
                    if translated_allowed_values:
                        translated_config[field_config][field_name]['allowed_values'] = translated_allowed_values

            return translated_config

    @staticmethod
    def translate(tenant_id: int, text: str, target_language: str, source_language: Optional[str] = None,
                  context: Optional[str] = None)-> str:
        if current_event:
            with current_event.create_span('Translation'):
                translation_cache = cache_manager.translation_cache.get_translation(text, target_language,
                                                                                    source_language, context)
                return translation_cache.translated_text
        else:
            with BusinessEvent('Translation Service', tenant_id):
                with current_event.create_span('Translation'):
                    translation_cache = cache_manager.translation_cache.get_translation(text, target_language,
                                                                                        source_language, context)
                    return translation_cache.translated_text