#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""
旋转脚本 - 让对象持续旋转
"""

from core.script_system import ScriptBase


class RotatorScript(ScriptBase):
    """旋转脚本类"""

    def __init__(self):
        super().__init__()
        self.rotation_speed_y = 30.0  # Y轴旋转速度 (度/秒)
        self.max_angle = 25.0  # 最大旋转角度（相对于初始角度）
        self.direction = 1
        self.current_offset = 0.0  # 当前相对于初始角度的偏移
        self.initial_angle = None  # 模型的初始角度
        self.is_rotating = True  # 是否正在旋转

        # 机器人式停顿参数
        self.pause_duration = 0.5  # 停顿时间（秒）
        self.current_pause_time = 0.0  # 当前停顿计时
        self.is_paused = False  # 是否正在停顿
        self.robot_mode = True  # 是否启用机器人模式

    def start(self):
        """脚本开始时调用"""
        self.log("机器人旋转脚本启动！")
        self.log(f"旋转速度: {self.rotation_speed_y}度/秒")
        self.log(f"最大旋转角度: ±{self.max_angle}度")
        self.log(f"机器人模式: {'开启' if self.robot_mode else '关闭'}")
        if self.robot_mode:
            self.log(f"停顿时间: {self.pause_duration}秒")

        # 记录模型的初始角度
        if self.gameObject:
            initial_hpr = self.gameObject.getHpr()
            self.initial_angle = initial_hpr.getY()  # 记录Y轴的初始角度（Pitch）
            self.log(f"模型初始角度: {self.initial_angle}度")
            self.log(f"旋转范围: {self.initial_angle - self.max_angle}° 到 {self.initial_angle + self.max_angle}°")
        else:
            self.log("⚠️ 无法获取游戏对象，使用默认初始角度0")
            self.initial_angle = 0.0

    def update(self, dt):
        """每帧更新 - 机器人式旋转"""
        if not self.is_rotating or self.initial_angle is None:
            return

        # 如果正在停顿中
        if self.is_paused:
            self.current_pause_time += dt
            if self.current_pause_time >= self.pause_duration:
                # 停顿结束，继续旋转
                self.is_paused = False
                self.current_pause_time = 0.0
                self.log(f"停顿结束，继续旋转，方向: {'正向' if self.direction > 0 else '反向'}")
            return

        # 计算角度变化量
        delta_angle = self.rotation_speed_y * dt * self.direction
        self.current_offset += delta_angle

        # 检查是否到达边界
        reached_boundary = False
        if self.current_offset > self.max_angle:
            self.current_offset = self.max_angle
            self.direction *= -1
            reached_boundary = True
        elif self.current_offset < -self.max_angle:
            self.current_offset = -self.max_angle
            self.direction *= -1
            reached_boundary = True

        # 如果到达边界且启用机器人模式，开始停顿
        if reached_boundary and self.robot_mode:
            self.is_paused = True
            self.current_pause_time = 0.0
            self.log(f"到达边界 ({self.current_offset}°)，开始停顿 {self.pause_duration}秒")

        # 计算最终角度（初始角度 + 偏移量）
        final_angle = self.initial_angle + self.current_offset

        # 设置新的旋转（只改变Y轴，保持其他不变）
        current_hpr = self.gameObject.getHpr()
        self.gameObject.setHpr(current_hpr.getX(), final_angle, current_hpr.getZ())

        # if not self.is_rotating:
        #     return
        #
        # # 获取当前旋转并应用增量
        # current_hpr = self.gameObject.getHpr()
        # new_r = current_hpr.getZ() + self.rotation_speed_y * dt
        # self.gameObject.setHpr(current_hpr.getX(), current_hpr.getY(), new_r)

    def on_destroy(self):
        """脚本销毁时调用"""
        self.log("机器人旋转脚本停止")

    # ==================== 机器人模式控制方法 ====================

    def set_robot_mode(self, enabled=True):
        """
        启用或禁用机器人模式

        Args:
            enabled: 是否启用机器人模式
        """
        self.robot_mode = enabled
        self.log(f"机器人模式: {'开启' if enabled else '关闭'}")
        if not enabled:
            self.is_paused = False  # 如果禁用机器人模式，立即结束停顿

    def set_pause_duration(self, duration):
        """
        设置停顿时间

        Args:
            duration: 停顿时间（秒）
        """
        self.pause_duration = max(0.1, duration)  # 最小0.1秒
        self.log(f"停顿时间已设置为: {self.pause_duration}秒")

    def set_max_angle(self, new_max_angle):
        """
        设置新的最大旋转角度

        Args:
            new_max_angle: 新的最大角度值
        """
        self.max_angle = new_max_angle
        self.log(f"最大旋转角度已设置为: ±{self.max_angle}度")
        if self.initial_angle is not None:
            self.log(f"新的旋转范围: {self.initial_angle - self.max_angle}° 到 {self.initial_angle + self.max_angle}°")

    def set_rotation_speed(self, new_speed):
        """
        设置新的旋转速度

        Args:
            new_speed: 新的旋转速度（度/秒）
        """
        self.rotation_speed_y = new_speed
        self.log(f"旋转速度已设置为: {self.rotation_speed_y}度/秒")

    def pause_rotation(self):
        """暂停旋转"""
        self.is_rotating = False
        self.log("旋转已暂停")

    def resume_rotation(self):
        """恢复旋转"""
        self.is_rotating = True
        self.is_paused = False  # 同时结束停顿状态
        self.log("旋转已恢复")

    def reset_to_initial_angle(self):
        """重置到初始角度"""
        if self.initial_angle is not None and self.gameObject:
            current_hpr = self.gameObject.getHpr()
            self.gameObject.setHpr(current_hpr.getX(), self.initial_angle, current_hpr.getZ())
            self.current_offset = 0.0
            self.direction = 1
            self.is_paused = False
            self.current_pause_time = 0.0
            self.log(f"已重置到初始角度: {self.initial_angle}度")

    def get_current_info(self):
        """获取当前旋转信息"""
        if self.gameObject and self.initial_angle is not None:
            current_hpr = self.gameObject.getHpr()
            current_angle = current_hpr.getY()
            self.log("=== 机器人旋转信息 ===")
            self.log(f"初始角度: {self.initial_angle}度")
            self.log(f"当前角度: {current_angle}度")
            self.log(f"偏移量: {self.current_offset}度")
            self.log(f"最大角度: ±{self.max_angle}度")
            self.log(f"旋转速度: {self.rotation_speed_y}度/秒")
            self.log(f"旋转方向: {'正向' if self.direction > 0 else '反向'}")
            self.log(f"旋转状态: {'运行中' if self.is_rotating else '已暂停'}")
            self.log(f"机器人模式: {'开启' if self.robot_mode else '关闭'}")
            if self.robot_mode:
                self.log(f"停顿时间: {self.pause_duration}秒")
                self.log(f"当前状态: {'停顿中' if self.is_paused else '旋转中'}")
                if self.is_paused:
                    remaining_time = self.pause_duration - self.current_pause_time
                    self.log(f"剩余停顿时间: {remaining_time:.1f}秒")
            self.log("=== 信息结束 ===")
        else:
            self.log("无法获取旋转信息")

    # ==================== 预设配置方法 ====================

    def set_slow_robot_mode(self):
        """预设：慢速机器人模式"""
        self.set_rotation_speed(15.0)
        self.set_pause_duration(1.0)
        self.set_robot_mode(True)
        self.log("已设置为慢速机器人模式")

    def set_fast_robot_mode(self):
        """预设：快速机器人模式"""
        self.set_rotation_speed(45.0)
        self.set_pause_duration(0.3)
        self.set_robot_mode(True)
        self.log("已设置为快速机器人模式")

    def set_smooth_mode(self):
        """预设：平滑模式（非机器人）"""
        self.set_robot_mode(False)
        self.set_rotation_speed(30.0)
        self.log("已设置为平滑旋转模式")