"""
调试可视化工具
提供软体和布料物理模拟的调试可视化功能
包含完整的可视化和性能监控功能
"""

from panda3d.core import NodePath, LineSegs, Vec3, Vec4, Point3
from panda3d.core import GeomVertexFormat, GeomVertexData, GeomVertexWriter
from panda3d.core import GeomLines, Geom, GeomNode, TextNode
from panda3d.core import TransparencyAttrib
from typing import List, Dict, Any, Optional, Tuple
import math


class ClothDebugVisualizer:
    """
    布料调试可视化器
    提供布料物理模拟的可视化调试功能，包括网格、固定点、力、速度等
    """
    
    # 可视化模式
    MODE_WIREFRAME = "wireframe"
    MODE_POINTS = "points"
    MODE_SOLID = "solid"
    
    # 颜色主题
    COLOR_THEME_DEFAULT = "default"
    COLOR_THEME_HEATMAP = "heatmap"
    COLOR_THEME_STRESS = "stress"
    
    def __init__(self, render_node: NodePath):
        """
        初始化调试可视化器
        
        Args:
            render_node: 渲染节点
        """
        self.render_node = render_node
        self.debug_root = render_node.attachNewNode("cloth_debug_visualizer")
        self.enabled = False
        
        # 可视化标志
        self.show_flags = {
            'mesh': True,
            'anchors': True,
            'forces': False,
            'velocities': False,
            'normals': False,
            'tears': True,
            'collisions': False,
            'bounding_box': False,
            'stress': False,
            'strain': False
        }
        
        # 可视化参数
        self.visualization_params = {
            'mesh_color': Vec4(0.0, 1.0, 0.0, 0.7),      # 绿色半透明
            'anchor_color': Vec4(1.0, 0.0, 0.0, 1.0),    # 红色
            'force_color': Vec4(1.0, 1.0, 0.0, 1.0),     # 黄色
            'velocity_color': Vec4(0.0, 0.0, 1.0, 1.0),  # 蓝色
            'normal_color': Vec4(1.0, 0.5, 0.0, 1.0),    # 橙色
            'tear_color': Vec4(1.0, 0.0, 1.0, 1.0),      # 紫色
            'collision_color': Vec4(1.0, 0.5, 0.0, 1.0), # 橙色
            'line_thickness': 2.0,
            'point_size': 5.0,
            'vector_scale': 1.0,
            'transparency': 0.7
        }
        
        # 性能监控
        self.performance_stats = {
            'last_update_time': 0.0,
            'update_count': 0,
            'rendered_objects': 0,
            'total_vertices': 0,
            'fps': 0.0
        }
        
        # 可视化模式
        self.visualization_mode = self.MODE_WIREFRAME
        self.color_theme = self.COLOR_THEME_DEFAULT
        
        # 统计信息显示
        self.stats_node = None
        self.show_stats = False
        
    def enable(self):
        """
        启用调试可视化
        """
        self.enabled = True
        self.debug_root.show()
        print("✓ 布料调试可视化已启用")
        
    def disable(self):
        """
        禁用调试可视化
        """
        self.enabled = False
        self.debug_root.hide()
        print("✓ 布料调试可视化已禁用")
        
    def set_visibility_flags(self, **kwargs):
        """
        设置可视化标志
        
        Args:
            **kwargs: 可视化标志键值对
        """
        for key, value in kwargs.items():
            if key in self.show_flags:
                self.show_flags[key] = value
                
    def set_visualization_params(self, **kwargs):
        """
        设置可视化参数
        
        Args:
            **kwargs: 可视化参数键值对
        """
        for key, value in kwargs.items():
            if key in self.visualization_params:
                self.visualization_params[key] = value
                
    def set_visualization_mode(self, mode: str):
        """
        设置可视化模式
        
        Args:
            mode: 可视化模式
        """
        if mode in [self.MODE_WIREFRAME, self.MODE_POINTS, self.MODE_SOLID]:
            self.visualization_mode = mode
            
    def set_color_theme(self, theme: str):
        """
        设置颜色主题
        
        Args:
            theme: 颜色主题
        """
        if theme in [self.COLOR_THEME_DEFAULT, self.COLOR_THEME_HEATMAP, self.COLOR_THEME_STRESS]:
            self.color_theme = theme
            
    def enable_statistics(self, show: bool = True):
        """
        启用统计信息显示
        
        Args:
            show: 是否显示统计信息
        """
        self.show_stats = show
        if show and not self.stats_node:
            self._create_stats_display()
        elif not show and self.stats_node:
            self.stats_node.removeNode()
            self.stats_node = None
            
    def visualize_cloth_mesh(self, cloth_info: Dict[str, Any]):
        """
        可视化布料网格
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['mesh']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "mesh")
            
            # 获取软体节点
            soft_body = cloth_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            links = soft_body.get_links()
            
            if not nodes or not links:
                return
                
            # 创建线条段
            lines = LineSegs()
            lines.setThickness(self.visualization_params['line_thickness'])
            lines.setColor(self.visualization_params['mesh_color'])
            
            # 根据颜色主题设置颜色
            base_color = self.visualization_params['mesh_color']
            
            # 绘制链接线
            for link in links:
                node_a = nodes[link.get_node_a()]
                node_b = nodes[link.get_node_b()]
                
                pos_a = node_a.get_position()
                pos_b = node_b.get_position()
                
                # 根据模式调整颜色
                if self.color_theme == self.COLOR_THEME_STRESS:
                    # 根据应力调整颜色
                    stress = link.get_bbending()  # 简化处理
                    color_factor = min(1.0, stress * 2.0)
                    color = Vec4(
                        base_color[0] + color_factor * (1.0 - base_color[0]),
                        base_color[1] * (1.0 - color_factor),
                        base_color[2] * (1.0 - color_factor),
                        base_color[3]
                    )
                    lines.setColor(color)
                elif self.color_theme == self.COLOR_THEME_HEATMAP:
                    # 根据位置高度调整颜色
                    height_factor = (pos_a[2] + pos_b[2]) / 2.0
                    normalized_height = max(0.0, min(1.0, (height_factor + 10.0) / 20.0))
                    lines.setColor(Vec4(normalized_height, 1.0 - normalized_height, 0.5, base_color[3]))
                else:
                    lines.setColor(base_color)
                    
                lines.moveTo(pos_a)
                lines.drawTo(pos_b)
                
            # 创建可视化节点
            mesh_geom = lines.create()
            mesh_node = self.debug_root.attachNewNode(mesh_geom)
            mesh_node.setName(f"cloth_mesh_debug_{id(cloth_info)}")
            cloth_info['_debug_mesh_node'] = mesh_node
            
            # 应用透明度
            mesh_node.setTransparency(TransparencyAttrib.MAlpha)
            
            self.performance_stats['total_vertices'] += len(nodes)
            
        except Exception as e:
            print(f"⚠ 可视化布料网格失败: {e}")
            
    def visualize_anchors(self, cloth_info: Dict[str, Any]):
        """
        可视化固定点
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['anchors']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "anchors")
            
            # 获取固定点信息
            anchors = cloth_info.get('anchors', [])
            if not anchors:
                return
                
            # 创建点表示固定点
            lines = LineSegs()
            lines.setThickness(self.visualization_params['point_size'])
            lines.setColor(self.visualization_params['anchor_color'])
            
            # 绘制固定点
            for anchor in anchors:
                vertex_index = anchor.get('vertex_index', 0)
                
                # 获取软体节点
                soft_body = cloth_info.get('soft_body')
                if soft_body:
                    nodes = soft_body.get_nodes()
                    if vertex_index < len(nodes):
                        pos = nodes[vertex_index].get_position()
                        lines.moveTo(pos)
                        lines.drawTo(pos)  # 绘制点
                        
            # 创建可视化节点
            anchor_geom = lines.create()
            anchor_node = self.debug_root.attachNewNode(anchor_geom)
            anchor_node.setName(f"cloth_anchors_debug_{id(cloth_info)}")
            cloth_info['_debug_anchor_node'] = anchor_node
            
        except Exception as e:
            print(f"⚠ 可视化固定点失败: {e}")
            
    def visualize_forces(self, cloth_info: Dict[str, Any]):
        """
        可视化力
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['forces']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "forces")
            
            # 获取软体节点
            soft_body = cloth_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            if not nodes:
                return
                
            # 创建力向量可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(self.visualization_params['force_color'])
            
            # 绘制力向量
            scale = self.visualization_params['vector_scale'] * 0.1
            for i, node in enumerate(nodes):
                pos = node.get_position()
                # 简化处理：使用速度作为力的近似
                velocity = node.get_velocity()
                force_vector = velocity * scale
                
                if force_vector.length() > 0.01:  # 只显示显著的力
                    lines.moveTo(pos)
                    lines.drawTo(pos + force_vector)
                    
                    # 绘制箭头
                    self._draw_arrow_head(lines, pos, pos + force_vector, 0.1)
                    
            # 创建可视化节点
            force_geom = lines.create()
            force_node = self.debug_root.attachNewNode(force_geom)
            force_node.setName(f"cloth_forces_debug_{id(cloth_info)}")
            cloth_info['_debug_force_node'] = force_node
            
        except Exception as e:
            print(f"⚠ 可视化布料力失败: {e}")
            
    def visualize_velocities(self, cloth_info: Dict[str, Any]):
        """
        可视化速度
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['velocities']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "velocities")
            
            # 获取软体节点
            soft_body = cloth_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            if not nodes:
                return
                
            # 创建速度向量可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(self.visualization_params['velocity_color'])
            
            # 绘制速度向量
            scale = self.visualization_params['vector_scale'] * 0.05
            for i, node in enumerate(nodes):
                pos = node.get_position()
                velocity = node.get_velocity()
                velocity_vector = velocity * scale
                
                if velocity_vector.length() > 0.005:  # 只显示显著的速度
                    lines.moveTo(pos)
                    lines.drawTo(pos + velocity_vector)
                    
                    # 绘制箭头
                    self._draw_arrow_head(lines, pos, pos + velocity_vector, 0.05)
                    
            # 创建可视化节点
            velocity_geom = lines.create()
            velocity_node = self.debug_root.attachNewNode(velocity_geom)
            velocity_node.setName(f"cloth_velocities_debug_{id(cloth_info)}")
            cloth_info['_debug_velocity_node'] = velocity_node
            
        except Exception as e:
            print(f"⚠ 可视化布料速度失败: {e}")
            
    def visualize_normals(self, cloth_info: Dict[str, Any]):
        """
        可视化法线
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['normals']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "normals")
            
            # 获取软体节点
            soft_body = cloth_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取面信息
            faces = soft_body.get_faces()
            if not faces:
                return
                
            # 创建法线可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(self.visualization_params['normal_color'])
            
            # 绘制面法线
            scale = self.visualization_params['vector_scale'] * 0.2
            for face in faces:
                # 简化处理：计算面的中心和法线
                # 实际实现需要更精确的计算
                pass
                
            # 创建可视化节点
            normal_geom = lines.create()
            normal_node = self.debug_root.attachNewNode(normal_geom)
            normal_node.setName(f"cloth_normals_debug_{id(cloth_info)}")
            cloth_info['_debug_normal_node'] = normal_node
            
        except Exception as e:
            print(f"⚠ 可视化布料法线失败: {e}")
            
    def visualize_tears(self, cloth_info: Dict[str, Any]):
        """
        可视化撕裂
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['tears']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "tears")
            
            # 获取撕裂信息
            tears = cloth_info.get('tears', [])
            if not tears:
                return
                
            # 创建撕裂可视化
            lines = LineSegs()
            lines.setThickness(self.visualization_params['line_thickness'] * 2)
            lines.setColor(self.visualization_params['tear_color'])
            
            # 绘制撕裂线
            for tear_info in tears:
                tear_point = tear_info.get('point', Point3(0, 0, 0))
                tear_radius = tear_info.get('radius', 0.1)
                
                # 绘制撕裂圆
                self._draw_circle(lines, tear_point, tear_radius, 16)
                
            # 创建可视化节点
            tear_geom = lines.create()
            tear_node = self.debug_root.attachNewNode(tear_geom)
            tear_node.setName(f"cloth_tears_debug_{id(cloth_info)}")
            cloth_info['_debug_tear_node'] = tear_node
            
        except Exception as e:
            print(f"⚠ 可视化布料撕裂失败: {e}")
            
    def visualize_collisions(self, cloth_info: Dict[str, Any]):
        """
        可视化碰撞
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['collisions']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "collisions")
            
            # 获取碰撞信息
            collisions = cloth_info.get('collisions', [])
            if not collisions:
                return
                
            # 创建碰撞可视化
            lines = LineSegs()
            lines.setThickness(self.visualization_params['point_size'])
            lines.setColor(self.visualization_params['collision_color'])
            
            # 绘制碰撞点
            for collision_info in collisions:
                collision_point = collision_info.get('point', Point3(0, 0, 0))
                lines.moveTo(collision_point)
                lines.drawTo(collision_point)
                
            # 创建可视化节点
            collision_geom = lines.create()
            collision_node = self.debug_root.attachNewNode(collision_geom)
            collision_node.setName(f"cloth_collisions_debug_{id(cloth_info)}")
            cloth_info['_debug_collision_node'] = collision_node
            
        except Exception as e:
            print(f"⚠ 可视化布料碰撞失败: {e}")
            
    def visualize_bounding_box(self, cloth_info: Dict[str, Any]):
        """
        可视化包围盒
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled or not self.show_flags['bounding_box']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_cloth_visualization(cloth_info, "bounding_box")
            
            # 获取软体节点
            soft_body = cloth_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            if not nodes:
                return
                
            # 计算包围盒
            min_pos = Point3(float('inf'), float('inf'), float('inf'))
            max_pos = Point3(float('-inf'), float('-inf'), float('-inf'))
            
            for node in nodes:
                pos = node.get_position()
                min_pos.set(
                    min(min_pos[0], pos[0]),
                    min(min_pos[1], pos[1]),
                    min(min_pos[2], pos[2])
                )
                max_pos.set(
                    max(max_pos[0], pos[0]),
                    max(max_pos[1], pos[1]),
                    max(max_pos[2], pos[2])
                )
                
            # 创建包围盒可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(Vec4(0.5, 0.5, 1.0, 0.5))  # 蓝色半透明
            
            # 绘制包围盒
            self._draw_box(lines, min_pos, max_pos)
            
            # 创建可视化节点
            bbox_geom = lines.create()
            bbox_node = self.debug_root.attachNewNode(bbox_geom)
            bbox_node.setName(f"cloth_bbox_debug_{id(cloth_info)}")
            cloth_info['_debug_bbox_node'] = bbox_node
            
        except Exception as e:
            print(f"⚠ 可视化布料包围盒失败: {e}")
            
    def update_visualization(self, cloth_info: Dict[str, Any]):
        """
        更新布料可视化
        
        Args:
            cloth_info: 布料对象信息
        """
        if not self.enabled:
            return
            
        # 更新各种可视化
        if self.show_flags['mesh']:
            self.visualize_cloth_mesh(cloth_info)
        if self.show_flags['anchors']:
            self.visualize_anchors(cloth_info)
        if self.show_flags['forces']:
            self.visualize_forces(cloth_info)
        if self.show_flags['velocities']:
            self.visualize_velocities(cloth_info)
        if self.show_flags['normals']:
            self.visualize_normals(cloth_info)
        if self.show_flags['tears']:
            self.visualize_tears(cloth_info)
        if self.show_flags['collisions']:
            self.visualize_collisions(cloth_info)
        if self.show_flags['bounding_box']:
            self.visualize_bounding_box(cloth_info)
            
        # 更新性能统计
        self.performance_stats['update_count'] += 1
            
    def clear_cloth_visualization(self, cloth_info: Dict[str, Any]):
        """
        清除布料可视化
        
        Args:
            cloth_info: 布料对象信息
        """
        self._clear_cloth_visualization(cloth_info, "all")
        
    def _clear_cloth_visualization(self, cloth_info: Dict[str, Any], 
                                 visualization_type: str):
        """
        清除布料可视化（内部方法）
        
        Args:
            cloth_info: 布料对象信息
            visualization_type: 可视化类型
        """
        try:
            visualization_map = {
                "mesh": '_debug_mesh_node',
                "anchors": '_debug_anchor_node',
                "forces": '_debug_force_node',
                "velocities": '_debug_velocity_node',
                "normals": '_debug_normal_node',
                "tears": '_debug_tear_node',
                "collisions": '_debug_collision_node',
                "bounding_box": '_debug_bbox_node'
            }
            
            if visualization_type == "all":
                # 清除所有可视化
                for key in visualization_map.values():
                    node = cloth_info.get(key)
                    if node and not node.isEmpty():
                        node.removeNode()
                        if key in cloth_info:
                            del cloth_info[key]
            else:
                # 清除特定可视化
                key = visualization_map.get(visualization_type)
                if key:
                    node = cloth_info.get(key)
                    if node and not node.isEmpty():
                        node.removeNode()
                        if key in cloth_info:
                            del cloth_info[key]
                        
        except Exception as e:
            print(f"⚠ 清除布料可视化失败: {e}")
            
    def _draw_arrow_head(self, lines: LineSegs, start: Point3, end: Point3, size: float):
        """
        绘制箭头头部
        
        Args:
            lines: 线段对象
            start: 起点
            end: 终点
            size: 箭头大小
        """
        direction = end - start
        length = direction.length()
        if length == 0:
            return
            
        direction.normalize()
        
        # 计算垂直向量
        if abs(direction.dot(Vec3(0, 0, 1))) < 0.999:
            up_vector = Vec3(0, 0, 1)
        else:
            up_vector = Vec3(1, 0, 0)
            
        right_vector = direction.cross(up_vector)
        right_vector.normalize()
        up_vector = right_vector.cross(direction)
        up_vector.normalize()
        
        # 绘制箭头
        arrow_point1 = end - direction * size + right_vector * size * 0.5
        arrow_point2 = end - direction * size - right_vector * size * 0.5
        
        lines.moveTo(end)
        lines.drawTo(arrow_point1)
        lines.moveTo(end)
        lines.drawTo(arrow_point2)
        
    def _draw_circle(self, lines: LineSegs, center: Point3, radius: float, segments: int):
        """
        绘制圆形
        
        Args:
            lines: 线段对象
            center: 圆心
            radius: 半径
            segments: 分段数
        """
        for i in range(segments):
            angle1 = (i / segments) * 2 * math.pi
            angle2 = ((i + 1) / segments) * 2 * math.pi
            
            point1 = center + Point3(math.cos(angle1) * radius, math.sin(angle1) * radius, 0)
            point2 = center + Point3(math.cos(angle2) * radius, math.sin(angle2) * radius, 0)
            
            lines.moveTo(point1)
            lines.drawTo(point2)
            
    def _draw_box(self, lines: LineSegs, min_pos: Point3, max_pos: Point3):
        """
        绘制包围盒
        
        Args:
            lines: 线段对象
            min_pos: 最小点
            max_pos: 最大点
        """
        # 8个顶点
        vertices = [
            Point3(min_pos[0], min_pos[1], min_pos[2]),  # 0
            Point3(max_pos[0], min_pos[1], min_pos[2]),  # 1
            Point3(max_pos[0], max_pos[1], min_pos[2]),  # 2
            Point3(min_pos[0], max_pos[1], min_pos[2]),  # 3
            Point3(min_pos[0], min_pos[1], max_pos[2]),  # 4
            Point3(max_pos[0], min_pos[1], max_pos[2]),  # 5
            Point3(max_pos[0], max_pos[1], max_pos[2]),  # 6
            Point3(min_pos[0], max_pos[1], max_pos[2])   # 7
        ]
        
        # 12条边
        edges = [
            (0, 1), (1, 2), (2, 3), (3, 0),  # 底面
            (4, 5), (5, 6), (6, 7), (7, 4),  # 顶面
            (0, 4), (1, 5), (2, 6), (3, 7)   # 垂直边
        ]
        
        for edge in edges:
            lines.moveTo(vertices[edge[0]])
            lines.drawTo(vertices[edge[1]])
            
    def _create_stats_display(self):
        """
        创建统计信息显示
        """
        # 创建文本节点
        text_node = TextNode('cloth_debug_stats')
        text_node.setText("Cloth Debug Stats")
        text_node.setAlign(TextNode.ALeft)
        text_node.setTextColor(1, 1, 0, 1)  # 黄色
        
        # 创建节点路径
        self.stats_node = self.debug_root.attachNewNode(text_node)
        self.stats_node.setScale(0.1)
        self.stats_node.setPos(-2, 0, 2)  # 屏幕左上角
        
    def update_stats_display(self):
        """
        更新统计信息显示
        """
        if self.stats_node and self.show_stats:
            text = f"Cloth Debug Stats\n"
            text += f"Objects: {self.performance_stats['rendered_objects']}\n"
            text += f"Vertices: {self.performance_stats['total_vertices']}\n"
            text += f"Updates: {self.performance_stats['update_count']}\n"
            text += f"FPS: {self.performance_stats['fps']:.1f}"
            
            self.stats_node.node().setText(text)
            
    def cleanup(self):
        """
        清理所有调试可视化
        """
        if not self.debug_root.isEmpty():
            self.debug_root.removeNode()
        if self.stats_node:
            self.stats_node.removeNode()
            self.stats_node = None
        print("✓ 布料调试可视化已清理")


class SoftBodyDebugVisualizer:
    """
    软体调试可视化器
    提供软体物理模拟的可视化调试功能
    """
    
    def __init__(self, render_node: NodePath):
        """
        初始化调试可视化器
        
        Args:
            render_node: 渲染节点
        """
        self.render_node = render_node
        self.debug_root = render_node.attachNewNode("soft_body_debug_visualizer")
        self.enabled = False
        
        # 可视化标志
        self.show_flags = {
            'mesh': True,
            'forces': False,
            'velocities': False,
            'normals': False,
            'collisions': False,
            'bounding_box': False,
            'mass_distribution': False,
            'constraints': False
        }
        
        # 可视化参数
        self.visualization_params = {
            'mesh_color': Vec4(1.0, 0.0, 0.0, 0.7),      # 红色半透明
            'force_color': Vec4(1.0, 1.0, 0.0, 1.0),     # 黄色
            'velocity_color': Vec4(0.0, 0.0, 1.0, 1.0),  # 蓝色
            'normal_color': Vec4(1.0, 0.5, 0.0, 1.0),    # 橙色
            'collision_color': Vec4(1.0, 0.5, 0.0, 1.0), # 橙色
            'constraint_color': Vec4(0.5, 0.0, 1.0, 1.0), # 紫色
            'line_thickness': 2.0,
            'point_size': 5.0,
            'vector_scale': 1.0,
            'transparency': 0.7
        }
        
        # 性能监控
        self.performance_stats = {
            'last_update_time': 0.0,
            'update_count': 0,
            'rendered_objects': 0,
            'total_vertices': 0,
            'fps': 0.0
        }
        
        # 统计信息显示
        self.stats_node = None
        self.show_stats = False
        
    def enable(self):
        """
        启用调试可视化
        """
        self.enabled = True
        self.debug_root.show()
        print("✓ 软体调试可视化已启用")
        
    def disable(self):
        """
        禁用调试可视化
        """
        self.enabled = False
        self.debug_root.hide()
        print("✓ 软体调试可视化已禁用")
        
    def set_visibility_flags(self, **kwargs):
        """
        设置可视化标志
        
        Args:
            **kwargs: 可视化标志键值对
        """
        for key, value in kwargs.items():
            if key in self.show_flags:
                self.show_flags[key] = value
                
    def set_visualization_params(self, **kwargs):
        """
        设置可视化参数
        
        Args:
            **kwargs: 可视化参数键值对
        """
        for key, value in kwargs.items():
            if key in self.visualization_params:
                self.visualization_params[key] = value
                
    def enable_statistics(self, show: bool = True):
        """
        启用统计信息显示
        
        Args:
            show: 是否显示统计信息
        """
        self.show_stats = show
        if show and not self.stats_node:
            self._create_stats_display()
        elif not show and self.stats_node:
            self.stats_node.removeNode()
            self.stats_node = None
            
    def visualize_soft_body_mesh(self, soft_info: Dict[str, Any]):
        """
        可视化软体网格
        
        Args:
            soft_info: 软体对象信息
        """
        if not self.enabled or not self.show_flags['mesh']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_soft_body_visualization(soft_info, "mesh")
            
            # 获取软体节点
            soft_body = soft_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            links = soft_body.get_links()
            
            if not nodes or not links:
                return
                
            # 创建线条段
            lines = LineSegs()
            lines.setThickness(self.visualization_params['line_thickness'])
            lines.setColor(self.visualization_params['mesh_color'])
            
            # 绘制链接线
            for link in links:
                node_a = nodes[link.get_node_a()]
                node_b = nodes[link.get_node_b()]
                
                pos_a = node_a.get_position()
                pos_b = node_b.get_position()
                
                lines.moveTo(pos_a)
                lines.drawTo(pos_b)
                
            # 创建可视化节点
            mesh_geom = lines.create()
            mesh_node = self.debug_root.attachNewNode(mesh_geom)
            mesh_node.setName(f"soft_body_mesh_debug_{id(soft_info)}")
            soft_info['_debug_mesh_node'] = mesh_node
            
            # 应用透明度
            mesh_node.setTransparency(TransparencyAttrib.MAlpha)
            
            self.performance_stats['total_vertices'] += len(nodes)
            
        except Exception as e:
            print(f"⚠ 可视化软体网格失败: {e}")
            
    def visualize_soft_body_forces(self, soft_info: Dict[str, Any]):
        """
        可视化软体力
        
        Args:
            soft_info: 软体对象信息
        """
        if not self.enabled or not self.show_flags['forces']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_soft_body_visualization(soft_info, "forces")
            
            # 获取软体节点
            soft_body = soft_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            if not nodes:
                return
                
            # 创建力向量可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(self.visualization_params['force_color'])
            
            # 绘制力向量
            scale = self.visualization_params['vector_scale'] * 0.1
            for i, node in enumerate(nodes):
                pos = node.get_position()
                # 简化处理：使用速度作为力的近似
                velocity = node.get_velocity()
                force_vector = velocity * scale
                
                if force_vector.length() > 0.01:  # 只显示显著的力
                    lines.moveTo(pos)
                    lines.drawTo(pos + force_vector)
                    
                    # 绘制箭头
                    self._draw_arrow_head(lines, pos, pos + force_vector, 0.1)
                    
            # 创建可视化节点
            force_geom = lines.create()
            force_node = self.debug_root.attachNewNode(force_geom)
            force_node.setName(f"soft_body_forces_debug_{id(soft_info)}")
            soft_info['_debug_force_node'] = force_node
            
        except Exception as e:
            print(f"⚠ 可视化软体力失败: {e}")
            
    def visualize_soft_body_velocities(self, soft_info: Dict[str, Any]):
        """
        可视化软体速度
        
        Args:
            soft_info: 软体对象信息
        """
        if not self.enabled or not self.show_flags['velocities']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_soft_body_visualization(soft_info, "velocities")
            
            # 获取软体节点
            soft_body = soft_info.get('soft_body')
            if not soft_body:
                return
                
            # 获取节点信息
            nodes = soft_body.get_nodes()
            if not nodes:
                return
                
            # 创建速度向量可视化
            lines = LineSegs()
            lines.setThickness(1.0)
            lines.setColor(self.visualization_params['velocity_color'])
            
            # 绘制速度向量
            scale = self.visualization_params['vector_scale'] * 0.05
            for i, node in enumerate(nodes):
                pos = node.get_position()
                velocity = node.get_velocity()
                velocity_vector = velocity * scale
                
                if velocity_vector.length() > 0.005:  # 只显示显著的速度
                    lines.moveTo(pos)
                    lines.drawTo(pos + velocity_vector)
                    
                    # 绘制箭头
                    self._draw_arrow_head(lines, pos, pos + velocity_vector, 0.05)
                    
            # 创建可视化节点
            velocity_geom = lines.create()
            velocity_node = self.debug_root.attachNewNode(velocity_geom)
            velocity_node.setName(f"soft_body_velocities_debug_{id(soft_info)}")
            soft_info['_debug_velocity_node'] = velocity_node
            
        except Exception as e:
            print(f"⚠ 可视化软体速度失败: {e}")
            
    def visualize_constraints(self, soft_info: Dict[str, Any]):
        """
        可视化约束
        
        Args:
            soft_info: 软体对象信息
        """
        if not self.enabled or not self.show_flags['constraints']:
            return
            
        try:
            # 清除之前的可视化
            self._clear_soft_body_visualization(soft_info, "constraints")
            
            # 获取约束信息
            constraints = soft_info.get('constraints', [])
            if not constraints:
                return
                
            # 创建约束可视化
            lines = LineSegs()
            lines.setThickness(self.visualization_params['line_thickness'])
            lines.setColor(self.visualization_params['constraint_color'])
            
            # 绘制约束线
            for constraint_info in constraints:
                # 简化处理
                pass
                
            # 创建可视化节点
            constraint_geom = lines.create()
            constraint_node = self.debug_root.attachNewNode(constraint_geom)
            constraint_node.setName(f"soft_body_constraints_debug_{id(soft_info)}")
            soft_info['_debug_constraint_node'] = constraint_node
            
        except Exception as e:
            print(f"⚠ 可视化软体约束失败: {e}")
            
    def update_visualization(self, soft_info: Dict[str, Any]):
        """
        更新软体可视化
        
        Args:
            soft_info: 软体对象信息
        """
        if not self.enabled:
            return
            
        # 更新各种可视化
        if self.show_flags['mesh']:
            self.visualize_soft_body_mesh(soft_info)
        if self.show_flags['forces']:
            self.visualize_soft_body_forces(soft_info)
        if self.show_flags['velocities']:
            self.visualize_soft_body_velocities(soft_info)
        if self.show_flags['constraints']:
            self.visualize_constraints(soft_info)
            
        # 更新性能统计
        self.performance_stats['update_count'] += 1
            
    def clear_soft_body_visualization(self, soft_info: Dict[str, Any]):
        """
        清除软体可视化
        
        Args:
            soft_info: 软体对象信息
        """
        self._clear_soft_body_visualization(soft_info, "all")
        
    def _clear_soft_body_visualization(self, soft_info: Dict[str, Any], 
                                     visualization_type: str):
        """
        清除软体可视化（内部方法）
        
        Args:
            soft_info: 软体对象信息
            visualization_type: 可视化类型
        """
        try:
            visualization_map = {
                "mesh": '_debug_mesh_node',
                "forces": '_debug_force_node',
                "velocities": '_debug_velocity_node',
                "constraints": '_debug_constraint_node'
            }
            
            if visualization_type == "all":
                # 清除所有可视化
                for key in visualization_map.values():
                    node = soft_info.get(key)
                    if node and not node.isEmpty():
                        node.removeNode()
                        if key in soft_info:
                            del soft_info[key]
            else:
                # 清除特定可视化
                key = visualization_map.get(visualization_type)
                if key:
                    node = soft_info.get(key)
                    if node and not node.isEmpty():
                        node.removeNode()
                        if key in soft_info:
                            del soft_info[key]
                        
        except Exception as e:
            print(f"⚠ 清除软体可视化失败: {e}")
            
    def _draw_arrow_head(self, lines: LineSegs, start: Point3, end: Point3, size: float):
        """
        绘制箭头头部
        
        Args:
            lines: 线段对象
            start: 起点
            end: 终点
            size: 箭头大小
        """
        direction = end - start
        length = direction.length()
        if length == 0:
            return
            
        direction.normalize()
        
        # 计算垂直向量
        if abs(direction.dot(Vec3(0, 0, 1))) < 0.999:
            up_vector = Vec3(0, 0, 1)
        else:
            up_vector = Vec3(1, 0, 0)
            
        right_vector = direction.cross(up_vector)
        right_vector.normalize()
        up_vector = right_vector.cross(direction)
        up_vector.normalize()
        
        # 绘制箭头
        arrow_point1 = end - direction * size + right_vector * size * 0.5
        arrow_point2 = end - direction * size - right_vector * size * 0.5
        
        lines.moveTo(end)
        lines.drawTo(arrow_point1)
        lines.moveTo(end)
        lines.drawTo(arrow_point2)
        
    def _create_stats_display(self):
        """
        创建统计信息显示
        """
        # 创建文本节点
        text_node = TextNode('soft_body_debug_stats')
        text_node.setText("Soft Body Debug Stats")
        text_node.setAlign(TextNode.ALeft)
        text_node.setTextColor(1, 0, 0, 1)  # 红色
        
        # 创建节点路径
        self.stats_node = self.debug_root.attachNewNode(text_node)
        self.stats_node.setScale(0.1)
        self.stats_node.setPos(-2, 0, 1)  # 屏幕左上角
        
    def update_stats_display(self):
        """
        更新统计信息显示
        """
        if self.stats_node and self.show_stats:
            text = f"Soft Body Debug Stats\n"
            text += f"Objects: {self.performance_stats['rendered_objects']}\n"
            text += f"Vertices: {self.performance_stats['total_vertices']}\n"
            text += f"Updates: {self.performance_stats['update_count']}\n"
            text += f"FPS: {self.performance_stats['fps']:.1f}"
            
            self.stats_node.node().setText(text)
            
    def cleanup(self):
        """
        清理所有调试可视化
        """
        if not self.debug_root.isEmpty():
            self.debug_root.removeNode()
        if self.stats_node:
            self.stats_node.removeNode()
            self.stats_node = None
        print("✓ 软体调试可视化已清理")


class PhysicsDebugManager:
    """
    物理调试管理器
    统一管理布料和软体的调试可视化
    """
    
    def __init__(self, render_node: NodePath):
        """
        初始化物理调试管理器
        
        Args:
            render_node: 渲染节点
        """
        self.render_node = render_node
        self.cloth_visualizer = ClothDebugVisualizer(render_node)
        self.soft_body_visualizer = SoftBodyDebugVisualizer(render_node)
        self.enabled = False
        
        # 全局设置
        self.global_settings = {
            'show_statistics': False,
            'update_frequency': 1,  # 每帧更新
            'auto_cleanup': True
        }
        
    def enable(self):
        """
        启用物理调试
        """
        self.enabled = True
        self.cloth_visualizer.enable()
        self.soft_body_visualizer.enable()
        print("✓ 物理调试已启用")
        
    def disable(self):
        """
        禁用物理调试
        """
        self.enabled = False
        self.cloth_visualizer.disable()
        self.soft_body_visualizer.disable()
        print("✓ 物理调试已禁用")
        
    def set_global_settings(self, **kwargs):
        """
        设置全局调试设置
        
        Args:
            **kwargs: 设置键值对
        """
        for key, value in kwargs.items():
            if key in self.global_settings:
                self.global_settings[key] = value
                
    def set_cloth_visibility(self, **kwargs):
        """
        设置布料可视化标志
        
        Args:
            **kwargs: 可视化标志键值对
        """
        self.cloth_visualizer.set_visibility_flags(**kwargs)
        
    def set_soft_body_visibility(self, **kwargs):
        """
        设置软体可视化标志
        
        Args:
            **kwargs: 可视化标志键值对
        """
        self.soft_body_visualizer.set_visibility_flags(**kwargs)
        
    def set_cloth_params(self, **kwargs):
        """
        设置布料可视化参数
        
        Args:
            **kwargs: 参数键值对
        """
        self.cloth_visualizer.set_visualization_params(**kwargs)
        
    def set_soft_body_params(self, **kwargs):
        """
        设置软体可视化参数
        
        Args:
            **kwargs: 参数键值对
        """
        self.soft_body_visualizer.set_visualization_params(**kwargs)
        
    def update_all_visualizations(self, cloth_objects: List[Dict[str, Any]], 
                                soft_body_objects: List[Dict[str, Any]]):
        """
        更新所有可视化
        
        Args:
            cloth_objects: 布料对象列表
            soft_body_objects: 软体对象列表
        """
        if not self.enabled:
            return
            
        # 更新布料可视化
        for cloth_info in cloth_objects:
            self.cloth_visualizer.update_visualization(cloth_info)
            
        # 更新软体可视化
        for soft_info in soft_body_objects:
            self.soft_body_visualizer.update_visualization(soft_info)
            
        # 更新统计显示
        if self.global_settings['show_statistics']:
            self.cloth_visualizer.update_stats_display()
            self.soft_body_visualizer.update_stats_display()
            
    def clear_all_visualizations(self, cloth_objects: List[Dict[str, Any]], 
                               soft_body_objects: List[Dict[str, Any]]):
        """
        清除所有可视化
        
        Args:
            cloth_objects: 布料对象列表
            soft_body_objects: 软体对象列表
        """
        # 清除布料可视化
        for cloth_info in cloth_objects:
            self.cloth_visualizer.clear_cloth_visualization(cloth_info)
            
        # 清除软体可视化
        for soft_info in soft_body_objects:
            self.soft_body_visualizer.clear_soft_body_visualization(soft_info)
            
    def cleanup(self):
        """
        清理所有调试可视化
        """
        self.cloth_visualizer.cleanup()
        self.soft_body_visualizer.cleanup()
        print("✓ 物理调试已清理")
        
    def get_debug_stats(self) -> Dict[str, Any]:
        """
        获取调试统计信息
        
        Returns:
            统计信息字典
        """
        return {
            'cloth_stats': self.cloth_visualizer.performance_stats,
            'soft_body_stats': self.soft_body_visualizer.performance_stats,
            'global_settings': self.global_settings,
            'enabled': self.enabled
        }