"""
Internationalization utilities for AI analysis prompts.

This module provides translation dictionaries and helper functions
for generating multilingual prompts for BaZi and LiuYao analysis.
"""
from typing import Dict, Any

# Supported languages
SUPPORTED_LANGUAGES = ['zh-hans', 'en']
DEFAULT_LANGUAGE = 'zh-hans'

# Translation dictionaries
TRANSLATIONS = {
    'zh-hans': {
        # Gender
        'gender_male': '男',
        'gender_female': '女',
        'gender_not_specified': '不指定',
        
        # None/Empty placeholders
        'none': '无',
        'error': 'Error',
        'unknown': '未知',
        
        # Elements
        'element_wood': '木',
        'element_fire': '火',
        'element_earth': '土',
        'element_metal': '金',
        'element_water': '水',
        
        # Common phrases
        'self': '日主',
        'self_label': '日主',
        'current_age': '当前年龄',
        'current_luck_pillar': '当前大运',
        'current_year': '当前年份',
    },
    'en': {
        # Gender
        'gender_male': 'Male',
        'gender_female': 'Female',
        'gender_not_specified': 'Not Specified',
        
        # None/Empty placeholders
        'none': 'None',
        'error': 'Error',
        'unknown': 'Unknown',
        
        # Elements
        'element_wood': 'Wood',
        'element_fire': 'Fire',
        'element_earth': 'Earth',
        'element_metal': 'Metal',
        'element_water': 'Water',
        
        # Common phrases
        'self': 'Day Master',
        'self_label': 'Day Master',
        'current_age': 'Current Age',
        'current_luck_pillar': 'Current Luck Pillar',
        'current_year': 'Current Year',
    }
}

# Element translation mapping (from English key to language-specific value)
ELEMENT_TRANSLATION = {
    'wood': {
        'zh-hans': '木',
        'en': 'Wood',
    },
    'fire': {
        'zh-hans': '火',
        'en': 'Fire',
    },
    'earth': {
        'zh-hans': '土',
        'en': 'Earth',
    },
    'metal': {
        'zh-hans': '金',
        'en': 'Metal',
    },
    'water': {
        'zh-hans': '水',
        'en': 'Water',
    },
}

# Heavenly Stems (天干) - 10 stems
# Index mapping: 0-9
HEAVENLY_STEMS = {
    0: {'zh-hans': '甲', 'en': 'Jia'},
    1: {'zh-hans': '乙', 'en': 'Yi'},
    2: {'zh-hans': '丙', 'en': 'Bing'},
    3: {'zh-hans': '丁', 'en': 'Ding'},
    4: {'zh-hans': '戊', 'en': 'Wu'},
    5: {'zh-hans': '己', 'en': 'Ji'},
    6: {'zh-hans': '庚', 'en': 'Geng'},
    7: {'zh-hans': '辛', 'en': 'Xin'},
    8: {'zh-hans': '壬', 'en': 'Ren'},
    9: {'zh-hans': '癸', 'en': 'Gui'},
}

# Earthly Branches (地支) - 12 branches with zodiac animals
# Index mapping: 0-11
EARTHLY_BRANCHES = {
    0: {'zh-hans': '子', 'en': 'Zi (Rat)'},
    1: {'zh-hans': '丑', 'en': 'Chou (Ox)'},
    2: {'zh-hans': '寅', 'en': 'Yin (Tiger)'},
    3: {'zh-hans': '卯', 'en': 'Mao (Rabbit)'},
    4: {'zh-hans': '辰', 'en': 'Chen (Dragon)'},
    5: {'zh-hans': '巳', 'en': 'Si (Snake)'},
    6: {'zh-hans': '午', 'en': 'Wu (Horse)'},
    7: {'zh-hans': '未', 'en': 'Wei (Goat)'},
    8: {'zh-hans': '申', 'en': 'Shen (Monkey)'},
    9: {'zh-hans': '酉', 'en': 'You (Rooster)'},
    10: {'zh-hans': '戌', 'en': 'Xu (Dog)'},
    11: {'zh-hans': '亥', 'en': 'Hai (Pig)'},
}

# Ten Gods (十神) - 10 relationships
TEN_GODS = {
    '比肩': {'zh-hans': '比肩', 'en': 'Friends (比肩)'},
    '劫财': {'zh-hans': '劫财', 'en': 'Rob Wealth (劫财)'},
    '食神': {'zh-hans': '食神', 'en': 'Eating God (食神)'},
    '伤官': {'zh-hans': '伤官', 'en': 'Hurting Officer (伤官)'},
    '偏财': {'zh-hans': '偏财', 'en': 'Indirect Wealth (偏财)'},
    '正财': {'zh-hans': '正财', 'en': 'Direct Wealth (正财)'},
    '七煞': {'zh-hans': '七煞', 'en': 'Seven Killings (七煞)'},
    '正官': {'zh-hans': '正官', 'en': 'Direct Officer (正官)'},
    '偏印': {'zh-hans': '偏印', 'en': 'Indirect Resource (偏印)'},
    '正印': {'zh-hans': '正印', 'en': 'Direct Resource (正印)'},
}

# Special Stars (神煞) - 26 stars
# Index mapping based on gShagodNames
SPECIAL_STARS = {
    0: {'zh-hans': '天乙', 'en': 'Heavenly Nobleman (天乙)'},
    1: {'zh-hans': '天德', 'en': 'Heavenly Virtue (天德)'},
    2: {'zh-hans': '月德', 'en': 'Moon Virtue (月德)'},
    3: {'zh-hans': '太极', 'en': 'Grand Ultimate (太极)'},
    4: {'zh-hans': '禄神', 'en': 'Fortune God (禄神)'},
    5: {'zh-hans': '文昌', 'en': 'Academic Star (文昌)'},
    6: {'zh-hans': '驿马', 'en': 'Traveling Horse (驿马)'},
    7: {'zh-hans': '桃花', 'en': 'Peach Blossom (桃花)'},
    8: {'zh-hans': '红鸾', 'en': 'Red Phoenix (红鸾)'},
    9: {'zh-hans': '天喜', 'en': 'Heavenly Joy (天喜)'},
    10: {'zh-hans': '将星', 'en': 'General Star (将星)'},
    11: {'zh-hans': '福星', 'en': 'Fortune Star (福星)'},
    12: {'zh-hans': '华盖', 'en': 'Artistic Star (华盖)'},
    13: {'zh-hans': '劫煞', 'en': 'Robbery Star (劫煞)'},
    14: {'zh-hans': '亡神', 'en': 'Calamity Star (亡神)'},
    15: {'zh-hans': '羊刃', 'en': 'Goat Blade (羊刃)'},
    16: {'zh-hans': '灾煞', 'en': 'Disaster (灾煞)'},
    17: {'zh-hans': '孤辰', 'en': 'Lonely Star (孤辰)'},
    18: {'zh-hans': '寡宿', 'en': 'Widow Star (寡宿)'},
    19: {'zh-hans': '阴差阳错', 'en': 'Yin-Yang Mismatch (阴差阳错)'},
    20: {'zh-hans': '天医', 'en': 'Heavenly Doctor (天医)'},
    21: {'zh-hans': '飞刃', 'en': 'Flying Blade (飞刃)'},
    22: {'zh-hans': '隔角', 'en': 'Separated Angle (隔角)'},
    23: {'zh-hans': '十恶大败', 'en': 'Great Defeat Star (十恶大败)'},
    24: {'zh-hans': '六秀', 'en': 'Six Talents (六秀)'},
    25: {'zh-hans': '金舆', 'en': 'Golden Chariot (金舆)'},
}


def get_translation(key: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Get a translated string for a given key and language.
    
    Args:
        key: Translation key
        language: Language code (zh-hans or en)
        
    Returns:
        Translated string, or the key if translation not found
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    return TRANSLATIONS.get(language, {}).get(key, key)


def translate_gender(gender: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate gender value to the specified language.
    
    Args:
        gender: Gender code (M, F, N)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated gender string
    """
    if gender == 'M':
        return get_translation('gender_male', language)
    elif gender == 'F':
        return get_translation('gender_female', language)
    else:
        return get_translation('gender_not_specified', language)


def translate_element(element: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate element name to the specified language.
    
    Args:
        element: Element name in English (wood, fire, earth, metal, water)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated element string
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    return ELEMENT_TRANSLATION.get(element.lower(), {}).get(language, element)


def translate_none(value: Any, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate None/empty values to the specified language.
    
    Args:
        value: Value to check (None, empty string, etc.)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated "None" string if value is None/empty, otherwise str(value)
    """
    if value is None or value == '' or value == '无':
        return get_translation('none', language)
    return str(value)


def validate_language(language: str) -> str:
    """
    Validate and normalize language code.
    
    Args:
        language: Language code to validate
        
    Returns:
        Validated language code (defaults to zh-hans if invalid)
    """
    if language in SUPPORTED_LANGUAGES:
        return language
    return DEFAULT_LANGUAGE


def normalize_language(language: str) -> str:
    """
    Normalize language code (alias for validate_language).
    
    Args:
        language: Language code to normalize
        
    Returns:
        Normalized language code (defaults to zh-hans if invalid)
    """
    return validate_language(language)


def get_text(key: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Get a translated text by key (alias for get_translation).
    
    Args:
        key: Translation key
        language: Language code (zh-hans or en)
        
    Returns:
        Translated string, or the key if translation not found
    """
    return get_translation(key, language)


def none_text(language: str = DEFAULT_LANGUAGE) -> str:
    """
    Get the "None" placeholder text for the specified language.
    
    Args:
        language: Language code (zh-hans or en)
        
    Returns:
        "None" text in the specified language
    """
    return get_translation('none', language)


def error_text(language: str = DEFAULT_LANGUAGE) -> str:
    """
    Get the "Error" placeholder text for the specified language.
    
    Args:
        language: Language code (zh-hans or en)
        
    Returns:
        "Error" text in the specified language
    """
    return get_translation('error', language)


def unknown_text(language: str = DEFAULT_LANGUAGE) -> str:
    """
    Get the "Unknown" placeholder text for the specified language.
    
    Args:
        language: Language code (zh-hans or en)
        
    Returns:
        "Unknown" text in the specified language
    """
    return get_translation('unknown', language)


def join_list(items: list, language: str = DEFAULT_LANGUAGE, separator: str = ', ') -> str:
    """
    Join a list of items with a separator, handling None/empty values.
    
    Args:
        items: List of items to join
        language: Language code (zh-hans or en)
        separator: Separator string (default: ', ')
        
    Returns:
        Joined string, or "None" text if list is empty
    """
    if not items:
        return none_text(language)
    
    # Filter out None and empty values
    filtered_items = [str(item) for item in items if item is not None and str(item).strip()]
    
    if not filtered_items:
        return none_text(language)
    
    return separator.join(filtered_items)


def is_missing(value: Any, language: str = DEFAULT_LANGUAGE) -> bool:
    """
    Check if a value is missing (None, empty, or equals the "None" text).
    
    Args:
        value: Value to check
        language: Language code (zh-hans or en) - used to check against localized "None"
        
    Returns:
        True if value is missing, False otherwise
    """
    if value is None:
        return True
    if isinstance(value, str):
        value = value.strip()
        if not value:
            return True
        # Check if it equals the localized "None" text
        if value == none_text(language) or value == '无':
            return True
    return False


def translate_heavenly_stem(stem: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate heavenly stem (天干) to the specified language.
    
    Args:
        stem: Heavenly stem character (e.g., '甲', '乙') or index (0-9)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated stem string. For English: "Jia (甲)", for Chinese: "甲"
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    # Try to find by Chinese character first
    for idx, data in HEAVENLY_STEMS.items():
        if data['zh-hans'] == stem:
            if language == 'en':
                return f"{data['en']} ({data['zh-hans']})"
            return data['zh-hans']
    
    # Try to find by index if stem is a number
    try:
        idx = int(stem)
        if idx in HEAVENLY_STEMS:
            data = HEAVENLY_STEMS[idx]
            if language == 'en':
                return f"{data['en']} ({data['zh-hans']})"
            return data['zh-hans']
    except (ValueError, TypeError):
        pass
    
    # If not found, return as-is
    return stem


def translate_earthly_branch(branch: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate earthly branch (地支) to the specified language.
    
    Args:
        branch: Earthly branch character (e.g., '子', '丑') or index (0-11)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated branch string. For English: "Zi (Rat) (子)", for Chinese: "子"
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    # Try to find by Chinese character first
    for idx, data in EARTHLY_BRANCHES.items():
        if data['zh-hans'] == branch:
            if language == 'en':
                return f"{data['en']} ({data['zh-hans']})"
            return data['zh-hans']
    
    # Try to find by index if branch is a number
    try:
        idx = int(branch)
        if idx in EARTHLY_BRANCHES:
            data = EARTHLY_BRANCHES[idx]
            if language == 'en':
                return f"{data['en']} ({data['zh-hans']})"
            return data['zh-hans']
    except (ValueError, TypeError):
        pass
    
    # If not found, return as-is
    return branch


def translate_ten_god(ten_god: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate Ten God (十神) to the specified language.
    
    Args:
        ten_god: Ten God name in Chinese (e.g., '比肩', '食神')
        language: Language code (zh-hans or en)
        
    Returns:
        Translated Ten God string. For English: "Friends (比肩)", for Chinese: "比肩"
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    if ten_god in TEN_GODS:
        return TEN_GODS[ten_god].get(language, ten_god)
    
    # If not found, return as-is
    return ten_god


def translate_special_star(star: str, language: str = DEFAULT_LANGUAGE) -> str:
    """
    Translate Special Star (神煞) to the specified language.
    
    Args:
        star: Special Star name in Chinese (e.g., '天乙', '文昌') or index (0-25)
        language: Language code (zh-hans or en)
        
    Returns:
        Translated Special Star string. For English: "Heavenly Nobleman (天乙)", for Chinese: "天乙"
    """
    if language not in SUPPORTED_LANGUAGES:
        language = DEFAULT_LANGUAGE
    
    # Try to find by Chinese character first
    for idx, data in SPECIAL_STARS.items():
        if data['zh-hans'] == star:
            if language == 'en':
                return f"{data['en']}"
            return data['zh-hans']
    
    # Try to find by index if star is a number
    try:
        idx = int(star)
        if idx in SPECIAL_STARS:
            data = SPECIAL_STARS[idx]
            if language == 'en':
                return f"{data['en']}"
            return data['zh-hans']
    except (ValueError, TypeError):
        pass
    
    # If not found, return as-is
    return star


def format_luck_description(
    god: str,
    earth: str,
    age_range: str,
    stem_relationship: str = None,
    branch_relationships: str = None,
    language: str = DEFAULT_LANGUAGE
) -> str:
    """
    Format a luck pillar description with optional ten god relationships.
    
    Args:
        god: Heavenly stem (天干)
        earth: Earthly branch (地支)
        age_range: Age range string
        stem_relationship: Optional ten god relationship for stem
        branch_relationships: Optional ten god relationships for branch
        language: Language code (zh-hans or en)
        
    Returns:
        Formatted luck pillar description
    """
    # Translate god and earth
    translated_god = translate_heavenly_stem(god, language)
    translated_earth = translate_earthly_branch(earth, language)
    
    # Include original Chinese characters in base
    if language == 'zh-hans':
        base = f"{god}{earth} (Ages {age_range})"
    else:
        # For English, include both translation and original Chinese
        base = f"{god}{earth} ({translated_god}{translated_earth}) (Ages {age_range})"
    
    if language == 'en':
        # English format
        if stem_relationship and not is_missing(stem_relationship, language):
            translated_stem_rel = translate_ten_god(stem_relationship, language)
            parts = [f"Ten Gods: {translated_god}: {translated_stem_rel}"]
            if branch_relationships and not is_missing(branch_relationships, language):
                # Translate each ten god in branch relationships
                branch_parts = []
                for rel in branch_relationships.split(', '):
                    if rel.strip():
                        translated_rel = translate_ten_god(rel.strip(), language)
                        branch_parts.append(translated_rel)
                if branch_parts:
                    parts.append(f"{translated_earth}: {', '.join(branch_parts)}")
            base += f" ({', '.join(parts)})"
    else:
        # Chinese format
        if stem_relationship and not is_missing(stem_relationship, language):
            parts = [f"十神：{god}：{stem_relationship}"]
            if branch_relationships and not is_missing(branch_relationships, language):
                parts.append(f"{earth}：{branch_relationships}")
            base += f" ({', '.join(parts)})"
    
    return base