"""
Morphing和变形动画插件 - 高级功能模块
提供动画状态机、曲线编辑器、物理集成等高级功能
"""

import math
import numpy as np
from typing import Dict, List, Tuple, Optional, Any, Callable, Union
from dataclasses import dataclass, field
from enum import Enum

from panda3d.core import *
from direct.actor.Actor import Actor
from direct.showbase.DirectObject import DirectObject
from direct.interval.IntervalGlobal import *

# 导入核心模块
from .core import MorphingCore, InterpolationMode

# 定义常量
ADVANCED_SETTINGS = {
    'state_machine_update_rate': 30,
    'curve_editor_points': 100,
    'physics_update_rate': 60
}

# 枚举定义
class AnimationStateType(Enum):
    """动画状态类型枚举"""
    IDLE = 0
    PLAYING = 1
    TRANSITION = 2
    BLENDING = 3
    PAUSED = 4

class TransitionType(Enum):
    """转换类型枚举"""
    INSTANT = 0       # 瞬间转换
    SMOOTH = 1        # 平滑转换
    BLEND = 2         # 混合转换
    CONDITIONAL = 3   # 条件转换

class CurveType(Enum):
    """曲线类型枚举"""
    LINEAR = 0        # 线性
    BEZIER = 1        # 贝塞尔
    SPLINE = 2        # 样条
    STEP = 3          # 阶梯
    NOISE = 4         # 噪声

@dataclass
class AnimationState:
    """动画状态数据类"""
    name: str
    morph_targets: Dict[str, float]  # {target_name: weight}
    duration: float = 0.0
    loop: bool = False
    play_rate: float = 1.0
    active: bool = True

@dataclass
class StateTransition:
    """状态转换数据类"""
    from_state: str
    to_state: str
    transition_type: TransitionType
    condition: Optional[Callable] = None  # 转换条件函数
    transition_time: float = 0.3  # 转换时间
    blend_mode: InterpolationMode = InterpolationMode.LINEAR

@dataclass
class AnimationCurve:
    """动画曲线数据类"""
    name: str
    curve_type: CurveType
    control_points: List[Tuple[float, float]]  # 控制点 [(time, value)]
    interpolation: InterpolationMode = InterpolationMode.LINEAR
    active: bool = True

@dataclass
class PhysicsConstraint:
    """物理约束数据类"""
    name: str
    constraint_type: str  # 'spring', 'distance', 'angle'
    target_bone: str
    stiffness: float = 1.0
    damping: float = 0.1
    rest_value: float = 0.0
    active: bool = True

class AnimationStateMachine:
    """
    动画状态机
    管理复杂的动画状态转换和混合
    """
    
    def __init__(self, morphing_core: MorphingCore, model_id: str):
        """
        初始化动画状态机
        :param morphing_core: Morphing核心系统
        :param model_id: 模型ID
        """
        self.morphing_core = morphing_core
        self.model_id = model_id
        self.states: Dict[str, AnimationState] = {}
        self.transitions: List[StateTransition] = []
        self.current_state: Optional[str] = None
        self.previous_state: Optional[str] = None
        self.transition_progress: float = 0.0
        self.is_transitioning: bool = False
        self.is_updating: bool = False
        self.update_rate = ADVANCED_SETTINGS['state_machine_update_rate']
        self.last_update_time: float = 0.0
        
        print(f"动画状态机初始化完成 (模型: {model_id})")
        
    def add_state(self, state_name: str, morph_targets: Dict[str, float],
                 duration: float = 0.0, loop: bool = False, play_rate: float = 1.0) -> bool:
        """
        添加动画状态
        :param state_name: 状态名称
        :param morph_targets: Morph目标权重字典 {target_name: weight}
        :param duration: 持续时间
        :param loop: 是否循环
        :param play_rate: 播放速度
        :return: 是否成功添加
        """
        # 验证Morph目标是否存在
        for target_name in morph_targets.keys():
            if (self.model_id not in self.morphing_core.morph_targets or
                target_name not in self.morphing_core.morph_targets[self.model_id]):
                print(f"错误: Morph目标 {target_name} 不存在于模型 {self.model_id} 中")
                return False
                
        # 创建状态
        state = AnimationState(
            name=state_name,
            morph_targets=morph_targets,
            duration=duration,
            loop=loop,
            play_rate=play_rate,
            active=True
        )
        
        # 存储状态
        self.states[state_name] = state
        print(f"动画状态已添加: {state_name} (模型: {self.model_id})")
        return True
        
    def remove_state(self, state_name: str) -> bool:
        """
        移除动画状态
        :param state_name: 状态名称
        :return: 是否成功移除
        """
        if state_name not in self.states:
            print(f"错误: 动画状态 {state_name} 不存在")
            return False
            
        del self.states[state_name]
        
        # 移除相关的转换
        self.transitions = [t for t in self.transitions 
                          if t.from_state != state_name and t.to_state != state_name]
        
        print(f"动画状态已移除: {state_name} (模型: {self.model_id})")
        return True
        
    def set_transition(self, from_state: str, to_state: str,
                      transition_type: TransitionType = TransitionType.SMOOTH,
                      condition: Optional[Callable] = None,
                      transition_time: float = 0.3,
                      blend_mode: InterpolationMode = InterpolationMode.LINEAR) -> bool:
        """
        设置状态转换
        :param from_state: 起始状态
        :param to_state: 目标状态
        :param transition_type: 转换类型
        :param condition: 转换条件函数
        :param transition_time: 转换时间
        :param blend_mode: 混合模式
        :return: 是否成功设置
        """
        # 验证状态是否存在
        if from_state not in self.states:
            print(f"错误: 起始状态 {from_state} 不存在")
            return False
            
        if to_state not in self.states:
            print(f"错误: 目标状态 {to_state} 不存在")
            return False
            
        # 创建转换
        transition = StateTransition(
            from_state=from_state,
            to_state=to_state,
            transition_type=transition_type,
            condition=condition,
            transition_time=transition_time,
            blend_mode=blend_mode
        )
        
        # 存储转换
        self.transitions.append(transition)
        print(f"状态转换已设置: {from_state} -> {to_state} (模型: {self.model_id})")
        return True
        
    def enter_state(self, state_name: str) -> bool:
        """
        进入指定状态
        :param state_name: 状态名称
        :return: 是否成功进入
        """
        if state_name not in self.states:
            print(f"错误: 动画状态 {state_name} 不存在")
            return False
            
        self.previous_state = self.current_state
        self.current_state = state_name
        self.is_transitioning = False
        
        # 应用状态的Morph目标权重
        state = self.states[state_name]
        for target_name, weight in state.morph_targets.items():
            self.morphing_core.set_morph_target_weight(self.model_id, target_name, weight)
            
        print(f"进入动画状态: {state_name} (模型: {self.model_id})")
        return True
        
    def trigger_transition(self, to_state: str) -> bool:
        """
        触发状态转换
        :param to_state: 目标状态
        :return: 是否成功触发
        """
        if not self.current_state:
            print(f"错误: 当前没有活动状态")
            return False
            
        if to_state not in self.states:
            print(f"错误: 目标状态 {to_state} 不存在")
            return False
            
        # 查找转换
        transition = None
        for t in self.transitions:
            if t.from_state == self.current_state and t.to_state == to_state:
                transition = t
                break
                
        if not transition:
            print(f"错误: 从 {self.current_state} 到 {to_state} 的转换不存在")
            return False
            
        # 开始转换
        self.is_transitioning = True
        self.transition_progress = 0.0
        self.previous_state = self.current_state
        self.current_state = to_state
        
        print(f"触发状态转换: {self.previous_state} -> {to_state} (模型: {self.model_id})")
        return True
        
    def update(self, dt: float) -> None:
        """
        更新状态机
        :param dt: 时间增量
        """
        if not self.is_updating:
            return
            
        current_time = globalClock.getRealTime()
        
        # 限制更新频率
        if current_time - self.last_update_time < 1.0 / self.update_rate:
            return
            
        self.last_update_time = current_time
        
        # 更新状态转换
        if self.is_transitioning:
            self._update_transition(dt)
            
        # 检查条件转换
        self._check_conditional_transitions()
        
    def _update_transition(self, dt: float) -> None:
        """
        更新状态转换
        :param dt: 时间增量
        """
        if not self.is_transitioning or not self.previous_state or not self.current_state:
            return
            
        # 更新转换进度
        transition = None
        for t in self.transitions:
            if t.from_state == self.previous_state and t.to_state == self.current_state:
                transition = t
                break
                
        if not transition:
            self.is_transitioning = False
            return
            
        self.transition_progress += dt / transition.transition_time
        
        # 检查转换是否完成
        if self.transition_progress >= 1.0:
            self.is_transitioning = False
            self.transition_progress = 1.0
            print(f"状态转换完成: {self.previous_state} -> {self.current_state} (模型: {self.model_id})")
            return
            
        # 计算插值因子
        t = self.transition_progress
        if transition.blend_mode == InterpolationMode.EASE_IN:
            t = t * t
        elif transition.blend_mode == InterpolationMode.EASE_OUT:
            t = 1.0 - (1.0 - t) * (1.0 - t)
        elif transition.blend_mode == InterpolationMode.EASE_IN_OUT:
            t = t * t * (3.0 - 2.0 * t)
            
        # 混合两个状态的权重
        from_state = self.states[self.previous_state]
        to_state = self.states[self.current_state]
        
        # 获取所有涉及的Morph目标
        all_targets = set(from_state.morph_targets.keys()) | set(to_state.morph_targets.keys())
        
        for target_name in all_targets:
            from_weight = from_state.morph_targets.get(target_name, 0.0)
            to_weight = to_state.morph_targets.get(target_name, 0.0)
            
            # 计算混合权重
            blended_weight = from_weight * (1.0 - t) + to_weight * t
            
            # 应用权重
            self.morphing_core.set_morph_target_weight(self.model_id, target_name, blended_weight)
            
    def _check_conditional_transitions(self) -> None:
        """
        检查条件转换
        """
        if not self.current_state:
            return
            
        # 检查从当前状态出发的条件转换
        for transition in self.transitions:
            if (transition.from_state == self.current_state and 
                transition.transition_type == TransitionType.CONDITIONAL and
                transition.condition):
                
                try:
                    # 检查条件是否满足
                    if transition.condition():
                        self.trigger_transition(transition.to_state)
                        break
                except Exception as e:
                    print(f"检查转换条件时出错: {e}")
                    
    def get_state_info(self, state_name: str) -> Optional[Dict[str, Any]]:
        """
        获取状态信息
        :param state_name: 状态名称
        :return: 状态信息字典
        """
        if state_name not in self.states:
            print(f"错误: 动画状态 {state_name} 不存在")
            return None
            
        state = self.states[state_name]
        
        return {
            'name': state.name,
            'morph_targets': state.morph_targets,
            'duration': state.duration,
            'loop': state.loop,
            'play_rate': state.play_rate,
            'active': state.active
        }
        
    def get_current_state(self) -> Optional[str]:
        """
        获取当前状态
        :return: 当前状态名称
        """
        return self.current_state
        
    def start_updating(self) -> None:
        """
        开始更新状态机
        """
        if not self.is_updating:
            self.is_updating = True
            print(f"动画状态机更新已启动 (模型: {self.model_id})")
            
    def stop_updating(self) -> None:
        """
        停止更新状态机
        """
        if self.is_updating:
            self.is_updating = False
            print(f"动画状态机更新已停止 (模型: {self.model_id})")

class AnimationCurveEditor:
    """
    动画曲线编辑器
    支持对动画属性进行曲线编辑和自定义
    """
    
    def __init__(self, morphing_core: MorphingCore):
        """
        初始化动画曲线编辑器
        :param morphing_core: Morphing核心系统
        """
        self.morphing_core = morphing_core
        self.curves: Dict[str, AnimationCurve] = {}
        self.curve_values: Dict[str, List[Tuple[float, float]]] = {}  # {curve_name: [(time, value)]}
        self.is_updating = False
        self.update_rate = ADVANCED_SETTINGS['curve_editor_points']
        self.last_update_time: float = 0.0
        
        print("动画曲线编辑器初始化完成")
        
    def create_curve(self, curve_name: str, curve_type: CurveType,
                    control_points: List[Tuple[float, float]],
                    interpolation: InterpolationMode = InterpolationMode.LINEAR) -> bool:
        """
        创建动画曲线
        :param curve_name: 曲线名称
        :param curve_type: 曲线类型
        :param control_points: 控制点列表 [(time, value)]
        :param interpolation: 插值模式
        :return: 是否成功创建
        """
        # 验证控制点
        if not control_points:
            print(f"错误: 控制点列表为空")
            return False
            
        # 按时间排序控制点
        sorted_points = sorted(control_points, key=lambda p: p[0])
        
        # 创建曲线
        curve = AnimationCurve(
            name=curve_name,
            curve_type=curve_type,
            control_points=sorted_points,
            interpolation=interpolation,
            active=True
        )
        
        # 存储曲线
        self.curves[curve_name] = curve
        
        # 预计算曲线值
        self._precompute_curve_values(curve_name)
        
        print(f"动画曲线已创建: {curve_name}")
        return True
        
    def remove_curve(self, curve_name: str) -> bool:
        """
        移除动画曲线
        :param curve_name: 曲线名称
        :return: 是否成功移除
        """
        if curve_name not in self.curves:
            print(f"错误: 动画曲线 {curve_name} 不存在")
            return False
            
        del self.curves[curve_name]
        
        if curve_name in self.curve_values:
            del self.curve_values[curve_name]
            
        print(f"动画曲线已移除: {curve_name}")
        return True
        
    def _precompute_curve_values(self, curve_name: str) -> None:
        """
        预计算曲线值
        :param curve_name: 曲线名称
        """
        if curve_name not in self.curves:
            return
            
        curve = self.curves[curve_name]
        values = []
        
        # 根据曲线类型生成值
        if curve.curve_type == CurveType.LINEAR:
            values = self._compute_linear_curve(curve.control_points)
        elif curve.curve_type == CurveType.BEZIER:
            values = self._compute_bezier_curve(curve.control_points)
        elif curve.curve_type == CurveType.SPLINE:
            values = self._compute_spline_curve(curve.control_points)
        elif curve.curve_type == CurveType.STEP:
            values = self._compute_step_curve(curve.control_points)
        elif curve.curve_type == CurveType.NOISE:
            values = self._compute_noise_curve(curve.control_points)
            
        self.curve_values[curve_name] = values
        
    def _compute_linear_curve(self, control_points: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
        """
        计算线性曲线值
        :param control_points: 控制点列表
        :return: 曲线值列表
        """
        if len(control_points) < 2:
            return control_points
            
        values = []
        num_points = ADVANCED_SETTINGS['curve_editor_points']
        
        for i in range(len(control_points) - 1):
            start_point = control_points[i]
            end_point = control_points[i + 1]
            
            # 计算这一段的点数
            segment_duration = end_point[0] - start_point[0]
            total_duration = control_points[-1][0] - control_points[0][0]
            segment_points = int(num_points * (segment_duration / total_duration)) if total_duration > 0 else num_points
            
            for j in range(segment_points):
                t = j / max(1, segment_points - 1)
                time = start_point[0] + (end_point[0] - start_point[0]) * t
                value = start_point[1] + (end_point[1] - start_point[1]) * t
                values.append((time, value))
                
        return values
        
    def _compute_bezier_curve(self, control_points: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
        """
        计算贝塞尔曲线值
        :param control_points: 控制点列表
        :return: 曲线值列表
        """
        if len(control_points) < 2:
            return control_points
            
        values = []
        num_points = ADVANCED_SETTINGS['curve_editor_points']
        
        # 对于贝塞尔曲线，我们使用相邻的4个点
        for i in range(max(0, len(control_points) - 3)):
            if i + 3 >= len(control_points):
                break
                
            p0 = control_points[i]
            p1 = control_points[i + 1]
            p2 = control_points[i + 2]
            p3 = control_points[i + 3]
            
            # 计算这一段的点数
            segment_points = num_points // max(1, len(control_points) - 3)
            
            for j in range(segment_points):
                t = j / max(1, segment_points - 1)
                
                # 贝塞尔曲线公式
                x = ((1 - t) ** 3) * p0[0] + 3 * ((1 - t) ** 2) * t * p1[0] + 3 * (1 - t) * (t ** 2) * p2[0] + (t ** 3) * p3[0]
                y = ((1 - t) ** 3) * p0[1] + 3 * ((1 - t) ** 2) * t * p1[1] + 3 * (1 - t) * (t ** 2) * p2[1] + (t ** 3) * p3[1]
                
                values.append((x, y))
                
        return values
        
    def _compute_spline_curve(self, control_points: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
        """
        计算样条曲线值
        :param control_points: 控制点列表
        :return: 曲线值列表
        """
        # 简化的样条实现，使用Catmull-Rom样条
        if len(control_points) < 2:
            return control_points
            
        values = []
        num_points = ADVANCED_SETTINGS['curve_editor_points']
        
        for i in range(len(control_points) - 1):
            # 获取四个控制点（处理边界情况）
            p0 = control_points[max(0, i - 1)]
            p1 = control_points[i]
            p2 = control_points[i + 1]
            p3 = control_points[min(len(control_points) - 1, i + 2)]
            
            # 计算这一段的点数
            segment_points = num_points // max(1, len(control_points) - 1)
            
            for j in range(segment_points):
                t = j / max(1, segment_points - 1)
                
                # Catmull-Rom样条公式
                t2 = t * t
                t3 = t2 * t
                
                x = 0.5 * (
                    (2 * p1[0]) +
                    (-p0[0] + p2[0]) * t +
                    (2 * p0[0] - 5 * p1[0] + 4 * p2[0] - p3[0]) * t2 +
                    (-p0[0] + 3 * p1[0] - 3 * p2[0] + p3[0]) * t3
                )
                
                y = 0.5 * (
                    (2 * p1[1]) +
                    (-p0[1] + p2[1]) * t +
                    (2 * p0[1] - 5 * p1[1] + 4 * p2[1] - p3[1]) * t2 +
                    (-p0[1] + 3 * p1[1] - 3 * p2[1] + p3[1]) * t3
                )
                
                values.append((x, y))
                
        return values
        
    def _compute_step_curve(self, control_points: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
        """
        计算阶梯曲线值
        :param control_points: 控制点列表
        :return: 曲线值列表
        """
        if not control_points:
            return []
            
        values = []
        num_points = ADVANCED_SETTINGS['curve_editor_points']
        
        # 在每个控制点之间创建阶梯
        for i in range(len(control_points)):
            point = control_points[i]
            next_point = control_points[i + 1] if i + 1 < len(control_points) else point
            
            # 计算这一段的点数
            segment_points = num_points // max(1, len(control_points))
            
            for j in range(segment_points):
                # 阶梯曲线保持前一个点的值直到下一个点
                values.append((point[0] + (next_point[0] - point[0]) * j / max(1, segment_points - 1), point[1]))
                
        return values
        
    def _compute_noise_curve(self, control_points: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
        """
        计算噪声曲线值
        :param control_points: 控制点列表
        :return: 曲线值列表
        """
        if not control_points:
            return []
            
        values = []
        num_points = ADVANCED_SETTINGS['curve_editor_points']
        
        # 基于控制点生成噪声曲线
        for i in range(num_points):
            t = i / max(1, num_points - 1)
            
            # 计算基础值（线性插值）
            base_value = 0.0
            for j in range(len(control_points) - 1):
                if control_points[j][0] <= t <= control_points[j + 1][0]:
                    t_segment = (t - control_points[j][0]) / (control_points[j + 1][0] - control_points[j][0])
                    base_value = control_points[j][1] + (control_points[j + 1][1] - control_points[j][1]) * t_segment
                    break
                    
            # 添加噪声
            noise = (np.random.random() - 0.5) * 0.2  # ±10%的噪声
            values.append((t, base_value + noise))
            
        return values
        
    def get_curve_value(self, curve_name: str, time: float) -> Optional[float]:
        """
        获取曲线在指定时间的值
        :param curve_name: 曲线名称
        :param time: 时间
        :return: 曲线值
        """
        if curve_name not in self.curve_values:
            return None
            
        values = self.curve_values[curve_name]
        if not values:
            return None
            
        # 找到最接近的时间点
        closest_value = values[0][1]
        min_diff = abs(values[0][0] - time)
        
        for t, v in values:
            diff = abs(t - time)
            if diff < min_diff:
                min_diff = diff
                closest_value = v
                
        return closest_value
        
    def apply_curve_to_morph_target(self, curve_name: str, model_id: str, 
                                  target_name: str, time: float, 
                                  base_weight: float = 1.0) -> bool:
        """
        将曲线应用到Morph目标
        :param curve_name: 曲线名称
        :param model_id: 模型ID
        :param target_name: Morph目标名称
        :param time: 时间
        :param base_weight: 基础权重
        :return: 是否成功应用
        """
        # 获取曲线值
        curve_value = self.get_curve_value(curve_name, time)
        if curve_value is None:
            return False
            
        # 计算最终权重
        final_weight = base_weight * curve_value
        
        # 应用到Morph目标
        return self.morphing_core.set_morph_target_weight(model_id, target_name, final_weight)
        
    def get_curve_info(self, curve_name: str) -> Optional[Dict[str, Any]]:
        """
        获取曲线信息
        :param curve_name: 曲线名称
        :return: 曲线信息字典
        """
        if curve_name not in self.curves:
            print(f"错误: 动画曲线 {curve_name} 不存在")
            return None
            
        curve = self.curves[curve_name]
        
        return {
            'name': curve.name,
            'curve_type': curve.curve_type.name,
            'control_points': curve.control_points,
            'interpolation': curve.interpolation.name,
            'active': curve.active,
            'precomputed_points': len(self.curve_values.get(curve_name, []))
        }
        
    def update(self, dt: float) -> None:
        """
        更新曲线编辑器
        :param dt: 时间增量
        """
        if not self.is_updating:
            return
            
        current_time = globalClock.getRealTime()
        
        # 限制更新频率
        if current_time - self.last_update_time < 1.0 / self.update_rate:
            return
            
        self.last_update_time = current_time
        
        # 这里可以添加实时曲线编辑的更新逻辑
        pass
        
    def start_updating(self) -> None:
        """
        开始更新曲线编辑器
        """
        if not self.is_updating:
            self.is_updating = True
            print("动画曲线编辑器更新已启动")
            
    def stop_updating(self) -> None:
        """
        停止更新曲线编辑器
        """
        if self.is_updating:
            self.is_updating = False
            print("动画曲线编辑器更新已停止")

class PhysicsAnimationIntegration:
    """
    物理动画集成系统
    结合物理模拟与骨骼动画
    """
    
    def __init__(self, morphing_core: MorphingCore):
        """
        初始化物理动画集成系统
        :param morphing_core: Morphing核心系统
        """
        self.morphing_core = morphing_core
        self.constraints: Dict[str, Dict[str, PhysicsConstraint]] = {}  # {model_id: {constraint_name: PhysicsConstraint}}
        self.is_updating = False
        self.update_rate = ADVANCED_SETTINGS['physics_update_rate']
        self.last_update_time: float = 0.0
        
        print("物理动画集成系统初始化完成")
        
    def add_constraint(self, model_id: str, constraint_name: str, constraint_type: str,
                      target_bone: str, stiffness: float = 1.0, damping: float = 0.1,
                      rest_value: float = 0.0) -> bool:
        """
        添加物理约束
        :param model_id: 模型ID
        :param constraint_name: 约束名称
        :param constraint_type: 约束类型 ('spring', 'distance', 'angle')
        :param target_bone: 目标骨骼
        :param stiffness: 刚度
        :param damping: 阻尼
        :param rest_value: 静止值
        :return: 是否成功添加
        """
        if model_id not in self.morphing_core.model_data:
            print(f"错误: 模型 {model_id} 未注册")
            return False
            
        # 创建约束
        constraint = PhysicsConstraint(
            name=constraint_name,
            constraint_type=constraint_type,
            target_bone=target_bone,
            stiffness=stiffness,
            damping=damping,
            rest_value=rest_value,
            active=True
        )
        
        # 存储约束
        if model_id not in self.constraints:
            self.constraints[model_id] = {}
        self.constraints[model_id][constraint_name] = constraint
        
        print(f"物理约束已添加: {constraint_name} (模型: {model_id})")
        return True
        
    def remove_constraint(self, model_id: str, constraint_name: str) -> bool:
        """
        移除物理约束
        :param model_id: 模型ID
        :param constraint_name: 约束名称
        :return: 是否成功移除
        """
        if model_id not in self.constraints or constraint_name not in self.constraints[model_id]:
            print(f"错误: 物理约束 {constraint_name} 不存在于模型 {model_id} 中")
            return False
            
        del self.constraints[model_id][constraint_name]
        print(f"物理约束已移除: {constraint_name} (模型: {model_id})")
        return True
        
    def update(self, dt: float) -> None:
        """
        更新物理动画集成系统
        :param dt: 时间增量
        """
        if not self.is_updating:
            return
            
        current_time = globalClock.getRealTime()
        
        # 限制更新频率
        if current_time - self.last_update_time < 1.0 / self.update_rate:
            return
            
        self.last_update_time = current_time
        
        # 更新每个模型的物理约束
        for model_id, constraints in self.constraints.items():
            self._update_model_constraints(model_id, constraints, dt)
            
    def _update_model_constraints(self, model_id: str, constraints: Dict[str, PhysicsConstraint], dt: float) -> None:
        """
        更新模型的物理约束
        :param model_id: 模型ID
        :param constraints: 约束字典
        :param dt: 时间增量
        """
        # 这里实现简化的弹簧物理系统
        for constraint_name, constraint in constraints.items():
            if not constraint.active:
                continue
                
            # 根据约束类型应用不同的物理效果
            if constraint.constraint_type == 'spring':
                self._apply_spring_constraint(model_id, constraint, dt)
            elif constraint.constraint_type == 'distance':
                self._apply_distance_constraint(model_id, constraint, dt)
            elif constraint.constraint_type == 'angle':
                self._apply_angle_constraint(model_id, constraint, dt)
                
    def _apply_spring_constraint(self, model_id: str, constraint: PhysicsConstraint, dt: float) -> None:
        """
        应用弹簧约束
        :param model_id: 模型ID
        :param constraint: 约束对象
        :param dt: 时间增量
        """
        # 简化的弹簧物理实现
        # 在实际项目中，这里会涉及更复杂的物理计算
        
        # 模拟弹簧运动
        # F = -k * x - d * v (胡克定律与阻尼)
        
        # 获取当前值（这里简化处理）
        current_value = 0.0  # 在实际实现中，需要获取当前的morph目标权重或其他值
        
        # 计算位移
        displacement = current_value - constraint.rest_value
        
        # 计算力
        force = -constraint.stiffness * displacement  # 弹簧力
        # 这里简化处理，省略速度和阻尼计算
        
        # 计算加速度 (F = ma, 假设质量为1)
        acceleration = force
        
        # 更新值（简化积分）
        new_value = current_value + acceleration * dt * dt
        
        # 应用到目标（示例：应用到morph目标）
        # self.morphing_core.set_morph_target_weight(model_id, constraint.target_bone, new_value)
        
    def _apply_distance_constraint(self, model_id: str, constraint: PhysicsConstraint, dt: float) -> None:
        """
        应用距离约束
        :param model_id: 模型ID
        :param constraint: 约束对象
        :param dt: 时间增量
        """
        # 距离约束实现
        pass  # 简化处理，实际项目中需要具体实现
        
    def _apply_angle_constraint(self, model_id: str, constraint: PhysicsConstraint, dt: float) -> None:
        """
        应用角度约束
        :param model_id: 模型ID
        :param constraint: 约束对象
        :param dt: 时间增量
        """
        # 角度约束实现
        pass  # 简化处理，实际项目中需要具体实现
        
    def get_constraint_info(self, model_id: str, constraint_name: str) -> Optional[Dict[str, Any]]:
        """
        获取约束信息
        :param model_id: 模型ID
        :param constraint_name: 约束名称
        :return: 约束信息字典
        """
        if model_id not in self.constraints or constraint_name not in self.constraints[model_id]:
            print(f"错误: 物理约束 {constraint_name} 不存在于模型 {model_id} 中")
            return None
            
        constraint = self.constraints[model_id][constraint_name]
        
        return {
            'name': constraint.name,
            'constraint_type': constraint.constraint_type,
            'target_bone': constraint.target_bone,
            'stiffness': constraint.stiffness,
            'damping': constraint.damping,
            'rest_value': constraint.rest_value,
            'active': constraint.active
        }
        
    def start_updating(self) -> None:
        """
        开始更新物理动画集成系统
        """
        if not self.is_updating:
            self.is_updating = True
            print("物理动画集成系统更新已启动")
            
    def stop_updating(self) -> None:
        """
        停止更新物理动画集成系统
        """
        if self.is_updating:
            self.is_updating = False
            print("物理动画集成系统更新已停止")