import traceback
import bpy
import numpy as np
import threading
import time
import webbrowser
import typing
import struct
from io import BytesIO
import numpy.typing as npt

from typing import Optional, Tuple, List, Set, Dict, Any, Generator, Callable, Union, Type
from mathutils import Vector, Matrix
from bpy.types import (Context, Object, Modifier, EditBone, Operator, Material,
                      VertexGroup, ShapeKey, Bone, Mesh, Armature, PropertyGroup)
from functools import lru_cache
from bpy.props import PointerProperty, IntProperty, StringProperty
from bpy.utils import register_class
from ..core.logging_setup import logger
from ..core.translations import t
from ..core.dictionaries import bone_names
from .dictionaries import reverse_bone_lookup, bone_names, simplify_bonename

class SceneMatClass(PropertyGroup):
    mat: PointerProperty(type=Material)

register_class(SceneMatClass)

class MaterialListBool:
    #For the love that is holy do not ever touch these. If this was java I would make these private
    #They should only be accessed via context.scene.texture_atlas_Has_Mat_List_Shown
    #This is so we know if the materials are up to date. messing with these variables directly will make the thing blow up.
    #The only exception to this is the ExpandSection_Materials operator which populates this with new data once the materials have changed and need reloading.
    old_list: dict[str,list[Material]] = {}
    bool_material_list_expand: dict[str,bool] = {}

    def set_bool(self, value: bool) -> None:
        MaterialListBool.bool_material_list_expand[bpy.context.scene.name] = value
        if value == False:
            MaterialListBool.old_list[bpy.context.scene.name] = []

    def get_bool(self) -> bool:
            newlist: list[Material] = []
            for obj in bpy.context.scene.objects:
                if len(obj.material_slots)>0:
                    for mat_slot in obj.material_slots:
                        if mat_slot.material:
                            if mat_slot.material not in newlist:
                                newlist.append(mat_slot.material)
            still_the_same: bool = True
            if bpy.context.scene.name in MaterialListBool.old_list:
                for item in newlist:
                    if item not in MaterialListBool.old_list[bpy.context.scene.name]:
                        still_the_same = False
                        break
                for item in MaterialListBool.old_list[bpy.context.scene.name]:
                    if item not in newlist:
                        still_the_same = False
                        break
            else:
                still_the_same = False
            MaterialListBool.bool_material_list_expand[bpy.context.scene.name] = still_the_same
            return MaterialListBool.bool_material_list_expand[bpy.context.scene.name]

class ProgressTracker:
    """Universal progress tracking for Avatar Toolkit operations"""
    
    def __init__(self, context: Context, total_steps: int, operation_name: str = "Operation") -> None:
        self.context: Context = context
        self.total: int = total_steps
        self.current: int = 0
        self.operation_name: str = operation_name
        self.wm = context.window_manager
        
    def step(self, message: str = "") -> None:
        """Update progress by one step"""
        self.current += 1
        progress = self.current / self.total
        self.wm.progress_begin(0, 100)
        self.wm.progress_update(progress * 100)
        logger.debug(f"{self.operation_name} - {progress:.1%}: {message}")
        
    def __enter__(self) -> 'ProgressTracker':
        logger.info(f"Starting {self.operation_name}")
        return self
        
    def __exit__(self, exc_type: Optional[Type[BaseException]], 
                 exc_val: Optional[BaseException], 
                 exc_tb: Optional[Any]) -> None:
        self.wm.progress_end()
        logger.info(f"Completed {self.operation_name}")

def get_active_armature(context: Context) -> Optional[Object]:
    """Get the currently selected armature from Avatar Toolkit properties"""
    armature_name = str(context.scene.avatar_toolkit.active_armature)
    if armature_name and armature_name != 'NONE':
        return bpy.data.objects.get(armature_name)
    return None

def set_active_armature(context: Context, armature: Object) -> None:
    """Set the active armature for Avatar Toolkit operations"""
    context.scene.avatar_toolkit.active_armature = armature

def get_armature_list(self: Optional[Any] = None, context: Optional[Context] = None) -> List[Tuple[str, str, str]]:
    """Get list of all armature objects in the scene"""
    if context is None:
        context = bpy.context
    armatures = [(obj.name, obj.name, "") for obj in context.scene.objects if obj.type == 'ARMATURE']
    if not armatures:
        return [('NONE', t("Armature.validation.no_armature"), '')]
    return armatures
  
def auto_select_single_armature(context: Context) -> None:
    """Automatically select armature if only one exists in scene"""
    armatures: List[Tuple[str, str, str]] = get_armature_list(context)
    if len(armatures) == 1 and armatures[0][0] != 'NONE':
        toolkit = context.scene.avatar_toolkit
        set_active_armature(context, armatures[0])

def clear_default_objects() -> None:
    """Removes default Blender objects"""
    default_names: Set[str] = {'Cube', 'Light', 'Camera'}
    for obj in bpy.data.objects:
        if obj.name.split('.')[0] in default_names:
            bpy.data.objects.remove(obj, do_unlink=True)

def get_armature_stats(armature: Object) -> Dict[str, Union[int, bool, str]]:
    """Get statistics about the armature"""
    return {
        'bone_count': len(armature.data.bones),
        'has_pose': bool(armature.pose),
        'visible': not armature.hide_viewport,
        'name': armature.name
    }

def get_all_meshes(context: Context) -> List[Object]:
    """Get all mesh objects parented to the active armature"""
    armature: Optional[Object] = get_active_armature(context)
    if armature:
        return [obj for obj in bpy.data.objects if obj.type == 'MESH' and obj.parent == armature]
    return []

def get_meshes_for_armature(armature: Object) -> List[Object]:
    """Get all mesh objects parented to a specific armature"""
    if armature and armature.type == 'ARMATURE':
        return [obj for obj in bpy.data.objects if obj.type == 'MESH' and obj.parent == armature]
    return []

def validate_mesh_for_pose(mesh_obj: Object) -> Tuple[bool, str]:
    """Validate mesh object for pose operations"""
    if not mesh_obj.data:
        return False, t("Mesh.validation.no_data")
        
    if not mesh_obj.vertex_groups:
        return False, t("Mesh.validation.no_vertex_groups")
        
    armature_mods: List[Modifier] = [mod for mod in mesh_obj.modifiers if mod.type == 'ARMATURE']
    if not armature_mods:
        return False, t("Mesh.validation.no_armature_modifier")
    
    return True, t("Mesh.validation.valid")

def cache_vertex_positions(mesh_obj: Object) -> npt.NDArray[np.float32]:
    """Cache vertex positions for a mesh object"""
    vertices = mesh_obj.data.vertices
    positions: npt.NDArray[np.float32] = np.empty(len(vertices) * 3, dtype=np.float32)
    vertices.foreach_get('co', positions)
    return positions.reshape(-1, 3)

def apply_vertex_positions(vertices: Object, positions: npt.NDArray[np.float32]) -> None:
    """Apply cached vertex positions to mesh in batch"""
    vertices.foreach_set('co', positions.flatten())

def process_armature_modifiers(mesh_obj: Object) -> List[Dict[str, Any]]:
    """Process and store armature modifier states"""
    modifier_states: List[Dict[str, Any]] = []
    for mod in mesh_obj.modifiers:
        if mod.type == 'ARMATURE':
            modifier_states.append({
                'name': mod.name,
                'object': mod.object,
                'vertex_group': mod.vertex_group,
                'show_viewport': mod.show_viewport
            })
    return modifier_states

def apply_pose_as_rest(context: Context, armature_obj: Object, meshes: List[Object]) -> Tuple[bool, str]:
    """Apply current pose as rest pose for armature and update meshes"""
    try:
        logger.info(f"Starting pose application for {len(meshes)} meshes")
        
        with ProgressTracker(context, len(meshes), "Applying Pose") as progress:
            for mesh_obj in meshes:
                if not mesh_obj.data:
                    continue
                    
                if mesh_obj.data.shape_keys and mesh_obj.data.shape_keys.key_blocks:
                    apply_armature_to_mesh_with_shapekeys(armature_obj, mesh_obj, context)
                else:
                    apply_armature_to_mesh(armature_obj, mesh_obj)
                
                progress.step(f"Processed {mesh_obj.name}")
            
            bpy.ops.object.mode_set(mode='POSE')
            bpy.ops.pose.armature_apply(selected=False)
            bpy.ops.object.mode_set(mode='OBJECT')
            
            return True, t("Operation.pose_applied")
            
    except Exception:
        logger.error(f"Error applying pose as rest: {traceback.format_exc()}")
        return False, traceback.format_exc()
    
def apply_armature_to_mesh(armature_obj: Object, mesh_obj: Object) -> None:
    """Apply armature deformation to mesh"""
    armature_mod: Modifier = mesh_obj.modifiers.new('PoseToRest', 'ARMATURE')
    armature_mod.object = armature_obj
    
    if bpy.app.version >= (3, 5):
        mesh_obj.modifiers.move(mesh_obj.modifiers.find(armature_mod.name), 0)
    else:
        for _ in range(len(mesh_obj.modifiers) - 1):
            bpy.ops.object.modifier_move_up(modifier=armature_mod.name)
            
    with bpy.context.temp_override(object=mesh_obj):
        bpy.ops.object.modifier_apply(modifier=armature_mod.name)

def apply_armature_to_mesh_with_shapekeys(armature_obj: Object, mesh_obj: Object, context: Context) -> None:
    """Apply armature deformation to mesh with shape keys"""
    old_active_index: int = mesh_obj.active_shape_key_index
    old_show_only: bool = mesh_obj.show_only_shape_key
    mesh_obj.show_only_shape_key = True
    
    shape_keys: List[ShapeKey] = mesh_obj.data.shape_keys.key_blocks
    vertex_groups: List[str] = []
    mutes: List[bool] = []
    
    for sk in shape_keys:
        vertex_groups.append(sk.vertex_group)
        sk.vertex_group = ''
        mutes.append(sk.mute)
        sk.mute = False

    disabled_mods: List[Modifier] = []
    for mod in mesh_obj.modifiers:
        if mod.show_viewport:
            mod.show_viewport = False
            disabled_mods.append(mod)

    arm_mod: Modifier = mesh_obj.modifiers.new('PoseToRest', 'ARMATURE')
    arm_mod.object = armature_obj
    
    co_length: int = len(mesh_obj.data.vertices) * 3
    eval_cos: npt.NDArray[np.float32] = np.empty(co_length, dtype=np.single)
    
    for i, shape_key in enumerate(shape_keys):
        mesh_obj.active_shape_key_index = i
        
        depsgraph = context.evaluated_depsgraph_get()
        eval_mesh = mesh_obj.evaluated_get(depsgraph)
        eval_mesh.data.vertices.foreach_get('co', eval_cos)
        
        shape_key.data.foreach_set('co', eval_cos)
        if i == 0:
            mesh_obj.data.vertices.foreach_set('co', eval_cos)

    for mod in disabled_mods:
        mod.show_viewport = True
        
    mesh_obj.modifiers.remove(arm_mod)
    
    for sk, vg, mute in zip(shape_keys, vertex_groups, mutes):
        sk.vertex_group = vg
        sk.mute = mute
        
    mesh_obj.active_shape_key_index = old_active_index
    mesh_obj.show_only_shape_key = old_show_only

def validate_meshes(meshes: List[Object]) -> Tuple[bool, str]:
    """Validates a list of mesh objects to ensure they are suitable for joining operations"""
    if not meshes:
        return False, t("Optimization.no_meshes")
    if not all(mesh.data for mesh in meshes):
        return False, t("Optimization.invalid_mesh_data")
    if not all(mesh.type == 'MESH' for mesh in meshes):
        return False, t("Optimization.non_mesh_objects")
    return True, ""

def fast_uv_fix(obj: Object) -> None:
    """Fast UV coordinate fixing for joined meshes"""
    if not obj or not obj.data or not obj.data.uv_layers:
        return
        
    current_mode = bpy.context.mode
    
    if current_mode != 'EDIT_MESH':
        bpy.ops.object.mode_set(mode='EDIT')
        
    bpy.ops.mesh.select_all(action='SELECT')
    
    # Process all UV layers at once
    bpy.ops.uv.select_all(action='SELECT')
    bpy.ops.uv.pack_islands(margin=0.001)
    
    if current_mode != 'EDIT_MESH':
        bpy.ops.object.mode_set(mode=current_mode)

def join_mesh_objects(context: Context, meshes: List[Object], progress: Optional[ProgressTracker] = None) -> Optional[Object]:
    """Combines multiple mesh objects into a single mesh with optimized performance"""
    try:
        if not meshes:
            return None
            
        bpy.ops.object.mode_set(mode='OBJECT')
        bpy.ops.object.select_all(action='DESELECT')
        
        # Create a list of valid meshes
        valid_meshes = [mesh for mesh in meshes if mesh.name in bpy.data.objects]
        if not valid_meshes:
            return None
            
        for mesh in valid_meshes:
            mesh.select_set(True)
            mesh.hide_set(False)
        
        context.view_layer.objects.active = valid_meshes[0]
        
        if progress:
            progress.step(t("Optimization.joining_meshes"))
            
        bpy.ops.object.join()
        joined_mesh = context.active_object
        
        if progress:
            progress.step(t("Optimization.applying_transforms"))
            
        bpy.ops.object.transform_apply(location=True, rotation=True, scale=True)
        
        if progress:
            progress.step(t("Optimization.fixing_uvs"))
            
        fast_uv_fix(joined_mesh)
        
        return joined_mesh
            
    except Exception:
        logger.error(f"Failed to join meshes: {traceback.format_exc()}")
        return None


def fix_uv_coordinates(context: Context) -> None:
    """Normalizes and fixes UV coordinates for the active mesh object"""
    obj: Object = context.object
    current_mode: str = context.mode
    current_active: Object = context.view_layer.objects.active
    current_selected: List[Object] = context.selected_objects.copy()

    try:
        bpy.ops.object.mode_set(mode='OBJECT')
        obj.select_set(True)
        context.view_layer.objects.active = obj
        
        # Process each UV layer
        for uv_layer in obj.data.uv_layers:
            obj.data.uv_layers.active = uv_layer
            bpy.ops.object.mode_set(mode='EDIT')
            bpy.ops.mesh.select_all(action='SELECT')
            
            with context.temp_override(active_object=obj):
                bpy.ops.uv.select_all(action='SELECT')
                bpy.ops.uv.pack_islands(margin=0.001)
                bpy.ops.uv.average_islands_scale()
            
        logger.debug(f"UV Fix - Successfully processed {obj.name}")

    except Exception:
        logger.warning(f"UV Fix - Skipped processing for {obj.name}: {traceback.format_exc()}")

    finally:
        bpy.ops.object.mode_set(mode='OBJECT')
        for sel_obj in current_selected:
            sel_obj.select_set(True)
        context.view_layer.objects.active = current_active

def clear_unused_data_blocks() -> int:
    """Removes all unused data blocks from the current Blender file"""
    initial_count: int = sum(len(getattr(bpy.data, attr)) for attr in dir(bpy.data)
                        if isinstance(getattr(bpy.data, attr), bpy.types.bpy_prop_collection))
    bpy.ops.outliner.orphans_purge(do_local_ids=True, do_linked_ids=True, do_recursive=True)
    final_count: int = sum(len(getattr(bpy.data, attr)) for attr in dir(bpy.data)
                      if isinstance(getattr(bpy.data, attr), bpy.types.bpy_prop_collection))
    return initial_count - final_count

def identify_bones(arm_data: bpy.types.Armature) -> Dict[str,str]:
    """Identify bone names in an armature based on our reverse dictionary, so there is no confusion to what a bone is.
    Essentially makes a dictionary of keys from dictionaries.bone_names like "hips", and the corosponding value is the bone that can be mapped to that key."""
    returned: Dict[str,str] = {}
    for bone in arm_data.bones:
        
        simplified_name = simplify_bonename(bone.name)

        if simplified_name in reverse_bone_lookup:
            returned[reverse_bone_lookup[simplified_name]] = bone.name
    return returned

def duplicate_bone_chain(bones: List[EditBone]) -> List[EditBone]:
    """Duplicate a chain of bones while preserving hierarchy"""
    new_bones: List[EditBone] = []
    parent_map: Dict[EditBone, EditBone] = {}
    
    for bone in bones:
        new_bone = duplicate_bone(bone)
        if bone.parent and bone.parent in parent_map:
            new_bone.parent = parent_map[bone.parent]
        parent_map[bone] = new_bone
        new_bones.append(new_bone)
        
    return new_bones

def restore_bone_transforms(bone: EditBone, transforms: Dict[str, Any]) -> None:
    """Restore bone transforms from stored data"""
    bone.head = transforms['head']
    bone.tail = transforms['tail'] 
    bone.roll = transforms['roll']
    bone.matrix = transforms['matrix']

def get_vertex_weights(mesh_obj: Object, group_name: str) -> Dict[int, float]:
    """Get vertex weights for a specific vertex group"""
    weights: Dict[int, float] = {}
    group_index: int = mesh_obj.vertex_groups[group_name].index
    for vertex in mesh_obj.data.vertices:
        for group in vertex.groups:
            if group.group == group_index:
                weights[vertex.index] = group.weight
    return weights

def transfer_vertex_weights(mesh_obj: Object, source_name: str, target_name: str, threshold: float = 0.01) -> None:
    """Transfer vertex weights from source to target group"""
    if source_name not in mesh_obj.vertex_groups:
        return
        
    source_group: VertexGroup = mesh_obj.vertex_groups[source_name]
    target_group: Optional[VertexGroup] = mesh_obj.vertex_groups.get(target_name)
    
    if not target_group:
        target_group = mesh_obj.vertex_groups.new(name=target_name)
    
    weights: Dict[int, float] = get_vertex_weights(mesh_obj, source_name)
    
    for vertex_index, weight in weights.items():
        if weight > threshold:
            target_group.add([vertex_index], weight, 'ADD')
            
    mesh_obj.vertex_groups.remove(source_group)

def remove_unused_shapekeys(mesh_obj: Object, tolerance: float = 0.001) -> int:
    """Remove unused shape keys from a mesh object"""
    if not mesh_obj.data.shape_keys:
        return 0
        
    key_blocks: List[ShapeKey] = mesh_obj.data.shape_keys.key_blocks
    vertex_count: int = len(mesh_obj.data.vertices)
    removed_count: int = 0
    
    cache: Dict[str, npt.NDArray[np.float32]] = {}
    locations: npt.NDArray[np.float32] = np.empty(3 * vertex_count, dtype=np.float32)
    to_delete: List[str] = []
    
    for key in key_blocks:
        if key == key.relative_key:
            continue
            
        key.data.foreach_get("co", locations)
        
        if key.relative_key.name not in cache:
            rel_locations: npt.NDArray[np.float32] = np.empty(3 * vertex_count, dtype=np.float32)
            key.relative_key.data.foreach_get("co", rel_locations)
            cache[key.relative_key.name] = rel_locations
            
        locations -= cache[key.relative_key.name]
        if (np.abs(locations) < tolerance).all():
            if not any(c in key.name for c in "-=~"):
                to_delete.append(key.name)
                
    for key_name in to_delete:
        mesh_obj.shape_key_remove(key_blocks[key_name])
        removed_count += 1
        
    return removed_count

def has_shapekeys(mesh_obj: Object) -> bool:
    """Check if mesh object has shape keys"""
    return mesh_obj.data.shape_keys is not None

def fix_zero_length_bones(armature: Object) -> None:
    """Fix zero length bones by setting a minimum length"""
    if not armature:
        return
    bpy.ops.object.mode_set(mode='EDIT')
    for bone in armature.data.edit_bones:
        if bone.length < 0.001:
            bone.length = 0.001
    bpy.ops.object.mode_set(mode='OBJECT')

def remove_unused_vertex_groups(mesh: Object) -> int:
    """Remove vertex groups with no weights"""
    removed: int = 0
    for vg in mesh.vertex_groups:
        has_weights: bool = False
        for vert in mesh.data.vertices:
            for group in vert.groups:
                if group.group == vg.index and group.weight > 0.001:
                    has_weights = True
                    break
            if has_weights:
                break
        if not has_weights:
            mesh.vertex_groups.remove(vg)
            removed = removed+1

    return removed

def calculate_bone_orientation(mesh: Object, vertices: List[Any]) -> Tuple[Vector, float]:
    """Calculate optimal bone orientation based on mesh geometry"""
    if not vertices:
        return Vector((0, 0, 0.1)), 0.0
        
    coords: List[Vector] = [mesh.data.vertices[v.index].co for v in vertices]
    min_co: Vector = Vector(map(min, zip(*coords)))
    max_co: Vector = Vector(map(max, zip(*coords)))
    dimensions: Vector = max_co - min_co
    
    roll_angle: float = 0.0
    
    return dimensions, roll_angle

def add_armature_modifier(mesh: Object, armature: Object) -> None:
    """Add armature modifier to mesh"""
    for mod in mesh.modifiers:
        if mod.type == 'ARMATURE':
            mesh.modifiers.remove(mod)

    modifier: Modifier = mesh.modifiers.new('Armature', 'ARMATURE')
    modifier.object = armature

def get_modifiers(self: Optional[Any] = None, context: Optional[Context] = None) -> List[Tuple[str, str, str]]:
    returned: List[Tuple[str, str, str]] = []
    if context.active_object == None:
        return returned
    if context.active_object.type != "MESH":
        return returned
    for mod in context.active_object.modifiers:
        returned.append((mod.name,mod.name,""))

    return returned


def get_shapekeys(context: Context, 
                  names: List[str], 
                  is_mouth: bool, 
                  no_basis: bool, 
                  return_list: bool) -> Union[List[Tuple[str, str, str]], List[str]]:
    """Get shape keys based on specified criteria"""
    choices: List[Tuple[str, str, str]] = []
    choices_simple: List[str] = []
    meshes_list: List[Object] = get_meshes_objects(check=False)

    if meshes_list:
        if is_mouth:
            meshes = [get_objects().get(context.scene.mesh_name_viseme)]
        else:
            meshes = [get_objects().get(context.scene.mesh_name_eye)]
    else:
        return choices

    for mesh in meshes:
        if not mesh or not has_shapekeys(mesh):
            return choices

        for shapekey in mesh.data.shape_keys.key_blocks:
            name = shapekey.name
            if name in choices_simple:
                continue
            if no_basis and name == 'Basis':
                continue
            choices.append((name, name, name))
            choices_simple.append(name)

    _sort_enum_choices_by_identifier_lower(choices)

    choices2: List[Tuple[str, str, str]] = []
    for name in names:
        if name in choices_simple and len(choices) > 1 and choices[0][0] != name:
            continue
        choices2.append((name, name, name))

    choices2.extend(choices)

    if return_list:
        shape_list: List[str] = []
        for choice in choices2:
            shape_list.append(choice[0])
        return shape_list

    return choices2

def _sort_enum_choices_by_identifier_lower(choices: List[Tuple[str, str, str]], in_place: bool = True) -> List[Tuple[str, str, str]]:
    """Sort a list of enum choices by the lowercase of their identifier"""
    def identifier_lower(choice: Tuple[str, str, str]) -> str:
        return choice[0].lower()

    if in_place:
        choices.sort(key=identifier_lower)
    else:
        choices = sorted(choices, key=identifier_lower)
    return choices

def is_enum_empty(string: str) -> bool:
    """Returns True only if the tested string is the empty enum identifier"""
    return _empty_enum_identifier == string

def is_enum_non_empty(string: str) -> bool:
    """Returns False only if the tested string is not the empty enum identifier"""
    return _empty_enum_identifier != string

_empty_enum_identifier: str = 'Cats_empty_enum_identifier'

def get_meshes_objects(check: bool = True) -> List[Object]:
    """Get all mesh objects in the scene"""
    meshes: List[Object] = [obj for obj in bpy.data.objects if obj.type == 'MESH']
    if check and not meshes:
        return []
    return meshes

def get_objects() -> bpy.types.BlendData:
    """Get all objects in the current Blender scene"""
    return bpy.data.objects

def duplicate_bone(bone: EditBone) -> EditBone:
    """Create a duplicate of the given bone"""

    new_bone: EditBone = bone.id_data.edit_bones.new(bone.name + "_copy")
    new_bone.head = bone.head.copy()
    new_bone.tail = bone.tail.copy()
    new_bone.roll = bone.roll
    new_bone.use_connect = bone.use_connect
    new_bone.use_local_location = bone.use_local_location
    new_bone.use_inherit_rotation = bone.use_inherit_rotation
    new_bone.use_deform = bone.use_deform
    return new_bone



class ArmatureData(Tuple[bool,bool]):
    pass

def store_breaking_settings_armature(armature: bpy.types.Object) -> ArmatureData:
    armature_data: bpy.types.Armature = armature.data
    data: ArmatureData = (armature_data.use_mirror_x, armature.pose.use_mirror_x)
    armature_data.use_mirror_x, armature.pose.use_mirror_x = (False, False)
    return data

def restore_breaking_settings_armature(armature: bpy.types.Object, data: ArmatureData) -> None:
    # Check if armature object is still valid (not removed)
    if not armature or armature.name not in bpy.data.objects:
        return
    armature_data: bpy.types.Armature = armature.data
    armature_data.use_mirror_x, armature.pose.use_mirror_x = data




