blenderpython/suw_core/data_manager.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
SUW Core - Data Manager Module
数据管理中心 - 统一管理所有共用数据
用途: 替代Ruby中的@zones、@parts、@hardwares等全局变量
版本: 1.0.0
作者: SUWood Team
"""

import logging
import threading
from typing import Dict, Any, Optional, List

# 设置日志
logger = logging.getLogger(__name__)

# 检查Blender可用性
try:
    import bpy
    BLENDER_AVAILABLE = True
except ImportError:
    BLENDER_AVAILABLE = False

# ==================== 数据管理器类 ====================


class DataManager:
    """数据管理器 - 统一管理所有SUWood数据"""

    def __init__(self):
        """初始化数据管理器"""
        # 核心数据存储 - 对应Ruby的实例变量
        self.zones = {}       # @zones - {uid: {zone_id: zone_data}}
        self.parts = {}       # @parts - {uid: {part_id: part_data}}
        self.hardwares = {}   # @hardwares - {uid: {hw_id: hw_data}}
        self.labels = {}      # @labels - {uid: {label_id: label_data}}
        self.door_labels = {}  # @door_labels - {uid: {door_label_id: door_label_data}}
        self.machinings = {}  # @machinings - {uid: [machining_list]}
        self.dimensions = {}  # @dimensions - {uid: [dimension_list]}

        # 单元参数 - 对应Ruby的@unit_param和@unit_trans
        self.unit_params = {}  # @unit_param - {uid: params}
        self.unit_trans = {}  # @unit_trans - {uid: transformation}

        # 材质和纹理 - 对应Ruby的@textures
        self.textures = {}    # @textures - {ckey: material}

        # 系统状态
        self.part_mode = False    # @part_mode
        self.hide_none = False    # @hide_none
        self.mat_type = 0         # @mat_type (MAT_TYPE_NORMAL)
        self.back_material = False  # @back_material
        self.added_contour = False  # @added_contour

        # 选择状态 - 对应Ruby的类变量
        self.selected_uid = None   # @@selected_uid
        self.selected_obj = None   # @@selected_obj
        self.selected_zone = None  # @@selected_zone
        self.selected_part = None  # @@selected_part
        self.scaled_zone = None    # @@scaled_zone

        # 选择集合
        self.selected_faces = []   # @selected_faces
        self.selected_parts = []   # @selected_parts
        self.selected_hws = []     # @selected_hws

        # Blender对象引用
        self.labels_group = None      # @labels - Blender组对象
        self.door_labels_group = None  # @door_labels - Blender组对象
        self.door_layer = None        # @door_layer
        self.drawer_layer = None      # @drawer_layer
        self.default_zone = None      # @@default_zone

        # 线程安全
        self.lock = threading.Lock()

        logger.info("✅ 数据管理器初始化完成")

    # ==================== Zones 数据管理 ====================

    def get_zones(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """获取区域数据 - 对应Ruby的get_zones方法"""
        uid = data.get("uid")
        if not uid:
            return {}

        with self.lock:
            if uid not in self.zones:
                self.zones[uid] = {}
            return self.zones[uid]

    def add_zone(self, uid: str, zid: Any, zone_obj: Any):
        """添加区域"""
        with self.lock:
            if uid not in self.zones:
                self.zones[uid] = {}
            self.zones[uid][zid] = zone_obj
            logger.debug(f"添加区域: uid={uid}, zid={zid}")

    def remove_zone(self, uid: str, zid: Any) -> bool:
        """删除区域"""
        with self.lock:
            if uid in self.zones and zid in self.zones[uid]:
                del self.zones[uid][zid]
                logger.debug(f"删除区域: uid={uid}, zid={zid}")
                return True
            return False

    def clear_zones(self, uid: str):
        """清空指定uid的所有区域"""
        with self.lock:
            if uid in self.zones:
                del self.zones[uid]
                logger.debug(f"清空区域: uid={uid}")

    # ==================== Parts 数据管理 ====================

    def get_parts(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """获取部件数据 - 对应Ruby的get_parts方法"""
        uid = data.get("uid")
        if not uid:
            return {}

        with self.lock:
            if uid not in self.parts:
                self.parts[uid] = {}
            return self.parts[uid]

    def add_part(self, uid: str, part_id: Any, part_obj: Any):
        """添加部件"""
        with self.lock:
            if uid not in self.parts:
                self.parts[uid] = {}
            self.parts[uid][part_id] = part_obj
            logger.debug(f"添加部件: uid={uid}, part_id={part_id}")

    def remove_part(self, uid: str, part_id: Any) -> bool:
        """删除部件"""
        with self.lock:
            if uid in self.parts and part_id in self.parts[uid]:
                del self.parts[uid][part_id]
                logger.debug(f"删除部件: uid={uid}, part_id={part_id}")
                return True
            return False

    def clear_parts(self, uid: str):
        """清空指定uid的所有部件"""
        with self.lock:
            if uid in self.parts:
                del self.parts[uid]
                logger.debug(f"清空部件: uid={uid}")

    # ==================== Hardwares 数据管理 ====================

    def get_hardwares(self, data: Dict[str, Any]) -> Dict[str, Any]:
        """获取硬件数据 - 对应Ruby的get_hardwares方法"""
        uid = data.get("uid")
        if not uid:
            return {}

        with self.lock:
            if uid not in self.hardwares:
                self.hardwares[uid] = {}
            return self.hardwares[uid]

    def add_hardware(self, uid: str, hw_id: Any, hw_obj: Any):
        """添加硬件"""
        with self.lock:
            if uid not in self.hardwares:
                self.hardwares[uid] = {}
            self.hardwares[uid][hw_id] = hw_obj
            logger.debug(f"添加硬件: uid={uid}, hw_id={hw_id}")

    def remove_hardware(self, uid: str, hw_id: Any) -> bool:
        """删除硬件"""
        with self.lock:
            if uid in self.hardwares and hw_id in self.hardwares[uid]:
                del self.hardwares[uid][hw_id]
                logger.debug(f"删除硬件: uid={uid}, hw_id={hw_id}")
                return True
            return False

    def clear_hardwares(self, uid: str):
        """清空指定uid的所有硬件"""
        with self.lock:
            if uid in self.hardwares:
                del self.hardwares[uid]
                logger.debug(f"清空硬件: uid={uid}")

    # ==================== Labels 数据管理 ====================

    def get_labels(self, uid: str) -> Dict[str, Any]:
        """获取标签数据"""
        with self.lock:
            if uid not in self.labels:
                self.labels[uid] = {}
            return self.labels[uid]

    def get_door_labels(self, uid: str) -> Dict[str, Any]:
        """获取门标签数据"""
        with self.lock:
            if uid not in self.door_labels:
                self.door_labels[uid] = {}
            return self.door_labels[uid]

    # ==================== Machinings 数据管理 ====================

    def get_machinings(self, uid: str) -> List[Any]:
        """获取加工数据"""
        with self.lock:
            if uid not in self.machinings:
                self.machinings[uid] = []
            return self.machinings[uid]

    def add_machining(self, uid: str, machining_obj: Any):
        """添加加工"""
        with self.lock:
            if uid not in self.machinings:
                self.machinings[uid] = []
            self.machinings[uid].append(machining_obj)
            logger.debug(f"添加加工: uid={uid}")

    def clear_machinings(self, uid: str):
        """清空指定uid的所有加工"""
        with self.lock:
            if uid in self.machinings:
                self.machinings[uid].clear()
                logger.debug(f"清空加工: uid={uid}")

    def cleanup_machinings(self, uid: str):
        """清理指定uid的已删除加工对象"""
        with self.lock:
            if uid in self.machinings:
                # 移除已删除的对象
                self.machinings[uid] = [
                    machining for machining in self.machinings[uid]
                    if machining and self._is_entity_valid(machining)
                ]
                logger.debug(
                    f"清理加工: uid={uid}, 剩余 {len(self.machinings[uid])} 个对象")

    # ==================== Dimensions 数据管理 ====================

    def get_dimensions(self, uid: str) -> List[Any]:
        """获取尺寸标注数据"""
        with self.lock:
            if uid not in self.dimensions:
                self.dimensions[uid] = []
            return self.dimensions[uid]

    def add_dimension(self, uid: str, dimension_obj: Any):
        """添加尺寸标注"""
        with self.lock:
            if uid not in self.dimensions:
                self.dimensions[uid] = []
            self.dimensions[uid].append(dimension_obj)
            logger.debug(f"添加尺寸标注: uid={uid}")

    def clear_dimensions(self, uid: str):
        """清空指定uid的所有尺寸标注"""
        with self.lock:
            if uid in self.dimensions:
                del self.dimensions[uid]
                logger.debug(f"清空尺寸标注: uid={uid}")

    # ==================== 材质管理 ====================

    def get_texture(self, key: str) -> Any:
        """获取材质 - 对应Ruby的get_texture方法"""
        if key and key in self.textures:
            return self.textures[key]
        return self.textures.get("mat_default")

    def add_texture(self, key: str, material: Any):
        """添加材质"""
        with self.lock:
            self.textures[key] = material
            logger.debug(f"添加材质: key={key}")

    # ==================== 选择管理 ====================

    def sel_clear(self):
        """清除所有选择 - 对应Ruby的sel_clear方法"""
        with self.lock:
            self.selected_uid = None
            self.selected_obj = None
            self.selected_zone = None
            self.selected_part = None
            self.selected_faces.clear()
            self.selected_parts.clear()
            self.selected_hws.clear()
            logger.debug("清除所有选择")

    def set_selected(self, uid: str, obj: Any, zone: Any = None, part: Any = None):
        """设置选择状态"""
        with self.lock:
            self.selected_uid = uid
            self.selected_obj = obj
            if zone:
                self.selected_zone = zone
            if part:
                self.selected_part = part
            logger.debug(f"设置选择: uid={uid}, obj={obj}")

    # ==================== 删除实体的核心实现 ====================

    def del_entities_by_type(self, entities: Dict[str, Any], typ: str, oid: int) -> int:
        """按类型删除实体 - 修复版本，确保删除所有相关对象"""
        if not entities:
            return 0

        deleted_count = 0
        entities_to_delete = []

        # 【修复1】收集数据结构中需要删除的实体
        for key, entity in entities.items():
            if entity and self._is_entity_valid(entity):
                # 对应Ruby逻辑: typ == "uid" || entity.get_attribute("sw", typ) == oid
                if typ == "uid" or self._get_entity_attribute(entity, typ) == oid:
                    entities_to_delete.append(key)

        # 【修复2】删除数据结构中的实体
        for key in entities_to_delete:
            entity = entities[key]
            if self._delete_entity_safe(entity):
                del entities[key]
                deleted_count += 1

        # 【修复3】遍历Blender中的所有对象，查找并删除相关对象
        if BLENDER_AVAILABLE:
            blender_deleted_count = self._delete_blender_objects_by_type(
                typ, oid)
            deleted_count += blender_deleted_count
            logger.debug(
                f"从Blender中删除对象: typ={typ}, oid={oid}, 删除数量={blender_deleted_count}")

        logger.debug(f"按类型删除实体: typ={typ}, oid={oid}, 总删除数量={deleted_count}")
        return deleted_count

    def _matches_delete_condition(self, entity, typ: str, oid: int, uid: str = None) -> bool:
        """检查实体是否匹配删除条件 - 添加详细调试"""
        try:
            if not entity or not hasattr(entity, 'get'):
                return False

            # 【调试】打印实体的所有属性
            entity_uid = entity.get("sw_uid")
            entity_typ_value = entity.get(f"sw_{typ}")

            logger.debug(
                f"🔍 检查删除条件: {entity.name if hasattr(entity, 'name') else 'unknown'}")
            logger.debug(
                f"   实体属性: sw_uid={entity_uid}, sw_{typ}={entity_typ_value}")
            logger.debug(f"   删除条件: uid={uid}, typ={typ}, oid={oid}")

            # 【修复】正确的删除条件逻辑
            if typ == "uid":
                # 删除整个单元：检查sw_uid
                uid_matches = entity_uid == oid
                logger.debug(f"   uid删除匹配: {uid_matches}")
                return uid_matches
            else:
                # 删除特定类型：需要同时匹配uid和对应的类型属性
                uid_matches = uid is None or entity_uid == uid
                typ_matches = entity_typ_value == oid

                logger.debug(
                    f"   类型删除匹配: uid匹配={uid_matches}, {typ}匹配={typ_matches}")

                # 必须同时匹配uid和类型值
                return uid_matches and typ_matches

        except Exception as e:
            logger.error(f"检查删除条件时发生错误: {e}")
            return False

    def _delete_blender_objects_by_type(self, typ: str, oid: int, uid: str = None) -> int:
        """从Blender中删除指定类型的对象 - 添加详细调试"""
        deleted_count = 0

        try:
            logger.info(f" 开始搜索Blender对象: typ={typ}, oid={oid}, uid={uid}")

            # 遍历所有Blender对象
            objects_to_delete = []
            checked_objects = []

            for obj in bpy.data.objects:
                checked_objects.append(obj.name)
                if self._should_delete_blender_object(obj, typ, oid, uid):
                    objects_to_delete.append(obj)
                    logger.info(f"🎯 标记删除: {obj.name}")

            logger.info(
                f"📊 检查了 {len(checked_objects)} 个对象，标记删除 {len(objects_to_delete)} 个")

            # 删除收集到的对象
            for obj in objects_to_delete:
                try:
                    logger.info(
                        f"️ 删除Blender对象: {obj.name}, typ={typ}, oid={oid}, uid={uid}")
                    bpy.data.objects.remove(obj, do_unlink=True)
                    deleted_count += 1
                except Exception as e:
                    logger.error(f"删除Blender对象失败: {obj.name}, 错误: {e}")

            # 清理孤立的网格数据
            self._cleanup_orphaned_meshes()

        except Exception as e:
            logger.error(f"删除Blender对象时发生错误: {e}")

        return deleted_count

    def _should_delete_blender_object(self, obj, typ: str, oid: int, uid: str = None) -> bool:
        """判断是否应该删除Blender对象 - 添加详细调试"""
        try:
            if not obj or not hasattr(obj, 'get'):
                return False

            # 【调试】打印对象的所有sw_属性
            sw_attrs = {}
            for key, value in obj.items():
                if key.startswith('sw_'):
                    sw_attrs[key] = value

            logger.debug(f"🔍 检查对象 {obj.name} 的sw_属性: {sw_attrs}")

            # 使用相同的删除条件逻辑
            should_delete = self._matches_delete_condition(obj, typ, oid, uid)

            if should_delete:
                logger.info(f"✅ 对象 {obj.name} 匹配删除条件")
            else:
                logger.debug(f"❌ 对象 {obj.name} 不匹配删除条件")

            return should_delete

        except Exception as e:
            logger.error(f"检查Blender对象删除条件时发生错误: {e}")
            return False

    def _cleanup_orphaned_meshes(self):
        """清理孤立的网格数据"""
        try:
            # 清理没有对象的网格
            for mesh in bpy.data.meshes:
                if mesh.users == 0:
                    bpy.data.meshes.remove(mesh)
                    logger.debug(f"清理孤立网格: {mesh.name}")

            # 清理没有对象的材质
            for material in bpy.data.materials:
                if material.users == 0:
                    bpy.data.materials.remove(material)
                    logger.debug(f"清理孤立材质: {material.name}")

        except Exception as e:
            logger.error(f"清理孤立数据时发生错误: {e}")

    def _get_entity_attribute(self, entity, attr_name: str):
        """获取实体属性 - 改进版本"""
        try:
            if BLENDER_AVAILABLE and hasattr(entity, 'get'):
                # 【修复7】检查多种可能的属性名
                possible_attrs = [
                    f"sw_{attr_name}",
                    attr_name,
                    f"sw{attr_name}"
                ]

                for attr in possible_attrs:
                    value = entity.get(attr)
                    if value is not None:
                        return value

            return None
        except:
            return None

    def _delete_entity_safe(self, entity) -> bool:
        """安全删除实体 - 改进版本"""
        try:
            if not entity or not BLENDER_AVAILABLE:
                return False

            # 【修复8】更全面的对象检查
            if hasattr(entity, 'name'):
                # 检查是否在Blender对象中
                if entity.name in bpy.data.objects:
                    bpy.data.objects.remove(entity, do_unlink=True)
                    return True
                # 检查是否在网格中
                elif entity.name in bpy.data.meshes:
                    bpy.data.meshes.remove(entity, do_unlink=True)
                    return True
                # 检查是否在材质中
                elif entity.name in bpy.data.materials:
                    bpy.data.materials.remove(entity, do_unlink=True)
                    return True

            return False
        except Exception as e:
            logger.error(f"删除实体失败: {e}")
            return False

    def _is_entity_valid(self, entity) -> bool:
        """检查实体是否有效"""
        try:
            if entity is None:
                return False

            # 检查是否是 Blender 对象
            if hasattr(entity, 'name'):
                # 检查对象是否已被删除
                if hasattr(entity, 'is_valid'):
                    return entity.is_valid
                elif hasattr(entity, 'users'):
                    return entity.users > 0
                else:
                    return True

            # 检查是否是字典或其他类型
            return entity is not None

        except Exception:
            return False

    # ==================== 统计和管理方法 ====================

    def get_data_stats(self) -> Dict[str, Any]:
        """获取数据统计信息"""
        with self.lock:
            return {
                "total_units": len(set(list(self.zones.keys()) + list(self.parts.keys()) + list(self.hardwares.keys()))),
                "zones": {
                    "units": len(self.zones),
                    "total_zones": sum(len(zones) for zones in self.zones.values())
                },
                "parts": {
                    "units": len(self.parts),
                    "total_parts": sum(len(parts) for parts in self.parts.values())
                },
                "hardwares": {
                    "units": len(self.hardwares),
                    "total_hardwares": sum(len(hws) for hws in self.hardwares.values())
                },
                "machinings": {
                    "units": len(self.machinings),
                    "total_machinings": sum(len(machs) for machs in self.machinings.values())
                },
                "dimensions": {
                    "units": len(self.dimensions),
                    "total_dimensions": sum(len(dims) for dims in self.dimensions.values())
                },
                "textures": len(self.textures),
                "selected_objects": {
                    "uid": self.selected_uid,
                    "obj": self.selected_obj,
                    "faces": len(self.selected_faces),
                    "parts": len(self.selected_parts),
                    "hardwares": len(self.selected_hws)
                },
                "system_state": {
                    "part_mode": self.part_mode,
                    "hide_none": self.hide_none,
                    "mat_type": self.mat_type,
                    "back_material": self.back_material,
                    "added_contour": self.added_contour
                }
            }

    def cleanup_all(self):
        """清理所有数据"""
        with self.lock:
            self.zones.clear()
            self.parts.clear()
            self.hardwares.clear()
            self.labels.clear()
            self.door_labels.clear()
            self.machinings.clear()
            self.dimensions.clear()
            self.textures.clear()
            self.unit_params.clear()
            self.unit_trans.clear()
            self.sel_clear()
            logger.info("✅ 数据管理器清理完成")

# ==================== 全局数据管理器实例 ====================


# 全局数据管理器实例
data_manager: Optional[DataManager] = None


def init_data_manager() -> DataManager:
    """初始化全局数据管理器实例"""
    global data_manager
    if data_manager is None:
        data_manager = DataManager()
    return data_manager


def get_data_manager() -> DataManager:
    """获取全局数据管理器实例"""
    global data_manager
    if data_manager is None:
        data_manager = init_data_manager()
    return data_manager


# 自动初始化
data_manager = init_data_manager()

# ==================== 兼容性函数 ====================


def get_zones(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取zones"""
    return data_manager.get_zones(data)


def get_parts(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取parts"""
    return data_manager.get_parts(data)


def get_hardwares(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取hardwares"""
    return data_manager.get_hardwares(data)


def get_texture(key: str) -> Any:
    """兼容性函数 - 获取材质"""
    return data_manager.get_texture(key)


def sel_clear():
    """兼容性函数 - 清除选择"""
    return data_manager.sel_clear()


# ==================== 兼容性函数 ====================


def get_zones(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取zones"""
    return data_manager.get_zones(data)


def get_parts(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取parts"""
    return data_manager.get_parts(data)


def get_hardwares(data: Dict[str, Any]) -> Dict[str, Any]:
    """兼容性函数 - 获取hardwares"""
    return data_manager.get_hardwares(data)


def get_texture(key: str) -> Any:
    """兼容性函数 - 获取材质"""
    return data_manager.get_texture(key)


def sel_clear():
    """兼容性函数 - 清除选择"""
    return data_manager.sel_clear()