aibis-dream/Assets/Scripts/MiniGame/HuoShan/SalesSystem/SalesYarnCommand.cs

using System.Collections;
using Yarn.Unity;
using UnityEngine;
using AibisDream.FixSystem;
using AibisDream.MiniGame.Language;

namespace AibisDream.MiniGame.HuoShan
{
    /// <summary>
    /// 销售系统的Yarn命令扩展
    /// 功能：
    /// - 发条控件命令
    /// - 滑片控制器命令
    /// - 处理器灯控制命令
    /// - 销售流程控制命令
    /// </summary>
    public static class SalesYarnCommand
    {
        #region 发条控件命令

        /// <summary>
        /// 重置发条到初始状态
        /// 用法: <<reset_crank>>
        /// </summary>
        [YarnCommand("reset_crank")]
        public static void ResetCrank()
        {
            var crankController = GetSalesManager()?.CrankController;
            if (crankController != null)
            {
                crankController.ResetCrank();
                Debug.Log("[SalesYarnCommand] 发条已重置");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到CrankController");
            }
        }

        /// <summary>
        /// 手动旋转发条到指定角度（用于测试或自动化）
        /// 用法: <<rotate_crank 180 0.5>>
        /// </summary>
        [YarnCommand("rotate_crank")]
        public static IEnumerator RotateCrank(float angle, float duration = 0.5f)
        {
            var crankController = GetSalesManager()?.CrankController;
            if (crankController != null)
            {
                Debug.Log($"[SalesYarnCommand] 旋转发条到{angle}度，时长{duration}秒");
                yield return new WaitForSeconds(duration);
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到CrankController");
            }
        }

        /// <summary>
        /// 等待发条完成（达到最大角度并释放）
        /// 用法: <<wait_crank_complete>>
        /// </summary>
        [YarnCommand("wait_crank_complete")]
        public static IEnumerator WaitCrankComplete()
        {
            var crankController = GetSalesManager()?.CrankController;
            if (crankController == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到CrankController");
                yield break;
            }

            Debug.Log("[SalesYarnCommand] 等待发条完成...");

            // 使用协程等待事件
            bool isComplete = false;
            UnityEngine.Events.UnityAction onComplete = () => isComplete = true;
            crankController.onCrankComplete.AddListener(onComplete);

            while (!isComplete)
            {
                yield return null;
            }

            crankController.onCrankComplete.RemoveListener(onComplete);
            Debug.Log("[SalesYarnCommand] 发条完成");
        }

        /// <summary>
        /// 发条逆时针转一圈的表现
        /// 用法: <<spin_crank>> 或 <<spin_crank 0.8>>
        /// </summary>
        /// <param name="duration">动画时长（秒），0 或不传则使用 CrankController 配置值</param>
        [YarnCommand("spin_crank")]
        public static IEnumerator SpinCrank(float duration = 0f)
        {
            var crankController = GetSalesManager()?.CrankController;
            if (crankController == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到CrankController");
                yield break;
            }

            crankController.PlaySpinCounterClockwise(duration > 0f ? duration : null);

            // 等待转圈完成
            while (crankController.IsSpinning)
            {
                yield return null;
            }

            Debug.Log("[SalesYarnCommand] 发条逆时针转圈完成");
        }

        /// <summary>
        /// 打开旋钮（切到展开/激活图）
        /// 用法: <<open_knob_lid>> 或 <<open_knob_lid 0.5>>
        /// </summary>
        [YarnCommand("open_knob_lid")]
        public static IEnumerator OpenKnobLid(float duration = 0f)
        {
            var knobController = GetSalesManager()?.KnobController;
            if (knobController == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到KnobController");
                yield break;
            }
            knobController.OpenLid(duration);
            float d = duration > 0f ? duration : 0.4f;
            yield return new WaitForSeconds(d);
        }

        /// <summary>
        /// 收起旋钮（切到收起图）
        /// 用法: <<close_knob_lid>> 或 <<close_knob_lid 0.5>>
        /// </summary>
        [YarnCommand("close_knob_lid")]
        public static IEnumerator CloseKnobLid(float duration = 0f)
        {
            var knobController = GetSalesManager()?.KnobController;
            if (knobController == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到KnobController");
                yield break;
            }
            knobController.CloseLid(duration);
            float d = duration > 0f ? duration : 0.4f;
            yield return new WaitForSeconds(d);
        }

        /// <summary>
        /// 旋钮交互提示：有激活图时切激活态，否则回退 _ShineFade。
        /// 用法: &lt;&lt;set_knob_highlight true&gt;&gt; / &lt;&lt;set_knob_highlight false&gt;&gt;
        /// </summary>
        [YarnCommand("set_knob_highlight")]
        public static void SetKnobHighlight(bool visible)
        {
            var knobController = GetSalesManager()?.KnobController;
            if (knobController != null)
                knobController.SetInteractionHighlightVisible(visible);
            else
                Debug.LogWarning("[SalesYarnCommand] 未找到 KnobController");
        }

        /// <summary>
        /// 发条交互提示高亮（_ShineFade）。
        /// 用法: &lt;&lt;set_crank_highlight true&gt;&gt; / &lt;&lt;set_crank_highlight false&gt;&gt;
        /// </summary>
        [YarnCommand("set_crank_highlight")]
        public static void SetCrankHighlight(bool visible)
        {
            var crankController = GetSalesManager()?.CrankController;
            if (crankController != null)
                crankController.SetInteractionHighlightVisible(visible);
            else
                Debug.LogWarning("[SalesYarnCommand] 未找到 CrankController");
        }

        #endregion

        #region 滑片控制命令

        /// <summary>
        /// 重置滑片到起始位置
        /// 用法: <<reset_slider>>
        /// </summary>
        [YarnCommand("reset_slider")]
        public static void ResetSlider()
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController != null)
            {
                sliderController.ResetPosition();
                Debug.Log("[SalesYarnCommand] 滑片已重置");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
            }
        }

        /// <summary>
        /// 滑片移动到指定角度
        /// 用法: <<slide_to_angle 90 1>>
        /// </summary>
        [YarnCommand("slide_to_angle")]
        public static IEnumerator SlideToAngle(float angle, float duration = 1f)
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController != null)
            {
                Debug.Log($"[SalesYarnCommand] 移动滑片到{angle}度，时长{duration}秒");
                sliderController.SlideTo(angle, duration);
                yield return new WaitForSeconds(duration);
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
            }
        }

        /// <summary>
        /// 滑片移动到指定标准化位置（0-1）
        /// 用法: <<slide_to_position 0.5 1>>
        /// </summary>
        [YarnCommand("slide_to_position")]
        public static IEnumerator SlideToPosition(float normalizedPosition, float duration = 1f)
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController != null)
            {
                Debug.Log($"[SalesYarnCommand] 移动滑片到位置{normalizedPosition}，时长{duration}秒");

                sliderController.SlideToNormalized(normalizedPosition, duration);
                yield return new WaitForSeconds(duration);
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
            }
        }

        /// <summary>
        /// 滑片移动到指定段
        /// 用法: <<slide_to_segment 3 1>>
        /// </summary>
        [YarnCommand("slide_to_segment")]
        public static IEnumerator SlideToSegment(int segmentIndex, float duration = 1f)
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController != null)
            {
                Debug.Log($"[SalesYarnCommand] 移动滑片到段{segmentIndex}，时长{duration}秒");
                sliderController.SlideToSegment(segmentIndex, duration);
                yield return new WaitForSeconds(duration);
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
            }
        }

        /// <summary>
        /// 滑片移动到异常段（任务关键）
        /// 用法: <<slide_to_anomaly 3 1>>
        /// </summary>
        [YarnCommand("slide_to_anomaly")]
        public static IEnumerator SlideToAnomaly(int segmentIndex, float duration = 1f)
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController != null)
            {
                Debug.Log($"[SalesYarnCommand] 移动滑片到异常段{segmentIndex}，时长{duration}秒");

                // 设置段数为异常段
                sliderController.SetSegmentCount(segmentIndex + 1);
                sliderController.SlideToSegment(segmentIndex, duration);

                yield return new WaitForSeconds(duration);
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
            }
        }

        /// <summary>
        /// 等待滑片到达目标位置
        /// 用法: <<wait_slider_at 0.5>>
        /// </summary>
        [YarnCommand("wait_slider_at")]
        public static IEnumerator WaitSliderAt(float targetPosition, float tolerance = 0.05f)
        {
            var sliderController = GetSalesManager()?.SliderController;
            if (sliderController == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到SliderController");
                yield break;
            }

            Debug.Log($"[SalesYarnCommand] 等待滑片到达位置{targetPosition}...");

            while (Mathf.Abs(sliderController.GetNormalizedPosition() - targetPosition) > tolerance)
            {
                yield return null;
            }

            Debug.Log($"[SalesYarnCommand] 滑片已到达位置{targetPosition}");
        }

        #endregion

        #region 处理器灯控制命令

        /// <summary>
        /// 激活指定索引的处理器灯
        /// 用法: <<activate_processor 3>>
        /// </summary>
        [YarnCommand("activate_processor")]
        public static void ActivateProcessor(int processorIndex, float duration = -1f)
        {
            var controller = FixSystemCenter.SystemDic.Get<ProcessorLightController>();
            if (controller != null)
            {
                controller.ActivateProcessor(processorIndex, duration);
                Debug.Log($"[SalesYarnCommand] 激活处理器{processorIndex}");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到ProcessorLightController");
            }
        }

        /// <summary>
        /// 关闭所有处理器灯
        /// 用法: <<deactivate_all_processors>>
        /// </summary>
        [YarnCommand("deactivate_all_processors")]
        public static void DeactivateAllProcessors(float fadeOutDuration = 0.3f)
        {
            var controller = FixSystemCenter.SystemDic.Get<ProcessorLightController>();
            if (controller != null)
            {
                controller.DeactivateAllProcessors(fadeOutDuration);
                Debug.Log("[SalesYarnCommand] 关闭所有处理器灯");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到ProcessorLightController");
            }
        }

        /// <summary>
        /// 显示异常处理器（闪烁）
        /// 用法: <<show_anomaly_processor 3>>
        /// </summary>
        [YarnCommand("show_anomaly_processor")]
        public static void ShowAnomalyProcessor(int processorIndex)
        {
            var controller = FixSystemCenter.SystemDic.Get<ProcessorLightController>();
            if (controller != null)
            {
                controller.ShowAnomalyProcessor(processorIndex);
                Debug.Log($"[SalesYarnCommand] 显示异常处理器{processorIndex}");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到ProcessorLightController");
            }
        }

        /// <summary>
        /// 根据滑片位置自动更新处理器灯
        /// 用法: <<update_processor_from_slider>>
        /// </summary>
        [YarnCommand("update_processor_from_slider")]
        public static void UpdateProcessorFromSlider()
        {
            var processorController = FixSystemCenter.SystemDic.Get<ProcessorLightController>();
            var sliderController = GetSalesManager()?.SliderController;

            if (processorController != null && sliderController != null)
            {
                float position = sliderController.GetNormalizedPosition();
                int processorIndex = processorController.GetProcessorIndexFromSlider(position);
                processorController.ActivateProcessor(processorIndex);
                Debug.Log($"[SalesYarnCommand] 根据滑片位置{position}激活处理器{processorIndex}");
            }
            else
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到所需的控制器");
            }
        }

        #endregion

        #region 销售流程控制命令

        /// <summary>
        /// 进入步进模式：触发 SaleView 收缩扩张动画，播放完成后释放 Animator 控制权，
        /// 以便 SliderController 等代码控制滑片等物件。
        /// 用法: <<enter_step_mode>>
        /// </summary>
        [YarnCommand("enter_step_mode")]
        public static IEnumerator EnterStepMode()
        {
            var manager = GetSalesManager();
            if (manager == null)
            {
                Debug.LogWarning("[SalesYarnCommand] 未找到 SalesManager，无法进入步进模式");
                yield break;
            }

            Debug.Log("[SalesYarnCommand] 进入步进模式，触发收缩扩张动画");
            yield return manager.PlaySaleViewEnterAnimationAndReleaseWhenDone();
        }

        /// <summary>
        /// 进入处理器深入模式（面板放大右移 + 盖子淡出 + 旋钮/辉光管启动）
        /// 用法: <<enter_processor_mode>>
        /// </summary>
        [YarnCommand("enter_processor_mode")]
        public static IEnumerator EnterProcessorMode()
        {
            var manager = GetSalesManager();
            if (manager == null)
            {
                Debug.LogWarning("[SalesYarnCommand] SalesManager not found");
                yield break;
            }

            Debug.Log("[SalesYarnCommand] Entering processor deep mode");
            yield return manager.EnterProcessorDeepMode();

            // Wait a frame for everything to settle
            yield return null;
        }

        /// <summary>
        /// 退出处理器深入模式（恢复面板位置/缩放、恢复盖子）
        /// 用法: <<exit_processor_mode>>
        /// </summary>
        [YarnCommand("exit_processor_mode")]
        public static IEnumerator ExitProcessorMode()
        {
            var manager = GetSalesManager();
            if (manager == null)
            {
                Debug.LogWarning("[SalesYarnCommand] SalesManager not found");
                yield break;
            }

            Debug.Log("[SalesYarnCommand] Exiting processor deep mode");
            yield return manager.ExitProcessorDeepMode();

            yield return null;
        }

        /// <summary>
        /// 完成一次完整的发条-滑片循环
        /// 用法: <<complete_crank_cycle>>
        /// </summary>
        [YarnCommand("complete_crank_cycle")]
        public static IEnumerator CompleteCrankCycle()
        {
            Debug.Log("[SalesYarnCommand] 完成发条-滑片循环");

            // 等待发条完成
            yield return WaitCrankComplete();

            // 移动滑片一段距离
            var sliderController = GetSalesManager()?.SliderController;


            if (sliderController != null)
            {
                float currentPosition = sliderController.GetNormalizedPosition();
                float newPosition = currentPosition + 0.25f; // 每次移动25%
                yield return SlideToPosition(newPosition, 0.5f);
            }
        }

        /// <summary>
        /// 等待特定步进节点完成
        /// 用法: <<wait_step_node 3>>
        /// </summary>
        [YarnCommand("wait_step_node")]
        public static IEnumerator WaitStepNode(int stepIndex)
        {
            Debug.Log($"[SalesYarnCommand] 等待步进节点{stepIndex}完成...");

            // 根据步进索引执行不同的等待逻辑
            switch (stepIndex)
            {
                case 1:
                case 2:
                    // 等待发条和滑片完成
                    yield return WaitCrankComplete();
                    break;
                case 3:
                    // 等待滑片移动到异常段
                    yield return new WaitForSeconds(2f);
                    break;
                case 4:
                    // 等待反向操作完成
                    yield return new WaitForSeconds(1f);
                    break;
            }

            Debug.Log($"[SalesYarnCommand] 步进节点{stepIndex}完成");
        }

        #endregion

        #region 静态工具方法

        /// <summary>
        /// 重置发条-滑片循环（进入销售深入时调用）
        /// 用法: <<reset_crank_cycle>>
        /// </summary>
        [YarnCommand("reset_crank_cycle")]
        public static void ResetCrankCycle()
        {
            var manager = GetSalesManager();
            if (manager != null)
            {
                manager.ResetCrankCycle();
                Debug.Log("[SalesYarnCommand] 已重置发条-滑片循环");
            }
        }

        /// <summary>
        /// 获取销售系统管理器
        /// </summary>
        private static SalesManager GetSalesManager()
        {
            return FixSystemCenter.SystemDic.Get<SalesManager>();
        }

        /// <summary>
        /// 等待指定时长
        /// </summary>
        private static IEnumerator Wait(float seconds)
        {
            yield return new WaitForSeconds(seconds);
        }

        #endregion
    }
}