using UnityEngine;
using UnityEngine.Rendering.Universal;
using System.Collections;
using System.Collections.Generic;
using DG.Tweening;

namespace AibisDream.FixSystem
{
    /// <summary>
    /// 灯光系统控制器，管理呼吸灯、小灯、环境灯、面板灯和警报灯的状态
    /// </summary>
    public class FixLightSystem : MonoBehaviour
    {
        #region 枚举定义

        /// <summary>
        /// 灯光状态
        /// </summary>
        public enum LightState
        {
            Normal,     // 正常状态
            Warning,    // 警告状态
            Emergency   // 紧急状态
        }


        #endregion

        #region 常量定义

        private const float SYSTEM_OFF_ENVIRONMENT_INTENSITY = 0.4f;
        private const float SELF_CHECK_DELAY = 0.05f;
        private const float SELF_CHECK_INTERVAL = 0.1f;
        private const float ECG_WAVE_TOGGLE_DELAY = 0.1f;
        private const float ECG_WAVE_FINAL_DELAY = 0.2f;
        private const float BREATHING_LIGHT_START_DELAY = 0.5f;
        private const float ALARM_LIGHT_MAX_INTENSITY = 4f;
        private const float BREATHING_LIGHT_MAX_INTENSITY = 1f;
        private const int SELF_CHECK_COUNT = 2;
        private const int MIN_FLICKER_BLINK_COUNT = 2;
        private const int MAX_FLICKER_BLINK_COUNT = 4;
        private const float MIN_FLICKER_INTERVAL = 3f;
        private const float MAX_FLICKER_INTERVAL = 8f;

        #endregion

        #region 呼吸灯相关字段

        [Header("呼吸灯设置")]
        [SerializeField] private Light2D breathingLight;
        [SerializeField] private float normalBreathingSpeed = 1f;
        [SerializeField] private float warningBreathingSpeed = 2f;
        [SerializeField] private float emergencyBreathingSpeed = 3f;
        [SerializeField] private Color normalColor = Color.green;
        [SerializeField] private Color warningColor = Color.yellow;
        [SerializeField] private Color emergencyColor = Color.red;
        [SerializeField] private RobotECGWave ecgWave;

        private SpriteRenderer breathingLightSprite;
        private Tween breathingTween;

        #endregion

        #region 小灯相关字段

        [Header("小灯设置")]
        [SerializeField] private List<Light2D> smallLights = new List<Light2D>();
        [SerializeField] private float smallLightBlinkInterval = 0.5f;
        [SerializeField] private Color smallLightDefaultColor = Color.yellow;
        [SerializeField] private Color smallLightNormalColor = Color.green;
        [SerializeField] private Color smallLightErrorColor = Color.red;
        [SerializeField] private float operationBlinkDuration = 1f;
        [SerializeField] private float operationBlinkInterval = 0.1f;

        private List<SpriteRenderer> smallLightSprites = new List<SpriteRenderer>();
        private SmallLightState smallLightState = SmallLightState.Default;
        private SmallLightStatus smallLightStatus = SmallLightStatus.Normal;

        #endregion

        #region 环境灯相关字段

        [Header("环境灯设置")]
        [SerializeField] private Light2D environmentLight;
        [SerializeField] private bool isEnvironmentLightFlickering = false;
        [SerializeField] private float normalEnvironmentIntensity = 1f;
        [SerializeField] private float warningEnvironmentIntensity = 1f;
        [SerializeField] private float emergencyEnvironmentIntensity = 1f;
        [SerializeField] private float brokenLightFlickerInterval = 0.1f;
        [SerializeField] private float brokenLightFlickerDuration = 0.05f;
        [SerializeField] private float brokenLightPatternInterval = 2f;
        [SerializeField] private float brokenLightDarkDuration = 0.8f;
        [SerializeField] private Color normalEnvironmentColor = Color.white;
        [SerializeField] private Color warningEnvironmentColor = Color.yellow;
        [SerializeField] private Color emergencyEnvironmentColor = Color.red;

        #endregion

        #region 面板灯相关字段

        [Header("面板灯设置")]
        [SerializeField] private Light2D panelLight;
        [SerializeField] private float panelLightIntensity = 1f;
        [SerializeField] private float panelLightBlinkDuration = 0.2f;
        [SerializeField] private int panelLightBlinkCount = 2;
        [SerializeField] private Color panelLightColor = Color.white;

        #endregion

        #region 警报灯相关字段

        [Header("警报灯设置")]
        [SerializeField] private Light2D alarmLight;
        [SerializeField] private float alarmBlinkSpeed = 0.5f;
        [SerializeField] private Color alarmLightColor = Color.red;

        private Tween alarmTween;

        #endregion

        #region 系统状态相关字段

        [SerializeField] private bool isSystemOn = false;
        private LightState currentState = LightState.Normal;
        private bool isSystemStarting = false;

        #endregion

        #region Unity生命周期方法

        private void Awake()
        {
            // 初始化SpriteRenderer引用
            InitializeSpriteRenderers();
        }

        private void Start()
        {
            InitializeSystemState();
            SetEnvironmentLightBroken();
            SetEnvironmentLightFlickering(isEnvironmentLightFlickering);
            StartCoroutine(SmallLightsBlinkRoutine());
            SetSmallLightState(SmallLightState.Default);
        }

        private void OnDestroy()
        {
            // 清理所有Tween
            breathingTween?.Kill();
            alarmTween?.Kill();
        }

        #endregion

        #region 初始化方法

        /// <summary>
        /// 初始化SpriteRenderer引用
        /// </summary>
        private void InitializeSpriteRenderers()
        {
            // 自动获取呼吸灯的SpriteRenderer
            if (breathingLight != null)
            {
                breathingLightSprite = breathingLight.GetComponentInParent<SpriteRenderer>();
            }

            // 自动获取小灯的SpriteRenderer
            smallLightSprites.Clear();
            foreach (var light in smallLights)
            {
                if (light != null)
                {
                    var spriteRenderer = light.GetComponentInParent<SpriteRenderer>();
                    smallLightSprites.Add(spriteRenderer);
                }
            }
        }

        /// <summary>
        /// 初始化系统状态
        /// </summary>
        private void InitializeSystemState()
        {
            if (isSystemOn)
            {
                InitializeSystemOn();
            }
            else
            {
                InitializeSystemOff();
            }
        }

        /// <summary>
        /// 系统开启时的初始化
        /// </summary>
        private void InitializeSystemOn()
        {
            SetBreathingLight(normalColor, BREATHING_LIGHT_MAX_INTENSITY);
            InitializeSmallLights(smallLightDefaultColor, BREATHING_LIGHT_MAX_INTENSITY);
            SetPanelLight(panelLightColor, panelLightIntensity);
            SetECGWaveActive(true);
            SetEnvironmentLightIntensity(normalEnvironmentIntensity);
        }

        /// <summary>
        /// 系统关闭时的初始化
        /// </summary>
        private void InitializeSystemOff()
        {
            SetBreathingLight(normalColor, 0f, true);
            TurnOffAllSmallLights();
            SetPanelLight(panelLightColor, 0f);
            SetECGWaveActive(false);
            SetEnvironmentLightIntensity(SYSTEM_OFF_ENVIRONMENT_INTENSITY);
        }

        #endregion

        #region 公共方法 - 系统控制

        /// <summary>
        /// 检查系统是否开启
        /// </summary>
        public bool IsSystemOn()
        {
            return isSystemOn;
        }

        /// <summary>
        /// 设置系统电源状态
        /// </summary>
        public void SetSystemPower(bool isOn)
        {
            isSystemOn = isOn;
            if (!isOn)
            {
                TurnOffAllLights();
            }
            else
            {
                UpdateLightsState();
            }
        }

        /// <summary>
        /// 启动系统
        /// </summary>
        public IEnumerator StartSystem()
        {
            if (isSystemStarting || isSystemOn) yield break;

            isSystemStarting = true;
            yield return StartCoroutine(SystemStartSequence());
            isSystemStarting = false;
        }

        #endregion

        #region 公共方法 - 灯光状态控制

        /// <summary>
        /// 设置灯光状态
        /// </summary>
        public void SetLightState(LightState newState)
        {
            if (!isSystemOn) return;

            if (currentState != newState)
            {
                currentState = newState;
                UpdateLightsState();
                Debug.Log($"灯光状态已切换为: {newState}");
            }
        }

        /// <summary>
        /// 设置小灯状态
        /// </summary>
        public void SetSmallLightState(SmallLightState newState)
        {
            if (smallLightState != newState)
            {
                smallLightState = newState;
                if (newState == SmallLightState.Default)
                {
                    smallLightStatus = SmallLightStatus.Normal;
                }
                StartCoroutine(HandleSmallLightStateChange());
            }
        }

        /// <summary>
        /// 设置小灯状态状态
        /// </summary>
        public void SetSmallLightStatus(SmallLightStatus newStatus)
        {
            if (smallLightStatus != newStatus)
            {
                smallLightStatus = newStatus;
                UpdateSmallLightsStatus();
            }
        }

        /// <summary>
        /// 设置环境灯闪烁状态
        /// </summary>
        public void SetEnvironmentLightFlickering(bool isFlickering)
        {
            if (isEnvironmentLightFlickering != isFlickering)
            {
                isEnvironmentLightFlickering = isFlickering;
                if (isFlickering)
                {
                    StartCoroutine(EnvironmentLightFlickerRoutine());
                }
            }
        }

        /// <summary>
        /// 设置环境灯损坏状态
        /// </summary>
        public void SetEnvironmentLightBroken()
        {
            if (environmentLight != null)
            {
                environmentLight.color = GetEnvironmentColorByState(currentState);
            }
        }

        /// <summary>
        /// 设置警报灯闪烁速度
        /// </summary>
        public void SetAlarmBlinkSpeed(float speed)
        {
            if (speed > 0)
            {
                alarmBlinkSpeed = speed;
                // 如果当前正在闪烁，更新闪烁速度
                if (currentState == LightState.Emergency && alarmLight != null)
                {
                    StartAlarmLightBlink();
                }
            }
        }

        /// <summary>
        /// 停止警报灯
        /// </summary>
        public void StopAlarmLight()
        {
            if (alarmLight != null)
            {
                alarmTween?.Kill();
                alarmLight.intensity = 0f;
            }
        }

        #endregion

        #region 公共方法 - ECG波形控制

        /// <summary>
        /// 获取当前波形类型
        /// </summary>
        public RobotECGWave.WaveType GetCurrentWaveType()
        {
            return ecgWave?.waveType ?? RobotECGWave.WaveType.RobotECG;
        }

        /// <summary>
        /// 设置波形类型
        /// </summary>
        public void SetWaveType(RobotECGWave.WaveType waveType)
        {
            if (ecgWave != null)
            {
                ecgWave.SetWaveType(waveType);
            }
        }

        #endregion

        #region 私有方法 - 灯光状态更新

        /// <summary>
        /// 更新所有灯光状态
        /// </summary>
        private void UpdateLightsState()
        {
            var stateConfig = GetStateConfig(currentState);

            UpdateAlarmLight(stateConfig);
            UpdateBreathingLight(stateConfig);
            UpdateECGWave(stateConfig);
            UpdateEnvironmentLight(stateConfig);
        }

        /// <summary>
        /// 获取状态配置
        /// </summary>
        private (Color color, float breathingSpeed, RobotECGWave.WaveType waveType, Color envColor, float envIntensity) GetStateConfig(LightState state)
        {
            return state switch
            {
                LightState.Normal => (normalColor, normalBreathingSpeed, RobotECGWave.WaveType.RobotECG, normalEnvironmentColor, normalEnvironmentIntensity),
                LightState.Warning => (warningColor, warningBreathingSpeed, RobotECGWave.WaveType.Warning, warningEnvironmentColor, warningEnvironmentIntensity),
                LightState.Emergency => (emergencyColor, emergencyBreathingSpeed, RobotECGWave.WaveType.Noise, normalEnvironmentColor, normalEnvironmentIntensity),
                _ => (normalColor, normalBreathingSpeed, RobotECGWave.WaveType.RobotECG, normalEnvironmentColor, normalEnvironmentIntensity)
            };
        }

        /// <summary>
        /// 更新警报灯
        /// </summary>
        private void UpdateAlarmLight((Color color, float breathingSpeed, RobotECGWave.WaveType waveType, Color envColor, float envIntensity) config)
        {
            if (alarmLight == null) return;

            if (currentState == LightState.Emergency)
            {
                alarmLight.color = alarmLightColor;
                StartAlarmLightBlink();
            }
            else
            {
                StopAlarmLight();
            }
        }

        /// <summary>
        /// 启动警报灯闪烁
        /// </summary>
        private void StartAlarmLightBlink()
        {
            if (alarmLight == null) return;

            alarmTween?.Kill();
            alarmTween = DOTween.To(
                () => alarmLight.intensity,
                x => alarmLight.intensity = x,
                ALARM_LIGHT_MAX_INTENSITY,
                alarmBlinkSpeed
            )
            .SetLoops(-1, LoopType.Yoyo)
            .SetEase(Ease.InOutSine);
        }

        /// <summary>
        /// 更新呼吸灯
        /// </summary>
        private void UpdateBreathingLight((Color color, float breathingSpeed, RobotECGWave.WaveType waveType, Color envColor, float envIntensity) config)
        {
            if (breathingLight == null)
            {
                Debug.LogWarning("呼吸灯组件未设置！");
                return;
            }

            SetBreathingLight(config.color, BREATHING_LIGHT_MAX_INTENSITY);
            StartBreathingEffect(config.breathingSpeed);
        }

        /// <summary>
        /// 启动呼吸效果
        /// </summary>
        private void StartBreathingEffect(float breathingSpeed)
        {
            breathingTween?.Kill();
            breathingTween = DOTween.To(
                () => breathingLight.intensity,
                x => breathingLight.intensity = x,
                BREATHING_LIGHT_MAX_INTENSITY,
                1f / breathingSpeed
            )
            .SetLoops(-1, LoopType.Yoyo)
            .SetEase(Ease.InOutSine);
        }

        /// <summary>
        /// 更新ECG波形
        /// </summary>
        private void UpdateECGWave((Color color, float breathingSpeed, RobotECGWave.WaveType waveType, Color envColor, float envIntensity) config)
        {
            if (ecgWave != null)
            {
                ecgWave.SetWaveType(config.waveType);
            }
            else
            {
                Debug.LogWarning("ECG波形组件未设置！");
            }
        }

        /// <summary>
        /// 更新环境灯
        /// </summary>
        private void UpdateEnvironmentLight((Color color, float breathingSpeed, RobotECGWave.WaveType waveType, Color envColor, float envIntensity) config)
        {
            if (environmentLight == null) return;

            environmentLight.color = config.envColor;
            float targetIntensity = isSystemOn ? config.envIntensity : SYSTEM_OFF_ENVIRONMENT_INTENSITY;
            environmentLight.intensity = targetIntensity;
        }

        #endregion

        #region 私有方法 - 灯光设置辅助方法

        /// <summary>
        /// 设置呼吸灯
        /// </summary>
        private void SetBreathingLight(Color color, float intensity, bool useTransparent = false)
        {
            if (breathingLight != null)
            {
                breathingLight.color = color;
                breathingLight.intensity = intensity;
            }

            if (breathingLightSprite != null)
            {
                breathingLightSprite.color = useTransparent
                    ? new Color(color.r, color.g, color.b, 0f)
                    : color;
            }
        }

        /// <summary>
        /// 设置面板灯
        /// </summary>
        private void SetPanelLight(Color color, float intensity)
        {
            if (panelLight != null)
            {
                panelLight.color = color;
                panelLight.intensity = intensity;
            }
        }

        /// <summary>
        /// 设置环境灯强度
        /// </summary>
        private void SetEnvironmentLightIntensity(float intensity)
        {
            if (environmentLight != null)
            {
                environmentLight.intensity = intensity;
            }
        }

        /// <summary>
        /// 设置ECG波形激活状态
        /// </summary>
        private void SetECGWaveActive(bool active)
        {
            if (ecgWave != null)
            {
                ecgWave.gameObject.SetActive(active);
            }
        }

        /// <summary>
        /// 初始化小灯
        /// </summary>
        private void InitializeSmallLights(Color color, float intensity)
        {
            SetSmallLightsColorAndIntensity(color, intensity);
        }

        /// <summary>
        /// 设置小灯颜色和强度
        /// </summary>
        private void SetSmallLightsColorAndIntensity(Color color, float intensity)
        {
            for (int i = 0; i < smallLights.Count; i++)
            {
                if (smallLights[i] != null)
                {
                    smallLights[i].color = color;
                    smallLights[i].intensity = intensity;
                }

                if (i < smallLightSprites.Count && smallLightSprites[i] != null)
                {
                    smallLightSprites[i].color = color;
                }
            }
        }

        /// <summary>
        /// 关闭所有小灯
        /// </summary>
        private void TurnOffAllSmallLights()
        {
            SetSmallLightsColorAndIntensity(Color.clear, 0f);
        }

        /// <summary>
        /// 关闭所有灯光
        /// </summary>
        private void TurnOffAllLights()
        {
            SetBreathingLight(normalColor, 0f, true);
            SetPanelLight(panelLightColor, 0f);
            SetECGWaveActive(false);
            TurnOffAllSmallLights();
        }

        /// <summary>
        /// 根据状态获取环境灯颜色
        /// </summary>
        private Color GetEnvironmentColorByState(LightState state)
        {
            return state switch
            {
                LightState.Normal => normalEnvironmentColor,
                LightState.Warning => warningEnvironmentColor,
                LightState.Emergency => emergencyEnvironmentColor,
                _ => normalEnvironmentColor
            };
        }

        #endregion

        #region 私有方法 - 小灯相关

        /// <summary>
        /// 处理小灯状态变化
        /// </summary>
        private IEnumerator HandleSmallLightStateChange()
        {
            if (smallLightState == SmallLightState.Operation)
            {
                yield return StartCoroutine(OperationBlinkSequence());
                SetSmallLightsToOperationState();
            }
            else
            {
                ResetSmallLightsToDefault();
            }
        }

        /// <summary>
        /// 运行状态闪烁序列
        /// </summary>
        private IEnumerator OperationBlinkSequence()
        {
            float endTime = Time.time + operationBlinkDuration;
            while (Time.time < endTime)
            {
                foreach (var light in smallLights)
                {
                    if (light != null)
                    {
                        light.intensity = Random.value > 0.5f ? BREATHING_LIGHT_MAX_INTENSITY : 0f;
                    }
                }
                yield return new WaitForSeconds(operationBlinkInterval);
            }
        }

        /// <summary>
        /// 设置小灯为运行状态
        /// </summary>
        private void SetSmallLightsToOperationState()
        {
            Color targetColor = GetSmallLightColorByState(currentState);
            SetSmallLightsColorAndIntensity(targetColor, BREATHING_LIGHT_MAX_INTENSITY);
        }

        /// <summary>
        /// 根据当前状态获取小灯颜色
        /// </summary>
        private Color GetSmallLightColorByState(LightState state)
        {
            return state switch
            {
                LightState.Normal => smallLightNormalColor,
                LightState.Warning => warningColor,
                LightState.Emergency => emergencyColor,
                _ => smallLightNormalColor
            };
        }

        /// <summary>
        /// 重置小灯为默认状态
        /// </summary>
        private void ResetSmallLightsToDefault()
        {
            SetSmallLightsColorAndIntensity(smallLightDefaultColor, 0f);

            // 只有第一个灯闪烁
            if (smallLights.Count > 0 && smallLights[0] != null)
            {
                smallLights[0].intensity = BREATHING_LIGHT_MAX_INTENSITY;
                if (smallLightSprites.Count > 0 && smallLightSprites[0] != null)
                {
                    smallLightSprites[0].color = smallLightDefaultColor;
                }
            }
        }

        /// <summary>
        /// 更新小灯状态状态
        /// </summary>
        private void UpdateSmallLightsStatus()
        {
            Color targetColor = smallLightStatus == SmallLightStatus.Normal
                ? smallLightNormalColor
                : smallLightErrorColor;

            SetSmallLightsColorAndIntensity(targetColor, BREATHING_LIGHT_MAX_INTENSITY);
        }

        /// <summary>
        /// 小灯闪烁协程
        /// </summary>
        private IEnumerator SmallLightsBlinkRoutine()
        {
            while (true)
            {
                if (!isSystemOn)
                {
                    TurnOffAllSmallLights();
                }
                else if (smallLightState == SmallLightState.Default)
                {
                    ResetSmallLightsToDefault();
                }

                yield return new WaitForSeconds(smallLightBlinkInterval);
            }
        }

        #endregion

        #region 私有方法 - 环境灯相关

        /// <summary>
        /// 环境灯闪烁协程
        /// </summary>
        private IEnumerator EnvironmentLightFlickerRoutine()
        {
            while (isEnvironmentLightFlickering)
            {
                if (environmentLight == null)
                {
                    yield return new WaitForSeconds(0.1f);
                    continue;
                }

                float currentIntensity = GetEnvironmentIntensityByState(currentState);
                environmentLight.intensity = currentIntensity;

                // 等待随机间隔
                yield return new WaitForSeconds(Random.Range(MIN_FLICKER_INTERVAL, MAX_FLICKER_INTERVAL));

                // 随机闪烁
                int blinkCount = Random.Range(MIN_FLICKER_BLINK_COUNT, MAX_FLICKER_BLINK_COUNT);
                for (int i = 0; i < blinkCount; i++)
                {
                    environmentLight.intensity = 0f;
                    yield return new WaitForSeconds(brokenLightFlickerDuration);

                    environmentLight.intensity = currentIntensity;
                    yield return new WaitForSeconds(brokenLightFlickerInterval);
                }
            }

            // 确保灯光在停止闪烁时是亮着的
            if (environmentLight != null)
            {
                environmentLight.intensity = GetEnvironmentIntensityByState(currentState);
            }
        }

        /// <summary>
        /// 根据状态获取环境灯强度
        /// </summary>
        private float GetEnvironmentIntensityByState(LightState state)
        {
            return state switch
            {
                LightState.Normal => normalEnvironmentIntensity,
                LightState.Warning => warningEnvironmentIntensity,
                LightState.Emergency => emergencyEnvironmentIntensity,
                _ => normalEnvironmentIntensity
            };
        }

        #endregion

        #region 私有方法 - 系统启动序列

        /// <summary>
        /// 系统启动序列
        /// </summary>
        private IEnumerator SystemStartSequence()
        {
            // 1. ECG波形闪烁
            yield return StartCoroutine(ECGWaveToggleSequence());

            // 2. 小灯自检
            yield return StartCoroutine(SmallLightsSelfCheck());

            // 3. 启动呼吸灯
            SetBreathingLight(normalColor, BREATHING_LIGHT_MAX_INTENSITY);
            yield return new WaitForSeconds(BREATHING_LIGHT_START_DELAY);

            // 4. 启动面板灯
            yield return StartCoroutine(PanelLightStartSequence());

            // 5. 设置系统状态为开启
            SetSystemPower(true);
        }

        /// <summary>
        /// ECG波形闪烁序列
        /// </summary>
        private IEnumerator ECGWaveToggleSequence()
        {
            if (ecgWave == null) yield break;

            ecgWave.gameObject.SetActive(true);
            yield return new WaitForSeconds(ECG_WAVE_TOGGLE_DELAY);
            ecgWave.gameObject.SetActive(false);
            yield return new WaitForSeconds(ECG_WAVE_TOGGLE_DELAY);
            ecgWave.gameObject.SetActive(true);
            yield return new WaitForSeconds(ECG_WAVE_FINAL_DELAY);
        }

        /// <summary>
        /// 面板灯启动序列
        /// </summary>
        private IEnumerator PanelLightStartSequence()
        {
            if (panelLight == null) yield break;

            for (int i = 0; i < panelLightBlinkCount; i++)
            {
                // 渐亮
                DOTween.To(() => panelLight.intensity, x => panelLight.intensity = x, panelLightIntensity, panelLightBlinkDuration * 0.5f)
                    .SetEase(Ease.InOutQuad);
                DOTween.To(() => environmentLight.intensity, x => environmentLight.intensity = x, normalEnvironmentIntensity, panelLightBlinkDuration * 0.5f)
                    .SetEase(Ease.InOutQuad);
                yield return new WaitForSeconds(panelLightBlinkDuration);

                // 渐暗
                DOTween.To(() => panelLight.intensity, x => panelLight.intensity = x, 0f, panelLightBlinkDuration * 0.5f)
                    .SetEase(Ease.InOutQuad);
                DOTween.To(() => environmentLight.intensity, x => environmentLight.intensity = x, 0f, panelLightBlinkDuration * 0.5f)
                    .SetEase(Ease.InOutQuad);
                yield return new WaitForSeconds(panelLightBlinkDuration);
            }

            // 最后渐亮到常亮状态
            DOTween.To(() => panelLight.intensity, x => panelLight.intensity = x, panelLightIntensity, panelLightBlinkDuration * 0.5f)
                .SetEase(Ease.InOutQuad);
            DOTween.To(() => environmentLight.intensity, x => environmentLight.intensity = x, normalEnvironmentIntensity, panelLightBlinkDuration * 0.5f)
                .SetEase(Ease.InOutQuad);
        }

        /// <summary>
        /// 小灯自检序列
        /// </summary>
        private IEnumerator SmallLightsSelfCheck()
        {
            // 关闭所有小灯
            SetSmallLightsColorAndIntensity(Color.clear, 0f);

            // 自检两次
            for (int check = 0; check < SELF_CHECK_COUNT; check++)
            {
                // 从左到右点亮
                for (int i = 0; i < smallLights.Count; i++)
                {
                    if (smallLights[i] != null)
                    {
                        smallLights[i].color = smallLightDefaultColor;
                        smallLights[i].intensity = BREATHING_LIGHT_MAX_INTENSITY;
                    }

                    if (i < smallLightSprites.Count && smallLightSprites[i] != null)
                    {
                        smallLightSprites[i].color = smallLightDefaultColor;
                    }

                    yield return new WaitForSeconds(SELF_CHECK_DELAY);
                }

                // 关闭所有灯
                SetSmallLightsColorAndIntensity(Color.clear, 0f);
                yield return new WaitForSeconds(SELF_CHECK_INTERVAL);
            }

            // 恢复到默认状态（只有第一个灯闪烁）
            ResetSmallLightsToDefault();
        }

        #endregion
    }
}