"""
MMD Converter - Core conversion logic for MMD models
Handles armature hierarchy and naming conventions
"""
import bpy
import re
from typing import Dict, List, Optional, Tuple, Set
from bpy.types import Object, Bone, Collection, Material, ShapeKey
from .common import get_active_armature
from .dictionaries import simplify_bonename
from .enhanced_dictionaries import mmd_bone_patterns, mmd_to_unity_bone_map, unity_bone_hierarchy
from .logging_setup import logger
from .translations import t
from .mmd.translations import jp_to_en_tuples, translateFromJp


def detect_mmd_armature(armature: Object) -> bool:
    """Detect if armature uses MMD bone naming conventions"""

    if not armature or armature.type != 'ARMATURE':
        return False
    
    found_mmd_bones = 0
    for bone in armature.data.bones:
        bone_name_lower = bone.name.lower()
        if any(pattern.lower() in bone_name_lower for pattern in mmd_bone_patterns):
            found_mmd_bones += 1
            logger.debug(f"Found MMD bone: {bone.name}")
    
    # Consider it MMD if we find at least 5 MMD bones
    logger.debug(f"Found {found_mmd_bones} MMD bones in armature {armature.name}")
    return found_mmd_bones >= 5


def get_armature_parent_object(armature: Object) -> Optional[Object]:
    """Get the parent object of the armature (typically an Empty in MMD imports)"""
    if armature and armature.parent:
        return armature.parent
    return None


def make_armature_main_parent(armature: Object) -> Tuple[bool, str]:
    """Make the armature the main parent object by removing any parent empties
    and reparenting all children to the armature."""

    if not armature or armature.type != 'ARMATURE':
        return False, t("MMD.error.invalid_armature")
    
    logger.info(f"Making armature '{armature.name}' the main parent")
    
    # Store original parent
    original_parent = armature.parent
    
    if not original_parent:
        logger.info("Armature already has no parent")
        return True, t("MMD.armature_already_root")
    
    parent_name = original_parent.name
    parent_type = original_parent.type
    
    logger.info(f"Found parent: {parent_name} (type: {parent_type})")
    
    # Get all children of the parent
    siblings = [child for child in original_parent.children if child != armature]

    armature.parent = None
    
    # Reparent siblings to the armature
    reparented_count = 0
    for sibling in siblings:
        sibling.parent = armature
        reparented_count += 1
        logger.debug(f"Reparented {sibling.name} to armature")
    
    # If the parent was an Empty and now has no children, remove it
    if parent_type == 'EMPTY' and len(original_parent.children) == 0:
        try:
            bpy.data.objects.remove(original_parent, do_unlink=True)
            logger.info(f"Removed empty parent object: {parent_name}")
            message = t("MMD.parent_removed_and_reparented", 
                       parent_name=parent_name, 
                       count=reparented_count)
        except Exception as e:
            logger.warning(f"Could not remove parent empty: {str(e)}")
            message = t("MMD.parent_unlinked_and_reparented",
                       parent_name=parent_name,
                       count=reparented_count)
    else:
        message = t("MMD.parent_unlinked", parent_name=parent_name)
    
    logger.info(f"Successfully made armature the main parent. Reparented {reparented_count} objects")
    return True, message


def rename_armature_to_standard(armature: Object) -> Tuple[bool, str]:
    """Rename the armature object to 'Armature' (standard Blender convention)"""
    if not armature or armature.type != 'ARMATURE':
        return False, t("MMD.error.invalid_armature")
    
    old_name = armature.name
    
    # Check if already named 'Armature'
    if old_name == 'Armature':
        logger.info("Armature already named 'Armature'")
        return True, t("MMD.armature_already_named")
    
    logger.info(f"Renaming armature from '{old_name}' to 'Armature'")
    
    try:
        armature.name = 'Armature'
        # Blender might append .001 if name exists, check actual result (Wonder if needed)
        actual_name = armature.name
        
        if actual_name == 'Armature':
            message = t("MMD.armature_renamed", old_name=old_name, new_name='Armature')
        else:
            message = t("MMD.armature_renamed_with_suffix", 
                       old_name=old_name, 
                       new_name=actual_name)
            logger.warning(f"Name collision, armature named: {actual_name}")
        
        logger.info(f"Successfully renamed armature to: {actual_name}")
        return True, message
        
    except Exception as e:
        logger.error(f"Failed to rename armature: {str(e)}")
        return False, t("MMD.error.rename_failed", error=str(e))


def convert_mmd_armature(armature: Object, 
                        make_parent: bool = True, 
                        rename_armature: bool = True) -> Tuple[bool, List[str]]:
    """Convert MMD armature to standard Blender format"""
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting MMD armature conversion for: {armature.name}")
    
    # Check if this is an MMD armature
    if not detect_mmd_armature(armature):
        return False, [t("MMD.error.not_mmd_armature")]
    
    messages = []
    overall_success = True
    
    # Step 1: Make armature the main parent
    if make_parent:
        success, message = make_armature_main_parent(armature)
        messages.append(message)
        if not success:
            overall_success = False
            logger.warning("Failed to make armature main parent")
    
    # Step 2: Rename armature
    if rename_armature:
        success, message = rename_armature_to_standard(armature)
        messages.append(message)
        if not success:
            overall_success = False
            logger.warning("Failed to rename armature")
    
    if overall_success:
        logger.info("MMD armature conversion completed successfully")
        messages.append(t("MMD.conversion_complete"))
    else:
        logger.warning("MMD armature conversion completed with errors")
    
    return overall_success, messages


def translate_mmd_name(name: str, category: str = "auto") -> Tuple[str, str]:
    """Translate MMD name using MMD dictionary first, then translation services"""
    if not name or not name.strip():
        return name, "unchanged"
    
    original_name = name.strip()
    
    # Step 1: Try MMD built-in dictionary translation
    mmd_translated = translateFromJp(original_name)
    
    # Check if MMD dictionary actually translated something
    if mmd_translated != original_name and mmd_translated:
        logger.debug(f"MMD dictionary translated: '{original_name}' -> '{mmd_translated}'")
        return mmd_translated, "mmd_dictionary"
    
    # Step 2: If MMD dictionary didn't translate or only partially translated,
    # use Avatar Toolkit translation services
    try:
        from .translation_manager import get_avatar_translation_manager
        
        manager = get_avatar_translation_manager()
        result = manager.translate_single(original_name, category=category, source_lang="ja", target_lang="en")
        
        if result.translated != original_name:
            logger.debug(f"API translated: '{original_name}' -> '{result.translated}' (method: {result.method})")
            return result.translated, "api_translation"
    except Exception as e:
        logger.warning(f"Translation service failed for '{original_name}': {e}")
    
    # Step 3: No translation available
    logger.debug(f"No translation available for: '{original_name}'")
    return original_name, "unchanged"


def translate_mmd_armature_bones(armature: Object, apply_translation: bool = True) -> Tuple[int, int, List[str]]:
    """Translate all bone names in an MMD armature"""
    if not armature or armature.type != 'ARMATURE':
        return 0, 0, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting bone translation for armature: {armature.name}")
    
    successful = 0
    failed = 0
    messages = []
    bone_translations = {}
    
    # Store the current mode
    current_mode = bpy.context.mode
    if current_mode != 'EDIT':
        bpy.context.view_layer.objects.active = armature
        bpy.ops.object.mode_set(mode='EDIT')
    
    try:
        for bone in armature.data.edit_bones:
            original_name = bone.name
            translated_name, method = translate_mmd_name(original_name, category="bones")
            
            if translated_name != original_name:
                bone_translations[original_name] = (translated_name, method)
                
                if apply_translation:
                    try:
                        bone.name = translated_name
                        logger.info(f"Translated bone: '{original_name}' -> '{translated_name}' ({method})")
                        successful += 1
                    except Exception as e:
                        logger.error(f"Failed to rename bone '{original_name}': {e}")
                        failed += 1
                else:
                    successful += 1
            else:
                logger.debug(f"Bone '{original_name}' not translated")
    
    finally:
        # Restore original mode
        if current_mode != 'EDIT':
            bpy.ops.object.mode_set(mode='OBJECT')
    
    # Generate summary messages
    if successful > 0:
        messages.append(t("MMD.bones_translated", count=successful))
    if failed > 0:
        messages.append(t("MMD.bones_failed", count=failed))
    
    mmd_dict_count = sum(1 for _, (_, method) in bone_translations.items() if method == "mmd_dictionary")
    api_count = sum(1 for _, (_, method) in bone_translations.items() if method == "api_translation")
    
    logger.info(f"Bone translation complete: {successful} successful, {failed} failed")
    logger.info(f"Translation methods: MMD Dictionary: {mmd_dict_count}, API: {api_count}")
    
    return successful, failed, messages


def translate_mmd_materials(armature: Object, apply_translation: bool = True) -> Tuple[int, int, List[str]]:
    """Translate all material names for meshes parented to the armature"""
    if not armature or armature.type != 'ARMATURE':
        return 0, 0, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting material translation for armature: {armature.name}")
    
    successful = 0
    failed = 0
    messages = []
    processed_materials = set()
    
    # Get all mesh objects parented to this armature
    for obj in bpy.data.objects:
        if obj.type == 'MESH' and obj.parent == armature and obj.data.materials:
            for mat in obj.data.materials:
                if mat and mat.name not in processed_materials:
                    processed_materials.add(mat.name)
                    original_name = mat.name
                    translated_name, method = translate_mmd_name(original_name, category="materials")
                    
                    if translated_name != original_name and apply_translation:
                        try:
                            mat.name = translated_name
                            logger.info(f"Translated material: '{original_name}' -> '{translated_name}' ({method})")
                            successful += 1
                        except Exception as e:
                            logger.error(f"Failed to rename material '{original_name}': {e}")
                            failed += 1
                    elif translated_name != original_name:
                        successful += 1
    
    if successful > 0:
        messages.append(t("MMD.materials_translated", count=successful))
    if failed > 0:
        messages.append(t("MMD.materials_failed", count=failed))
    
    logger.info(f"Material translation complete: {successful} successful, {failed} failed")
    
    return successful, failed, messages


def translate_mmd_shapekeys(armature: Object, apply_translation: bool = True) -> Tuple[int, int, List[str]]:
    """Translate all shape key names for meshes parented to the armature"""
    if not armature or armature.type != 'ARMATURE':
        return 0, 0, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting shape key translation for armature: {armature.name}")
    
    successful = 0
    failed = 0
    messages = []
    
    # Get all mesh objects parented to this armature
    for obj in bpy.data.objects:
        if obj.type == 'MESH' and obj.parent == armature and obj.data.shape_keys:
            for shape_key in obj.data.shape_keys.key_blocks:
                original_name = shape_key.name
                translated_name, method = translate_mmd_name(original_name, category="shapekeys")
                
                if translated_name != original_name and apply_translation:
                    try:
                        shape_key.name = translated_name
                        logger.info(f"Translated shape key: '{original_name}' -> '{translated_name}' ({method})")
                        successful += 1
                    except Exception as e:
                        logger.error(f"Failed to rename shape key '{original_name}': {e}")
                        failed += 1
                elif translated_name != original_name:
                    successful += 1
    
    if successful > 0:
        messages.append(t("MMD.shapekeys_translated", count=successful))
    if failed > 0:
        messages.append(t("MMD.shapekeys_failed", count=failed))
    
    logger.info(f"Shape key translation complete: {successful} successful, {failed} failed")
    
    return successful, failed, messages


def translate_mmd_objects(armature: Object, apply_translation: bool = True) -> Tuple[int, int, List[str]]:
    """Translate object names parented to the armature"""
    if not armature or armature.type != 'ARMATURE':
        return 0, 0, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting object name translation for armature: {armature.name}")
    
    successful = 0
    failed = 0
    messages = []
    
    # Get all objects parented to this armature
    for obj in bpy.data.objects:
        if obj.parent == armature:
            original_name = obj.name
            translated_name, method = translate_mmd_name(original_name, category="objects")
            
            if translated_name != original_name and apply_translation:
                try:
                    obj.name = translated_name
                    logger.info(f"Translated object: '{original_name}' -> '{translated_name}' ({method})")
                    successful += 1
                except Exception as e:
                    logger.error(f"Failed to rename object '{original_name}': {e}")
                    failed += 1
            elif translated_name != original_name:
                successful += 1
    
    if successful > 0:
        messages.append(t("MMD.objects_translated", count=successful))
    if failed > 0:
        messages.append(t("MMD.objects_failed", count=failed))
    
    logger.info(f"Object translation complete: {successful} successful, {failed} failed")
    
    return successful, failed, messages


def translate_mmd_everything(armature: Object, 
                            translate_bones: bool = True,
                            translate_materials: bool = True, 
                            translate_shapekeys: bool = True,
                            translate_objects: bool = True) -> Tuple[bool, List[str]]:
    """
    Translate all MMD names (bones, materials, shape keys, objects)
    
    Args:
        armature: The armature object
        translate_bones: Whether to translate bone names
        translate_materials: Whether to translate material names
        translate_shapekeys: Whether to translate shape key names
        translate_objects: Whether to translate object names
        
    Returns:
        Tuple of (success, messages)
    """
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting comprehensive MMD translation for: {armature.name}")
    
    all_messages = []
    total_successful = 0
    total_failed = 0
    
    # Translate bones
    if translate_bones:
        success, failed, messages = translate_mmd_armature_bones(armature, apply_translation=True)
        total_successful += success
        total_failed += failed
        all_messages.extend(messages)
    
    # Translate materials
    if translate_materials:
        success, failed, messages = translate_mmd_materials(armature, apply_translation=True)
        total_successful += success
        total_failed += failed
        all_messages.extend(messages)
    
    # Translate shape keys
    if translate_shapekeys:
        success, failed, messages = translate_mmd_shapekeys(armature, apply_translation=True)
        total_successful += success
        total_failed += failed
        all_messages.extend(messages)
    
    # Translate objects
    if translate_objects:
        success, failed, messages = translate_mmd_objects(armature, apply_translation=True)
        total_successful += success
        total_failed += failed
        all_messages.extend(messages)
    
    # Summary
    if total_successful > 0:
        all_messages.append(t("MMD.translation_complete", total=total_successful))
    
    logger.info(f"Comprehensive MMD translation complete: {total_successful} successful, {total_failed} failed")
    
    return total_failed == 0, all_messages


def restructure_mmd_to_unity_bones(armature: Object) -> Tuple[bool, List[str]]:
    """Restructure MMD bone hierarchy to Unity humanoid format."""
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting MMD to Unity bone restructuring for: {armature.name}")
    
    messages = []
    renamed_count = 0
    removed_count = 0
    reparented_count = 0
    
    # Store the current mode
    current_mode = bpy.context.mode
    if current_mode != 'EDIT':
        bpy.context.view_layer.objects.active = armature
        bpy.ops.object.mode_set(mode='EDIT')
    
    try:
        edit_bones = armature.data.edit_bones
        bones_to_remove = []
        bone_renames = {}
        
        # Protected bone name patterns (never remove or modify these)
        protected_patterns = [
            r'.*[bB]reast.*', r'.*[bB]ust.*', r'.*[tT]its.*',  # Breast bones
            r'.*[sS]kirt.*',  # Skirt bones
            r'.*[hH]air.*',  # Hair bones
            r'.*[bB]ag.*',  # Bag/accessory bones
            r'.*[rR]ibbon.*',  # Ribbon bones
            r'.*[tT]ail.*',  # Tail bones
            r'.*[wW]ing.*',  # Wing bones
            r'.*[eE]ar.*',  # Ear bones
            r'.*[sS]leeve.*',  # Sleeve bones
            r'.*[cC]ape.*', r'.*[sS]carf.*',  # Cape/Scarf bones
            r'.*[cC]oat.*', r'.*[dD]ress.*',  # Coat/Dress bones
            r'.*[fF]inger.*', r'.*[tT]humb.*',  # Finger bones
            r'.*[aA]ccessor.*',  # Accessory bones
            r'.*[jJ]oint.*',  # Joint bones
            r'.*[cC]loth.*', r'.*[pP]hys.*',  # Cloth/Physics bones
            r'^tf_.*',  # tf_ prefixed bones (clothing/accessories)
            r'^\+.*',  # + prefixed bones (accessories)
            r'.*[tT]ooth.*',  # Tooth bones
        ]
        compiled_protected = [re.compile(pattern) for pattern in protected_patterns]
        
        # Step 1: Identify and map bones (but only rename/remove bones explicitly in the map)
        for bone in edit_bones:
            bone_name = bone.name
            
            # Check if bone is protected - never touch these
            is_protected = any(pattern.match(bone_name) for pattern in compiled_protected)
            if is_protected:
                logger.debug(f"Protected bone (keeping): {bone_name}")
                continue
            
            # Only process bones that are EXPLICITLY in the map
            unity_name = mmd_to_unity_bone_map.get(bone_name)
            
            if unity_name is None:
                # Only mark for removal if explicitly mapped to None
                if bone_name in mmd_to_unity_bone_map:
                    bones_to_remove.append(bone_name)
                    logger.debug(f"Marking bone for removal: {bone_name}")
                # Otherwise, keep the bone as-is
            elif unity_name != bone_name:
                # Mark for rename only if explicitly mapped
                bone_renames[bone_name] = unity_name
                logger.debug(f"Planning rename: {bone_name} -> {unity_name}")
        
        # Step 2: Handle bone merging (e.g., LowerBody + Center -> Hips)
        unity_bone_sources = {}
        for old_name, new_name in bone_renames.items():
            if new_name not in unity_bone_sources:
                unity_bone_sources[new_name] = []
            unity_bone_sources[new_name].append(old_name)
        
        # For bones with multiple sources, keep the first one and remove others
        for unity_name, sources in unity_bone_sources.items():
            if len(sources) > 1:
                logger.info(f"Multiple bones map to '{unity_name}': {sources}")
                # Keep the first, mark others for removal and reparent their children
                keep_bone = sources[0]
                for source in sources[1:]:
                    if source in edit_bones:
                        # Reparent children to the kept bone
                        bone_to_remove = edit_bones[source]
                        keep_bone_obj = edit_bones[keep_bone]
                        for child in bone_to_remove.children:
                            child.parent = keep_bone_obj
                            reparented_count += 1
                        bones_to_remove.append(source)
                        if source in bone_renames:
                            del bone_renames[source]
        
        # Step 3: Reparent bones to be removed (move children to parent)
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                bone = edit_bones[bone_name]
                parent_bone = bone.parent
                for child in bone.children:
                    child.parent = parent_bone
                    reparented_count += 1
                    logger.debug(f"Reparented {child.name} from {bone_name} to {parent_bone.name if parent_bone else 'None'}")
        
        # Step 4: Remove marked bones
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                edit_bones.remove(edit_bones[bone_name])
                removed_count += 1
                logger.info(f"Removed bone: {bone_name}")
        
        # Step 5: Rename bones
        for old_name, new_name in bone_renames.items():
            if old_name in edit_bones:
                bone = edit_bones[old_name]
                try:
                    bone.name = new_name
                    renamed_count += 1
                    logger.info(f"Renamed bone: {old_name} -> {new_name}")
                except Exception as e:
                    logger.error(f"Failed to rename bone {old_name}: {e}")
        
        # Step 6: Fix hierarchy to match Unity standard
        for bone in edit_bones:
            expected_parent_name = unity_bone_hierarchy.get(bone.name)
            if expected_parent_name is not None:
                # This bone should have a specific parent
                if expected_parent_name in edit_bones:
                    expected_parent = edit_bones[expected_parent_name]
                    if bone.parent != expected_parent:
                        bone.parent = expected_parent
                        reparented_count += 1
                        logger.debug(f"Fixed hierarchy: {bone.name} -> parent: {expected_parent_name}")
            elif expected_parent_name is None and unity_bone_hierarchy.get(bone.name) is not None:
                # This should be a root bone
                if bone.parent is not None:
                    bone.parent = None
                    reparented_count += 1
                    logger.debug(f"Made {bone.name} a root bone")
        
    except Exception as e:
        logger.error(f"Error during bone restructuring: {e}", exc_info=True)
        messages.append(t("MMD.restructure_failed", error=str(e)))
        return False, messages
    
    finally:
        # Restore original mode
        if current_mode != 'EDIT':
            bpy.ops.object.mode_set(mode='OBJECT')
    
    # Generate messages
    if renamed_count > 0:
        messages.append(t("MMD.bones_restructured", count=renamed_count))
    if removed_count > 0:
        messages.append(t("MMD.bones_removed", count=removed_count))
    if reparented_count > 0:
        messages.append(t("MMD.bones_reparented", count=reparented_count))
    
    logger.info(f"Bone restructuring complete: {renamed_count} renamed, {removed_count} removed, {reparented_count} reparented")
    
    return True, messages


def remove_mmd_ik_bones(armature: Object) -> Tuple[bool, List[str]]:
    """Remove MMD IK (Inverse Kinematics) and helper bones."""
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting MMD IK bone removal for: {armature.name}")
    
    messages = []
    removed_count = 0
    reparented_count = 0
    
    # Store the current mode
    current_mode = bpy.context.mode
    
    try:
        # Switch to object mode to check weights
        if bpy.context.mode != 'OBJECT':
            bpy.context.view_layer.objects.active = armature
            bpy.ops.object.mode_set(mode='OBJECT')
        
        # Get all meshes using this armature
        meshes = [obj for obj in bpy.data.objects 
                 if obj.type == 'MESH' and obj.parent == armature]
        
        # Track bones with weights
        bones_with_weights = set()
        
        for mesh in meshes:
            for vertex_group in mesh.vertex_groups:
                # Check if any vertices have non-zero weights
                has_weight = False
                for vert in mesh.data.vertices:
                    try:
                        weight = vertex_group.weight(vert.index)
                        if weight > 0.001:  # Threshold for "zero" weight
                            has_weight = True
                            break
                    except:
                        continue
                
                if has_weight:
                    bones_with_weights.add(vertex_group.name)
        
        logger.info(f"Found {len(bones_with_weights)} bones with vertex weights")
        
        # Set armature as active object before switching modes
        bpy.context.view_layer.objects.active = armature
        
        # Patterns to identify IK and helper bones (Japanese and English)
        # These are control/helper bones that typically have zero weights
        ik_helper_patterns = [
            r'.*[iI][kK].*',  # Contains IK (IK, ik, etc.)
            r'.*ＩＫ.*',  # Japanese fullwidth IK
            r'.*親.*',  # Japanese "parent"
            r'.*[DCd]$',  # D/C suffix (D-bones, control bones like RightKneeD, RightAnkleD)
            r'.*[Ee][Xx]$',  # EX suffix (extra bones like RightLegTipEX)
            r'.*[Pp]arent$',  # Ends with Parent
            r'.*[Pp]$',  # P suffix (helper bones like ShoulderP)
            r'.*[Cc]$',  # C suffix (control bones like ShoulderC)
            r'^_dummy_.*',  # Dummy bones
            r'^_shadow_.*',  # Shadow bones
            r'.*ダミー.*',  # Japanese "dummy"
            r'.*補助.*',  # Japanese "auxiliary/helper"
            r'.*操作.*',  # Japanese "control/operation"
            r'.*[Tt]arget$',  # Target bones
            r'.*[Gg]roup$',  # Group bones
        ]
        
        # Compile patterns
        compiled_patterns = [re.compile(pattern) for pattern in ik_helper_patterns]
        
        # Protected bone names (main skeleton - never remove these even with zero weights)
        protected_bones = {
            "Hips", "Spine", "Chest", "UpperChest", "Upper Chest", "Neck", "Head",
            "Left shoulder", "Right shoulder", "Shoulder_L", "Shoulder_R",
            "Left arm", "Right arm", "UpperArm_L", "UpperArm_R",
            "Left elbow", "Right elbow", "LowerArm_L", "LowerArm_R",
            "Left wrist", "Right wrist", "Hand_L", "Hand_R",
            "Left leg", "Right leg", "UpperLeg_L", "UpperLeg_R",
            "Left knee", "Right knee", "LowerLeg_L", "LowerLeg_R",
            "Left ankle", "Right ankle", "Foot_L", "Foot_R",
            "Left toe", "Right toe", "Toe_L", "Toe_R",
            "Left eye", "Right eye", "Eye_L", "Eye_R"
        }
        
        # Protected bone name patterns (never remove these)
        protected_patterns = [
            r'.*[bB]reast.*',  # Breast bones
            r'.*[bB]ust.*',  # Bust bones
            r'.*[sS]kirt.*',  # Skirt bones
            r'.*[hH]air.*',  # Hair bones
            r'.*[bB]ag.*',  # Bag/accessory bones
            r'.*[rR]ibbon.*',  # Ribbon bones
            r'.*[tT]ail.*',  # Tail bones
            r'.*[wW]ing.*',  # Wing bones
            r'.*[sS]leeve.*',  # Sleeve bones
            r'.*[cC]ape.*',  # Cape bones
            r'.*[sS]carf.*',  # Scarf bones
            r'.*[cC]oat.*',  # Coat bones
            r'.*[dD]ress.*',  # Dress bones
            r'.*[fF]inger.*',  # Finger bones
            r'.*[tT]humb.*',  # Thumb bones
            r'.*[aA]ccessor.*',  # Accessory bones
            r'.*[cC]loth.*',  # Cloth bones
            r'.*[pP]hys.*',  # Physics bones
        ]
        compiled_protected = [re.compile(pattern) for pattern in protected_patterns]
        
        # Switch to pose mode to remove constraints first
        bpy.ops.object.mode_set(mode='POSE')
        pose_bones = armature.pose.bones
        
        # Identify IK/helper bones to remove (zero weight + matches pattern)
        bones_to_remove = []
        
        for bone in armature.data.bones:
            bone_name = bone.name
            
            # Check if it matches IK/helper pattern FIRST (before protection checks)
            matches_pattern = any(pattern.match(bone_name) for pattern in compiled_patterns)
            
            # Skip if bone has weights (it's actually used by the mesh)
            if bone_name in bones_with_weights:
                if matches_pattern:
                    logger.debug(f"IK pattern match but has weights (keeping): {bone_name}")
                continue
            
            # If matches IK pattern, remove regardless of other checks (except weights)
            if matches_pattern:
                bones_to_remove.append(bone_name)
                logger.debug(f"IK/helper bone identified (zero weight): {bone_name}")
                
                # Remove constraints from this bone
                if bone_name in pose_bones:
                    pose_bone = pose_bones[bone_name]
                    for constraint in list(pose_bone.constraints):
                        constraint_name = constraint.name
                        pose_bone.constraints.remove(constraint)
                        logger.debug(f"Removed constraint '{constraint_name}' from {bone_name}")
                continue
            
            # Skip if in protected set
            if bone_name in protected_bones:
                continue
            
            # Skip if matches protected pattern
            is_protected = any(pattern.match(bone_name) for pattern in compiled_protected)
            if is_protected:
                logger.debug(f"Protected bone (keeping): {bone_name}")
                continue
        
        # Remove constraints that reference bones we're about to delete
        for pose_bone in pose_bones:
            for constraint in list(pose_bone.constraints):
                if hasattr(constraint, 'target') and constraint.target:
                    if hasattr(constraint, 'subtarget') and constraint.subtarget in bones_to_remove:
                        constraint_name = constraint.name
                        pose_bone_name = pose_bone.name
                        pose_bone.constraints.remove(constraint)
                        logger.debug(f"Removed constraint '{constraint_name}' from {pose_bone_name} (referenced deleted bone)")
        
        # Switch to edit mode for bone removal
        bpy.ops.object.mode_set(mode='EDIT')
        edit_bones = armature.data.edit_bones
        
        # Reparent children before removing
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                bone = edit_bones[bone_name]
                parent_bone = bone.parent
                for child in bone.children:
                    child.parent = parent_bone
                    reparented_count += 1
                    logger.debug(f"Reparented {child.name} from {bone_name} to {parent_bone.name if parent_bone else 'None'}")
        
        # Remove IK/helper bones
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                edit_bones.remove(edit_bones[bone_name])
                removed_count += 1
                logger.info(f"Removed IK/helper bone: {bone_name}")
        
    except Exception as e:
        logger.error(f"Error during IK bone removal: {e}", exc_info=True)
        messages.append(t("MMD.ik_removal_failed", error=str(e)))
        return False, messages
    
    finally:
        # Restore original mode
        if current_mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
    
    # Generate messages
    if removed_count > 0:
        messages.append(t("MMD.ik_bones_removed", count=removed_count))
    else:
        messages.append(t("MMD.no_ik_bones_found"))
    
    if reparented_count > 0:
        messages.append(t("MMD.bones_reparented", count=reparented_count))
    
    logger.info(f"IK bone removal complete: {removed_count} removed, {reparented_count} reparented")
    
    return True, messages


def remove_mmd_twist_bones(armature: Object) -> Tuple[bool, List[str]]:
    """Remove MMD twist bones."""
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting MMD twist bone removal for: {armature.name}")
    
    messages = []
    removed_count = 0
    reparented_count = 0
    
    # Store the current mode
    current_mode = bpy.context.mode
    if current_mode != 'EDIT':
        bpy.context.view_layer.objects.active = armature
        bpy.ops.object.mode_set(mode='EDIT')
    
    try:
        edit_bones = armature.data.edit_bones
        bones_to_remove = []
        
        # Patterns to identify twist bones - be specific about twist markers
        twist_patterns = [
            r'.*_[tT]wist$',  # Ends with _twist or _Twist
            r'^[tT]wist_',  # Starts with twist_ or Twist_
            r'.*\.[tT]wist$',  # Ends with .twist or .Twist
            r'^[tT]wist\.',  # Starts with twist. or Twist.
            r'.*[tT]wist$',  # Ends with Twist (no underscore/dot required)
            r'.*捩.*',  # Contains Japanese twist character
        ]
        
        # Compile patterns
        compiled_patterns = [re.compile(pattern) for pattern in twist_patterns]
        
        # Protected bone name patterns (never remove these)
        protected_patterns = [
            r'.*[bB]reast.*',  # Breast bones
            r'.*[bB]ust.*',  # Bust bones
            r'.*[sS]kirt.*',  # Skirt bones
            r'.*[hH]air.*',  # Hair bones
            r'.*[bB]ag.*',  # Bag/accessory bones
            r'.*[rR]ibbon.*',  # Ribbon bones
            r'.*[tT]ail.*',  # Tail bones
            r'.*[wW]ing.*',  # Wing bones
            r'.*[eE]ar.*',  # Ear bones
            r'.*[sS]leeve.*',  # Sleeve bones
            r'.*[cC]ape.*',  # Cape bones
            r'.*[sS]carf.*',  # Scarf bones
            r'.*[cC]oat.*',  # Coat bones
            r'.*[dD]ress.*',  # Dress bones
        ]
        compiled_protected = [re.compile(pattern) for pattern in protected_patterns]
        
        # Identify twist bones (but exclude protected bones)
        for bone in edit_bones:
            bone_name = bone.name
            
            # Check if bone is protected
            is_protected = any(pattern.match(bone_name) for pattern in compiled_protected)
            if is_protected:
                continue
            
            # Check if it's a twist bone
            for pattern in compiled_patterns:
                if pattern.match(bone_name):
                    bones_to_remove.append(bone_name)
                    logger.debug(f"Twist bone identified: {bone_name}")
                    break
        
        # Reparent children before removing
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                bone = edit_bones[bone_name]
                parent_bone = bone.parent
                for child in bone.children:
                    child.parent = parent_bone
                    reparented_count += 1
                    logger.debug(f"Reparented {child.name} from {bone_name} to {parent_bone.name if parent_bone else 'None'}")
        
        # Remove twist bones
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                edit_bones.remove(edit_bones[bone_name])
                removed_count += 1
                logger.info(f"Removed twist bone: {bone_name}")
        
    except Exception as e:
        logger.error(f"Error during twist bone removal: {e}", exc_info=True)
        messages.append(t("MMD.twist_removal_failed", error=str(e)))
        return False, messages
    
    finally:
        # Restore original mode
        if current_mode != 'EDIT':
            bpy.ops.object.mode_set(mode='OBJECT')
    
    # Generate messages
    if removed_count > 0:
        messages.append(t("MMD.twist_bones_removed", count=removed_count))
    else:
        messages.append(t("MMD.no_twist_bones_found"))
    
    if reparented_count > 0:
        messages.append(t("MMD.bones_reparented", count=reparented_count))
    
    logger.info(f"Twist bone removal complete: {removed_count} removed, {reparented_count} reparented")
    
    return True, messages


def remove_mmd_zero_weight_bones(armature: Object) -> Tuple[bool, List[str]]:
    """
    Remove bones with zero or near-zero vertex weights.
    Protects main skeleton bones from removal.
    """
    if not armature or armature.type != 'ARMATURE':
        return False, [t("MMD.error.invalid_armature")]
    
    logger.info(f"Starting zero weight bone removal for: {armature.name}")
    
    messages = []
    removed_count = 0
    reparented_count = 0
    
    # Store the current mode
    current_mode = bpy.context.mode
    
    try:
        # Switch to object mode to check weights
        if bpy.context.mode != 'OBJECT':
            bpy.context.view_layer.objects.active = armature
            bpy.ops.object.mode_set(mode='OBJECT')
        
        # Get all meshes using this armature
        meshes = [obj for obj in bpy.data.objects 
                 if obj.type == 'MESH' and obj.parent == armature]
        
        # Track bones with weights
        bones_with_weights = set()
        
        for mesh in meshes:
            for vertex_group in mesh.vertex_groups:
                # Check if any vertices have non-zero weights
                has_weight = False
                for vert in mesh.data.vertices:
                    try:
                        weight = vertex_group.weight(vert.index)
                        if weight > 0.001:  # Threshold for "zero" weight
                            has_weight = True
                            break
                    except:
                        continue
                
                if has_weight:
                    bones_with_weights.add(vertex_group.name)
        
        # Switch to edit mode
        bpy.ops.object.mode_set(mode='EDIT')
        edit_bones = armature.data.edit_bones
        
        # Protected bone names (main skeleton)
        protected_bones = {
            "Hips", "Spine", "Chest", "UpperChest", "Neck", "Head",
            "Left shoulder", "Right shoulder", "Shoulder_L", "Shoulder_R",
            "Left arm", "Right arm", "UpperArm_L", "UpperArm_R",
            "Left elbow", "Right elbow", "LowerArm_L", "LowerArm_R",
            "Left wrist", "Right wrist", "Hand_L", "Hand_R",
            "Left leg", "Right leg", "UpperLeg_L", "UpperLeg_R",
            "Left knee", "Right knee", "LowerLeg_L", "LowerLeg_R",
            "Left ankle", "Right ankle", "Foot_L", "Foot_R",
            "Left toe", "Right toe", "Toe_L", "Toe_R",
            "Left eye", "Right eye", "Eye_L", "Eye_R"
        }
        
        # Protected bone name patterns (never remove these even with zero weights)
        protected_patterns = [
            r'.*[bB]reast.*',  # Breast bones
            r'.*[bB]ust.*',  # Bust bones
            r'.*[sS]kirt.*',  # Skirt bones
            r'.*[hH]air.*',  # Hair bones
            r'.*[bB]ag.*',  # Bag/accessory bones
            r'.*[rR]ibbon.*',  # Ribbon bones
            r'.*[tT]ail.*',  # Tail bones
            r'.*[wW]ing.*',  # Wing bones
            r'.*[eE]ar.*',  # Ear bones (not Eye)
            r'.*[sS]leeve.*',  # Sleeve bones
            r'.*[cC]ape.*',  # Cape bones
            r'.*[sS]carf.*',  # Scarf bones
            r'.*[cC]oat.*',  # Coat bones
            r'.*[dD]ress.*',  # Dress bones
            r'.*[fF]inger.*',  # Finger bones
            r'.*[tT]humb.*',  # Thumb bones
            r'.*[iI]ndex.*',  # Index finger bones
            r'.*[mM]iddle.*',  # Middle finger bones
            r'.*[rR]ing.*',  # Ring finger bones
            r'.*[pP]ink.*',  # Pinky bones
            r'.*[tT]oe.*',  # Toe bones
            r'.*[aA]ccessor.*',  # Accessory bones
            r'.*[jJ]oint.*',  # Joint bones
            r'.*[cC]loth.*',  # Cloth bones
            r'.*[pP]hys.*',  # Physics bones
        ]
        compiled_protected = [re.compile(pattern) for pattern in protected_patterns]
        
        # Identify zero weight bones (but exclude protected bones)
        bones_to_remove = []
        for bone in edit_bones:
            # Skip if bone has weights
            if bone.name in bones_with_weights:
                continue
            
            # Skip if in protected set
            if bone.name in protected_bones:
                continue
            
            # Skip if matches protected pattern
            is_protected = any(pattern.match(bone.name) for pattern in compiled_protected)
            if is_protected:
                logger.debug(f"Protected bone (zero weight but keeping): {bone.name}")
                continue
            
            bones_to_remove.append(bone.name)
            logger.debug(f"Zero weight bone identified: {bone.name}")
        
        # Reparent children before removing
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                bone = edit_bones[bone_name]
                parent_bone = bone.parent
                for child in bone.children:
                    child.parent = parent_bone
                    reparented_count += 1
                    logger.debug(f"Reparented {child.name} from {bone_name} to {parent_bone.name if parent_bone else 'None'}")
        
        # Remove zero weight bones
        for bone_name in bones_to_remove:
            if bone_name in edit_bones:
                edit_bones.remove(edit_bones[bone_name])
                removed_count += 1
                logger.info(f"Removed zero weight bone: {bone_name}")
        
    except Exception as e:
        logger.error(f"Error during zero weight bone removal: {e}", exc_info=True)
        messages.append(t("MMD.zero_weight_removal_failed", error=str(e)))
        return False, messages
    
    finally:
        # Restore original mode
        if current_mode != 'OBJECT':
            bpy.ops.object.mode_set(mode='OBJECT')
    
    # Generate messages
    if removed_count > 0:
        messages.append(t("MMD.zero_weight_bones_removed", count=removed_count))
    else:
        messages.append(t("MMD.no_zero_weight_bones_found"))
    
    if reparented_count > 0:
        messages.append(t("MMD.bones_reparented", count=reparented_count))
    
    logger.info(f"Zero weight bone removal complete: {removed_count} removed, {reparented_count} reparented")
    
    return True, messages