"""
Model value translator - handles translation of model field values based on current language.
Supports django-modeltranslation or fallback translation mechanism.
"""

from django.utils.translation import get_language
from django.conf import settings
import logging

logger = logging.getLogger(__name__)


def get_translated_field(obj, field_name, fallback_value=None):
    """
    Get translated value of a model field based on current language.
    
    Supports:
    1. django-modeltranslation translated fields (e.g., name_en, name_de)
    2. Direct model field values (returns as-is)
    
    Args:
        obj: Model instance
        field_name: Field name to translate (e.g., 'name', 'description')
        fallback_value: Value to return if translation not found
    
    Returns:
        Translated value or original value
    """
    if not obj:
        return fallback_value
    
    current_language = get_language() or 'en'
    language_code = current_language.split('-')[0]  # Handle 'en-US' -> 'en'
    
    # Try to get django-modeltranslation field (e.g., name_en, name_de)
    translated_field = f"{field_name}_{language_code}"
    
    if hasattr(obj, translated_field):
        try:
            translated_value = getattr(obj, translated_field, None)
            if translated_value:
                return translated_value
        except Exception as e:
            logger.debug(f"Error getting translated field {translated_field}: {e}")
    
    # Fallback to base field
    if hasattr(obj, field_name):
        try:
            return getattr(obj, field_name)
        except Exception as e:
            logger.debug(f"Error getting field {field_name}: {e}")
    
    return fallback_value


def translate_queryset_fields(queryset, field_mappings):
    """
    Translate multiple fields in a queryset result.
    
    Args:
        queryset: QuerySet of model instances
        field_mappings: Dict mapping model fields to display names
                       e.g., {'name': 'product_name', 'description': 'product_desc'}
    
    Returns:
        List of dicts with translated values
    """
    results = []
    
    for obj in queryset:
        translated_obj = {}
        for model_field, display_name in field_mappings.items():
            translated_obj[display_name] = get_translated_field(obj, model_field)
        translated_obj['_original'] = obj  # Store original object reference
        results.append(translated_obj)
    
    return results


def get_product_translated_data(product):
    """
    Get all translatable fields from a Product instance.
    
    Returns:
        Dict with translated product data
    """
    if not product:
        return {}
    
    return {
        'name': get_translated_field(product, 'name', product.name),
        'description': get_translated_field(product, 'description', product.description),
        'category': get_translated_field(product.category, 'name', product.category.name) if product.category else None,
        'original': product
    }


def get_category_translated_data(category):
    """
    Get all translatable fields from a Category instance.
    
    Returns:
        Dict with translated category data
    """
    if not category:
        return {}
    
    return {
        'name': get_translated_field(category, 'name', category.name),
        'description': get_translated_field(category, 'description', category.description),
        'original': category
    }


def get_order_translated_data(order):
    """
    Get order with translated product information.
    
    Returns:
        Dict with translated order data including items
    """
    if not order:
        return {}
    
    translated_items = []
    for item in order.items.all():
        translated_items.append({
            'product_name': get_translated_field(item.product, 'name', item.product.name),
            'product_description': get_translated_field(item.product, 'description', item.product.description),
            'quantity': item.quantity,
            'price': item.price,
            'subtotal': item.get_subtotal(),
            'original_item': item
        })
    
    return {
        'order_id': order.id,
        'reference': order.reference,
        'status': order.status,
        'total': order.total,
        'items': translated_items,
        'created_at': order.created_at,
        'original': order
    }


def get_discount_translated_data(discount):
    """
    Get translated discount information.
    
    Returns:
        Dict with translated discount data
    """
    if not discount:
        return {}
    
    return {
        'name': get_translated_field(discount, 'name', discount.name),
        'description': get_translated_field(discount, 'description', discount.description),
        'discount_type': discount.discount_type,
        'value': discount.value,
        'original': discount
    }


def current_language_code():
    """
    Get current language code (without region, e.g., 'en' not 'en-US').
    
    Returns:
        Language code string
    """
    current_lang = get_language() or 'en'
    return current_lang.split('-')[0]


def is_rtl_language():
    """
    Check if current language is right-to-left.
    
    Returns:
        Boolean
    """
    rtl_languages = ['ar', 'he', 'ur', 'fa']
    return current_language_code() in rtl_languages


def get_language_info():
    """
    Get information about current language and available languages.
    
    Returns:
        Dict with language configuration
    """
    current_lang = current_language_code()
    languages_dict = dict(settings.LANGUAGES)
    
    return {
        'current_code': current_lang,
        'current_name': languages_dict.get(current_lang, current_lang),
        'is_rtl': is_rtl_language(),
        'available_languages': settings.LANGUAGES
    }