/***
 **
 ** Blocks 玩法
 ** 2025-12-8
 **/

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using asap.core;
using cfg;
using DG.Tweening;
using EventCubeMelt;
using EventCubeMelt.Data;
using game;
using Game;
using GameCore;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.UI;
using Animation = UnityEngine.Animation;
using Sequence = DG.Tweening.Sequence;


namespace EventCubeMelt.UI
{
    public class EventCubeMeltPanel : BasePanel
    {
        // 
        private EventCubeMeltManager _thisEventManager;

        private EventCubeMeltData _thisEventData;

        // 
        private readonly PlayerItemData _playerItemData = GContext.container.Resolve<PlayerItemData>();

        // 显示奖励数量
        private int _showRewardCount = 4;

        private IDisposable _robotAddScoreSubscription;

        private Button _btnClose;
        private Button _btnQuestionmark;
        private Button _btnAdd;

        private Transform root;

        private TMP_Text icon_ticket;

        private TMP_Text _textTitle;
        private TMP_Text _txtTime;
        private TMP_Text _txtNum;
        private Image _imgTicket; //- 图标

        private Transform _stageComplete;
        private Transform _nextStageTip;
        private TMP_Text _textStage;

        private Animation _showAnimation; // 处理显示的Animation
        private CanvasGroup _canvasGroup;

        private Image _weaponImage;

        //- 视频解码器
        private Transform _videoPlayer;

        //- 引导
        private Transform _guide01;

        private Button _btnJump;
        // 获取奖励逻辑
        private bool _isStageRewardLogic = false;


        private TaskCompletionSource<bool> _waitStageRewardTcs;

        private bool _isFinalRewardLogic = false;
        // 最终奖励
        private RewardItemNew _rewardFinal;
        // Level 复用一下
        private SandDigLevel[] _levels;

        private RewardItemNew _rewardItem1;
        private RewardItemNew _rewardItem2;
        // 提出来放到脚本中
        private CubeMeltCollectItems[] _collectItems;
        // 定时器
        private IDisposable _timer;

        // 增光特效
        private Transform _fxUIEventCubemeltFireIncrease;



        #region 组件引用

        [Header("组件引用")][SerializeField] private BoardRenderer boardRenderer;
        [SerializeField] private PieceRenderer[] pieceRendererArray;

        #endregion

        #region 数值设定

        [Header("面板宽度")] public int boardWidth = 8;
        [Header("面板高度")] public int boardHeight = 8;

        // [Header("下方单元数量")] 
        // public int pieceNumber = 3;

        [Header("下方单元宽")] public int pieceWidth = 5;
        [Header("下方单元高")] public int pieceHeight = 5;

        [Header("视觉效果")]
        [Tooltip("点击的偏移")]
        public int pieceOffsetY = 320;
        [Tooltip("拖动对象的的缩放")]
        public float pieceScaleFactor = 100F / 40;
        [Tooltip("拖动对象目标大小，影响计算位置")]
        public float pieceTargetSize = 100F;

        [Tooltip("滑动比例")]
        public float pieceDistanceFactor = 0.2F;

        #endregion

        // GUide
        private Transform moveNode;
        private Vector3 moveNodeOriginPos;
        private Vector3 moveFinalPos;
        private bool _isUpdatingCollect;


        #region 周期函数

        private void Awake()
        {
            ELog("Awake");


            _thisEventManager = GContext.container.Resolve<EventCubeMeltManager>();
            _thisEventData = _thisEventManager.EventData;

            root = transform.Find("root");
            _textTitle = transform.Find("root/title/Txt_titleName").GetComponent<TMP_Text>();
            _levels = transform.Find("root/title/level").GetComponentsInChildren<SandDigLevel>(true);

            _txtTime = transform.Find("root/title/level/Txt_time").GetComponent<TMP_Text>();
            _rewardFinal = transform.Find("root/title/level/reward").GetComponent<RewardItemNew>();

            _showAnimation = GetComponent<Animation>();
            _canvasGroup = GetComponent<CanvasGroup>();

            _collectItems = transform.Find("root/TargetObject/CollectObject/CollectList")
                .GetComponentsInChildren<CubeMeltCollectItems>(true);
            //
            _rewardItem1 = transform.Find("root/TargetObject/RewardObject/reward/reward1")
                .GetComponent<RewardItemNew>();
            _rewardItem2 = transform.Find("root/TargetObject/RewardObject/reward/reward2")
                .GetComponent<RewardItemNew>();

            _stageComplete = transform.Find("root/StageComplete");
            _nextStageTip = transform.Find("root/NextStageTip");
            _textStage = transform.Find("root/NextStageTip/txt_stage").GetComponent<TMP_Text>();

            _btnClose = transform.Find("p_panel_btn_close").GetComponent<Button>();
            _btnQuestionmark = transform.Find("root/title/Btn_questionmark").GetComponent<Button>();
            _btnAdd = transform.Find("root/icon_ticket").GetComponent<Button>();
            _txtNum = transform.Find("root/icon_ticket/txt_num").GetComponent<TMP_Text>();
            _imgTicket = transform.Find("root/icon_ticket/Img_ticket").GetComponent<Image>();

            _guide01 = transform.Find("root/guide_01");
            _btnJump = transform.Find("root/btn_jump").GetComponent<Button>();
            var finalPos = transform.Find("root/EventCubeMeltTablePanel/Guidance/final_pos");
            moveNode = _guide01.Find("node");
            moveNodeOriginPos = moveNode.position;
            moveFinalPos = finalPos.position;

            _fxUIEventCubemeltFireIncrease = transform.Find("root/Bg_melt/fx_ui_event_cubemelt_fire_increase");
            _weaponImage = transform.Find("root/Bg_melt/weapon").GetComponent<Image>();

            _videoPlayer = transform.Find("root/BlockVideoPlayer");

            _videoPlayer.gameObject.SetActive(false);
            _showRewardCount = _levels.Length;
            _btnClose.onClick.AddListener(OnClose);

            _btnQuestionmark.onClick.AddListener(() =>
            {
                var infoPanel = _thisEventManager.EventCubeMeltMainData.InfoPanel;
                _ = UIManager.Instance.ShowUI(new UIType(infoPanel));
            });
            _btnAdd.onClick.AddListener(OnBtnAdd);


            _btnJump.onClick.AddListener(() =>
            {
                _thisEventManager.JumpToStage(11);
            });
            // 绑定事件
            GContext.OnEvent<EventForUpdateCollect>().Subscribe(evtData => { _ = UpdateCollectAsync(); }).AddTo(disposables);
            GContext.OnEvent<EventForRefreshCubeMeltPanel>().Subscribe(_ => RefreshUI()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltUpdateTicketCount>().Subscribe(_ => UpdateTickCount()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltShowNeoNormalPack>().Subscribe(_ => ShowNeoPackPanel()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltForNextStage>().Subscribe(evtData => { _ = ShowNextStageAsync(); }).AddTo(disposables);
            GContext.OnEvent<FishingChallengeContinueEvent>().Subscribe(_ => OnStageLogicContinue()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltWeaponExhibitFinished>().Subscribe(_ => OnWeaponExhibitFinish())
                .AddTo(disposables);
            GContext.OnEvent<EventCubeMeltWeaponProgress>().Subscribe((evt) => UpdateWeaponProgress()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltStageFinish>().Subscribe(_ => OnFinishStage()).AddTo(disposables);
            GContext.OnEvent<EventCubeMeltGuideFingerHide>().Subscribe(_ => StopGuideMove()).AddTo(disposables);
            GContext.OnEvent<EventNewGuideFingerStart>().Subscribe(_ => StartGuideMove()).AddTo(disposables);
            GContext.OnEvent<EventNewGuideFingerFinish>().Subscribe(_ => OnNewGuideFingerFinish()).AddTo(disposables);
            GContext.OnEvent<EventCubemeltExitAct>().Subscribe(_ => OnClose()).AddTo(disposables);

        }

        private void OnFinishStage()
        {
            ELog("OnFinishStage()");
            _canvasGroup.blocksRaycasts = false;
            foreach (var pieceRenderer in pieceRendererArray)
            {
                pieceRenderer.RestorePiece();
            }
        }

        private void OnClose()
        {
            GContext.Publish(new UnloadActToNextAct());
        }

        private async Task ShowNextStageAsync()
        {
            ELog("ShowNextStage");
            await Awaiters.NextFrame;
            _ = ShowCurrentStage();
            _showAnimation?.Play("EventCubeMeltSwithShow");
            UpdateTopInfo();
            UpdateTargetInfo();
            UpdateTickCount();
            _canvasGroup.blocksRaycasts = true;
        }

        private void OnStageLogicContinue()
        {
            ELog($"OnStageLogicContinue isStageRewardLogic={_isStageRewardLogic} isFinalRewardLogic={_isFinalRewardLogic}");

            if (_isStageRewardLogic)
            {
                _isStageRewardLogic = false;
            }
            else if (_isFinalRewardLogic)
            {
                _isFinalRewardLogic = false;
            }

            _waitStageRewardTcs?.TrySetResult(true);
        }

        private async void OnWeaponExhibitFinish()
        {
            ELog("OnWeaponExhibitFinish");
            var rootAni = root.GetComponent<Animation>();
            rootAni.Play("EventCubeMeltFinishRecover");
            await Awaiters.Seconds(0.12f);

            var bRet = _waitExhibitTcs?.TrySetResult(true) ?? false;
            // var success = _changeShowTypeTask.TrySetResult(true);
            if (!bRet)
            {
                LogWarning("WaitExhibitTrySetResultIgnored reason=AlreadyCompleted");
            }
            else
            {
            }


        }

        protected override void Start()
        {
            base.Start();
            _canvasGroup.blocksRaycasts = false;
            Initialize();
            UpdateTopInfo();
            UpdateTargetInfo();
            UpdateTickCount();
            SetIcon();
            _ = ShowCurrentStage();
            _timer = Observable.Interval(TimeSpan.FromSeconds(1)).Subscribe(UpdateTimer).AddTo(this);

            _videoPlayer.gameObject.SetActive(false);
        }


        private void GuideListener(AddIndexEvent addIndexEvent)
        {
            ELog($"GuideListener -> {addIndexEvent.guideSubIndex} {addIndexEvent.CompleteGuide}");
            if (addIndexEvent.CompleteGuide)
            {
                if (!this)
                {
                    return;
                }
                if (_canvasGroup)
                {
                    _canvasGroup.blocksRaycasts = true;
                }
                RunGuide01Anim();
            }
        }

        private async void RunGuide01Anim()
        {
            ELog("RunGuide01Anim");
            await Awaiters.NextFrame;

            _thisEventManager.SetIsInGuideAnim(true);
            if (!_guide01)
                return;

            _guide01.gameObject.SetActive(true);

            var trans = _guide01.Find("node/p/CubeGroup_02");
            var rootP = _guide01.Find("node/p");
            var renderer1 = pieceRendererArray[1];
            renderer1.GetComponent<Animation>().Play("CubeMeltGuideCubeAnim");

            var pieceRender = trans.GetComponent<PieceRenderer>();
            if (!pieceRender)
                pieceRender = trans.gameObject.AddComponent<PieceRenderer>();

            pieceRender.LoadDataToGrid(renderer1.Data);
            rootP.transform.localScale = Vector3.one * pieceRender.ScaleFactor;
            StartGuideMove();

        }

        [SerializeField] private float moveDuration = 1f;
        [SerializeField] private float pauseDuration = 0.5f;

        private Sequence moveToTarget;
        private void StartGuideMove()
        {
            // StopGuideMove();
            _guide01?.gameObject.SetActive(true);
            ELog($"StartGuideMove-> ");
            var transformNode = moveNode;
            // 创建移动动画到目标位置
            // transformNode.DOKill();
            transformNode.position = moveNodeOriginPos;
            moveToTarget?.Kill();

            moveToTarget = DOTween.Sequence();
            moveToTarget.Append(transformNode.DOMove(moveNodeOriginPos, 0));
            moveToTarget.Append(transformNode.DOMove(moveFinalPos, moveDuration));
            moveToTarget.AppendInterval(pauseDuration);
            moveToTarget.Append(transformNode.DOMove(moveNodeOriginPos, 0f));
            moveToTarget.SetLoops(-1);


            // 创建返回动画
            // var moveBack = DOTween.Sequence();
            // moveBack.Append(transformNode.DOMove(moveNodeOriginPos,0f));
            // 组合两个序列并循环
            // var fullSequence = DOTween.Sequence();
            // fullSequence.Append(moveToTarget);
            // fullSequence.Append(moveBack);
            // fullSequence.SetEase(Ease.InOutQuad);
            // fullSequence.SetLoops(-1);  // 无限循环
        }

        private void OnNewGuideFingerFinish()
        {
            var pieceRenderer = pieceRendererArray[1];
            if (pieceRenderer)
            {
                pieceRenderer.GetComponent<Animation>().Stop();
            }
        }

        private void StopGuideMove()
        {
            if (moveNode)
            {
                moveNode.DOKill();
            }
            moveToTarget?.Kill();
            _guide01.gameObject.SetActive(false);
        }
        protected override void OnDestroy()
        {
            _timer?.Dispose();
            _timer = null;
            StopGuideMove();
            moveToTarget?.Kill();
            base.OnDestroy();
            ELog("OnDestroy");
        }

        private void Update()
        {
#if UNITY_EDITOR
            if (Input.GetKeyDown(KeyCode.N))
            {
                boardRenderer.OnRestoreStep();
            }
            else if (Input.GetKeyDown(KeyCode.B))
            {
                boardRenderer.OnPrevStep();
            }

            if (Input.GetKeyDown(KeyCode.K))
            {
                isShow = !isShow;
            }

            if (Input.GetKeyDown(KeyCode.J))
            {
                _thisEventManager.JumpToStage(newStepValue);
            }
#endif
        }
#if UNITY_EDITOR
        private bool isShow = false;
        //
        private string newStepStr;

        private string newLoopStr;

        private int newStepValue;

        private int newLoopValue;
        private async void OnGUI()
        {
            if (!isShow)
            {
                return;
            }

            // Set the button width and height
            float buttonWidth = 300; // Replace with your desired width
            float buttonHeight = 70; // Replace with your desired height
            int fontSize = 40; // Replace with your desired font size

            // Set the font size for text fields, buttons, and labels
            GUI.skin.textField.fontSize = fontSize;
            GUI.skin.button.fontSize = fontSize;
            GUI.skin.label.fontSize = fontSize;
            // 触发ChallengeShowPlayAniEvent 事件并能输入oldStep和newStep
            GUILayout.Label("跳转关卡:");
            newStepStr = GUILayout.TextField(newStepStr, GUILayout.Width(buttonWidth), GUILayout.Height(buttonHeight));

            int.TryParse(newStepStr, out newStepValue);
            if (GUILayout.Button("跳转", GUILayout.Width(buttonWidth), GUILayout.Height(buttonHeight)))
            {
                var bRet = int.TryParse(newStepStr, out var newStep);
                if (bRet)
                    _thisEventManager.JumpToStage(newStep - 1);

                // Event.current.Use();
                GUIUtility.hotControl = 0;
                GUIUtility.keyboardControl = 0;
            }

            newLoopStr = GUILayout.TextField(newLoopStr, GUILayout.Width(buttonWidth), GUILayout.Height(buttonHeight));
            // int.TryParse(newLoopStr, out newLoopValue);

            if (GUILayout.Button("轮数跳转", GUILayout.Width(buttonWidth), GUILayout.Height(buttonHeight)))
            {
                var bRet = int.TryParse(newLoopStr, out newLoopValue);
                if (bRet)
                {
                    // _thisEventManager.JumpToStage(newStep -1);
                    // var newCycle = (newLoopValue != 0) ? 1 : newLoopValue ;
                    var newCycle = newLoopValue;
                    if (newCycle != _thisEventData.Cycle)
                    {
                        _thisEventData.Cycle = newCycle;
                        var step = _thisEventData.CurrentStagetId;
                        _thisEventManager.JumpToStage(step);
                    }
                }
                GUIUtility.hotControl = 0;
                GUIUtility.keyboardControl = 0;
            }


        }
#endif

        #endregion

        #region LOG

        private static void LogWarning(string message)
        {
            Debug.LogWarning($"<color=yellow>EventCubeMeltPanel => {message}</color>");
        }

        private static void LogError(string message)
        {
            Debug.LogError($"<color=red>EventCubeMeltPanel => {message}</color>");
        }

        private static void ELog(string message)
        {
#if UNITY_EDITOR
            if (!EventCubeMeltLogPolicy.EnableELog) return;
            Debug.Log($"<color=orange>EventCubeMeltPanel => {message}</color>");
#endif
        }

        #endregion

        #region 按钮事件

        private async void OnBtnAdd()
        {
            await Awaiters.NextFrame;
            // 
            ShowNeoPackPanel();
        }

        private async void ShowNeoPackPanel()
        {
            var packID = _thisEventManager.EventCubeMeltMainData.PackPackID;
            var packData = new EventNeoNormalPackData
            {
                EventId = _thisEventData.EventId,
                PackId = packID,
                // Panel = _thisEventManager.EventCubeMeltMainData.PackPanel
            };
            await EventNeoNormalPackPanel.TryShowAsync(packData);
        }

        #endregion

        #region 用户函数

        private void UpdateTopInfo()
        {
            ELog("UpdateTopInfo");
            _txtTime.text = ConvertTools.ConvertTime2(_thisEventManager.GetRemainingTime());
            //LocalizationMgr.GetFormatTextValue("UI_COMMON_end",
            //ConvertTools.ConvertTime2(_thisEventManager.GetRemainingTime()));
            // var dropId = _thisEventManager.EventCubeMeltMainData.FinalReward;
            var dropId = _thisEventManager.GetFinalReward();
            var itemData = _playerItemData.GetItemDataByDropIdAndTypeLureInflation(null, dropId);
            // _rewardFinal.SetData(itemData[0]);
            _rewardFinal.InflationRate = _thisEventData.InflationRate;
            _rewardFinal.SetDropIcon("", dropId);
            UpdateLevel();
        }

        private void UpdateTargetInfo()
        {
            // 奖励
            var dropId = _thisEventManager.EventCubeMeltCollectionData.CollectingReward;
            var itemData = _playerItemData.GetItemDataByDropIdAndTypeLureInflation(_thisEventData.InflationRate, dropId);
            try
            {
                _rewardItem1.SetData(itemData[0]);
                if (itemData.Count > 1)
                {
                    _rewardItem2.SetData(itemData[1]);
                }
            }
            catch (Exception e)
            {
                LogError($"UpdateTargetInfoFailed error={e.Message}");
            }

            // 当前完成的收集
            UpdateCollectInfo();
            UpdateWeapon();
        }

        private void UpdateWeapon()
        {

            _weaponImage?.gameObject.SetActive(true);

            // if (true)
            // {
            //     _videoPlayer?.gameObject.SetActive(true);
            //     SetUpProgress();
            //     return;
            // }
            var uiService = GContext.container.Resolve<IUIService>();
            var sprName = _thisEventManager.EventCubeMeltCollectionData.CollectingIcon;
            uiService.SetImageSprite(_weaponImage, sprName);
            SetUpProgress();
        }

        [Header("武器变化周期")]
        [SerializeField] private float weaponUpdateDuration = 0.5f;
        [Tooltip("火焰变化周期")]
        [SerializeField] private float fxIncreaseDuration = 0.8f;
        private async void UpdateWeaponProgress()
        {
            _fxUIEventCubemeltFireIncrease.gameObject.SetActive(true);
            var percent = _thisEventManager.GetCollectProgress();
            var startValue = _weaponImage.color.r;
            var df = weaponUpdateDuration * (percent - startValue);
            var newColor = new Color(percent, percent, percent, 1f);
            _weaponImage.DOColor(newColor, df);
            // 播放火焰特效
            await Awaiters.Seconds(fxIncreaseDuration); //
            _fxUIEventCubemeltFireIncrease.gameObject.SetActive(false);
        }


        public void SetUpProgress()
        {
            var percent = _thisEventManager.GetCollectProgress();
            ELog($"SetUpProgress-> {percent}");
            var image = _weaponImage.GetComponent<Image>();
            image.color = new Color(percent, percent, percent, 1f);
        }

        private void UpdateCollectInfo()
        {
            // 注，默认 数值的数量不会超过 UI的数量，当前最多是3组
            var iCount = _thisEventData.CollectItems.Count;
            for (var i = 0; i < iCount; ++i)
            {
                var item = _thisEventData.CollectItems[i];
                _collectItems[i].gameObject.SetActive(true);
                _collectItems[i].InitWithData(item);
            }

            for (var i = iCount; i < _collectItems.Length; ++i)
            {
                _collectItems[i].gameObject.SetActive(false);
            }
        }

        private void UpdateTickCount()
        {
            _txtNum.text = _thisEventData.TicketCount.ToString();
        }

        public RectTransform GetEndRectTransform(int cellTypeValue)
        {
            var items = _thisEventManager.GetCollectionItems();
            var index = 0;
            foreach (var kv in items)
            {
                var itemId = kv.Key;
                if (itemId == (int)cellTypeValue)
                {
                    //注意不要超值-  
                    break;
                }

                index++;
            }

            if (index >= _collectItems.Length)
                return null;
            var root = _collectItems[index];
            ELog($"GetEndPos ->{index} : {root}");
            // return (RectTransform)root.Find("collect_icon").transform;
            return root.GetAniTransform();
        }

        private void UpdateTimer(long _ = 0L)
        {
            var now = _thisEventManager.GetRemainingTime();
            // _txtTime.text = ConvertTools.ConvertTime2(now.Days, now.Hours, now.Minutes, now.Seconds);

            // ConvertTools.ConvertTime2(now);
            _txtTime.text = ConvertTools.ConvertTime2(now);
            // LocalizationMgr.GetFormatTextValue("UI_COMMON_end", ConvertTools.ConvertTime2(now));
            if (now.TotalMilliseconds < 0)
            {
                Settle();
            }
        }

        private void Settle()
        {
            // timer?.Cancel();
            // timer = null;
            _txtTime.text = LocalizationMgr.GetText("UI_EventRankPopupPanel_13");
            //结算
            _thisEventManager.OnSettle();
        }

        // 设置代币图标
        void SetIcon()
        {
            var itemId = _thisEventManager.EventCubeMeltMainData.ItemID;
            var tables = GContext.container.Resolve<Tables>();
            var data = tables.TbItem.GetOrDefault(itemId);
            var imageData = new ShowImageData(_imgTicket, data.Icon);
            GContext.container.Resolve<IUIService>().SetImageSprite(imageData);
        }

        private void UpdateLevel()
        {
            // ELog("UpdateLevel-> ");
            // var count = _thisEventManager.EventCubeMeltMainData.StageList.Count;
            var count = _thisEventManager.StageCount;

            var curIndex = (_thisEventData.CurrentStagetId) % count;
            var startIndex = 0;
            var offsetIndex = count - _showRewardCount;
            // curIndex = 14;
            ELog($"UpdateLevel->  {curIndex}");


            if (curIndex <= 1)
            {
                startIndex = 0;
            }
            else if (curIndex > offsetIndex)
            {
                startIndex = offsetIndex;
            }
            else
            {
                startIndex = curIndex - 1;
            }

            for (var i = 0; i < _showRewardCount - 1; i++)
            {
                var index = startIndex + i;
                if (index >= count)
                {
                    break;
                }

                var state = 0;
                if (index < curIndex)
                {
                    state = 2;
                }
                else if (index == curIndex)
                {
                    state = 1;
                }

                _levels[i].SetState(state);
                _levels[i].SetTextNum($"{index + 1}");
            }

            _levels[_showRewardCount - 1].SetTextNum($"{count}");
        }

        private void RefreshUI()
        {
            ELog("RefreshUI");

            UpdateTopInfo();
            UpdateTargetInfo();
            UpdateGameContext();
            UpdateTickCount();
        }

        //- 
        private async Task UpdateCollectAsync()
        {
            if (_isUpdatingCollect)
            {
                ELog("UpdateCollectSkip reason=Running");
                return;
            }

            _isUpdatingCollect = true;
            ELog("UpdateCollect-> ");
            try
            {
                await Awaiters.NextFrame;

                var iCount = _thisEventData.CollectItems.Count;
                for (var i = iCount; i < _collectItems.Length; ++i)
                {
                    _collectItems[i].gameObject.SetActive(false);
                }

                var tasks = new List<Task>();

                for (var i = 0; i < iCount; ++i)
                {
                    var item = _thisEventData.CollectItems[i];
                    tasks.Add(_collectItems[i].UpdateCollectItem(item));
                }

                // GContext.Publish(new EventUISound("audio_ui_cubemelt_cube_refresh"));

                GContext.Publish(new EventCubeMeltWeaponProgress
                {
                    percent = _thisEventManager.GetCollectProgress()
                });
                await Task.WhenAll(tasks);
                await CheckIfCollectFinished();
            }
            finally
            {
                _isUpdatingCollect = false;
            }
        }


        private async Task CheckIfCollectFinished()
        {
            var isFinishThisStage = _thisEventManager.IsThisCollectFinished();
            var isGetStageReward = _thisEventManager.IsGetStageReward();
            if (isFinishThisStage)
            {
#if AGG
                using (var e = GEvent.GameEvent("event_cubemelt_complete"))
                {
                    e.AddContent("stage_id",_thisEventData.CurrentStagetId);
                }
#else
                ELog($"event_cubemelt_complete -> {_thisEventData.CurrentStagetId} ");
#endif

                _canvasGroup.blocksRaycasts = false;
                if (!isGetStageReward)
                {
                    await RunFinishStage();
                    await CheckStageRewardsGet();
                }
                // await CheckFinalRewardsGet();
                UpdateToNextStage();
            }
        }
        private async Task CheckStageRewardsGet()
        {
            _isStageRewardLogic = _thisEventManager.PlayGetStageReward();
            if (_isStageRewardLogic)
            {
                // await CheckStageRewardFinished();
                ELog("WaitForStageRewardFinished");
                _waitStageRewardTcs = new TaskCompletionSource<bool>();
                await _waitStageRewardTcs.Task;
            }
        }
        // private async Task CheckFinalRewardsGet()
        // {
        //     var isFinishAll = _thisEventManager.IsFinishAllStage();
        //     var isFinalGet = _thisEventManager.IsGetFinalReward();
        //     if (isFinishAll && !isFinalGet)
        //     {
        //         _isFinalRewardLogic = _thisEventManager.PlayGetFinalRewards();
        //         if (_isFinalRewardLogic)
        //         {
        //             await CheckFinalRewardsFinished();
        //         }
        //     }
        // }
        private async Task CheckStageRewardFinished()
        {
            if (!_isStageRewardLogic) return;
            while (true)
            {
                if (!_isStageRewardLogic)
                    return;
                await Awaiters.Seconds(0.2f);
            }
        }
        private async Task CheckFinalRewardsFinished()
        {
            if (!_isFinalRewardLogic) return;
            while (true)
            {
                if (!_isFinalRewardLogic)
                    return;
                await Awaiters.Seconds(1f);
            }
        }

        private readonly float _durationForShowFinishView = 1f;
        private async Task RunFinishStage()
        {
            _stageComplete.gameObject.SetActive(true);
            await Awaiters.Seconds(2f);
            _stageComplete.gameObject.SetActive(false);

            await RunWeaponExhibit();
            ClearBoardAndPieces();
        }

        private async Task RunWeaponExhibit()
        {
            _fxUIEventCubemeltFireIncrease.gameObject.SetActive(true);
            await Awaiters.Seconds(fxIncreaseDuration); //
            _weaponImage.gameObject.SetActive(false);
            _fxUIEventCubemeltFireIncrease.gameObject.SetActive(false);

            OnWeaponExhibitNew();
            // GContext.Publish(new EventCubeMeltWeaponExhibit());
            // audio_ui_cubemelt_complete_show
            GContext.Publish(new EventUISound("audio_ui_cubemelt_complete_show"));
            await WaitForExhibitFinished();
        }

        private TaskCompletionSource<bool> _waitExhibitTcs;
        private async Task WaitForExhibitFinished()
        {
            ELog("WaitForExhibitFinished");
            _waitExhibitTcs = new TaskCompletionSource<bool>();
            await _waitExhibitTcs.Task;
        }

        private void UpdateToNextStage()
        {
            ELog("UpdateToNextStage");
            // await Awaiters.NextFrame;
            _thisEventManager.UpdateToNextStage();
        }

        private void ClearBoardAndPieces()
        {
            if (boardRenderer)
            {
                boardRenderer.ClearBoard();
            }

            foreach (var pieceRenderer in pieceRendererArray)
            {
                if (pieceRenderer)
                {
                    pieceRenderer.CleanPiece();
                }
            }
        }


        private async void OnWeaponExhibitNew()
        {
            ELog("OnWeaponExhibitNew");

            var rootAni = root.GetComponent<Animation>();
            rootAni.Play("EventCubeMeltFinish");


            // var stageId  = _thisEventManager.EventData.CurrentStagetId;
            // var videoBytes   = await Addressables.LoadAssetAsync<TextAsset>("video_weapon_01").Task;

            // if (_videoDecoder == null || !videoBytes) return;


            // _videoPlayer.gameObject.SetActive(true);

            // 软解码器由 PlayVideo 内部创建；下列参数在 Editor/Standalone 等路径下生效
            // _videoDecoder.PlayVideo(
            //     videoBytes,
            //     LeviathanVideoDecoderBase.PlayAlphaType.ChromaKey, // None / RightSide / BottomSide / ChromaKey
            //     multithreadedDecode: true,   // WebGL 下会被强制为 false（无 C# 线程）
            //     beginFrameIndex: 1,
            //     syncDecodeFirstFrame: true, // false：首帧异步，先隐藏 RawImage，首帧就绪后再显示（见 OnFirstFrameRendered）
            //     fastDecode: true            // true：跳过环路滤波，解码更快、画质略降
            // );
            // _videoDecoder.SetChromaKeyCutoff(1f);

            // var  sequence = DOTween.Sequence();
            //
            // // 同时执行（Append 会等前面的完成，Join 会同时执行）
            // var videoTransform = _videoDecoder.transform;
            // sequence.Append(videoTransform.DOMove(new Vector3(500, 0, 0), 1f));
            // // sequence.Join(videoTransform.DOScale(Vector3.one * 2, 1f)); // 与上一行同时执行
            //
            // // 停顿 0.5 秒
            // sequence.AppendInterval(0.5f);
            // // 返回原状态
            // sequence.Append(transform.DOMove(Vector3.zero, 1f));
            // sequence.Join(transform.DOScale(Vector3.one, 1f));
            //
            // // 设置循环和缓动
            // sequence.SetLoops(3, LoopType.Restart)  // 无限循环
            //     .SetEase(Ease.InOutSine);
            //
            await Awaiters.Seconds(3f);
            //
            // videoTransform.DOKill();
            _videoPlayer.gameObject.SetActive(false);
            GContext.Publish(new EventCubeMeltWeaponExhibitFinished());
        }

        #endregion

        #region BlockGame 逻辑
        private void Initialize()
        {
            // _thisEventManager.SetBoardDimension(new Vector2Int(boardWidth, boardHeight));
            _thisEventManager.SetPieceDimension(new Vector2Int(pieceWidth, pieceHeight));
            if (boardRenderer)
            {
                boardRenderer.Initialize(boardHeight, boardWidth, _thisEventData.BoardData);
                boardRenderer.TargetCellSize = pieceTargetSize;
            }

            if (pieceRendererArray.Length > 0)
            {
                for (var i = 0; i < pieceRendererArray.Length; ++i)
                {
                    ELog($"InitializePieceRenderer index={i} renderer={pieceRendererArray[i]}");

                    pieceRendererArray[i].Index = i;
                    pieceRendererArray[i].Initialize(pieceHeight, pieceWidth);
                    pieceRendererArray[i].ScaleFactor = pieceScaleFactor;
                    pieceRendererArray[i].OffsetY = pieceOffsetY;
                    pieceRendererArray[i].TargetSize = pieceTargetSize;
                    pieceRendererArray[i].DistanceFactor = pieceDistanceFactor;
                }
            }
        }
        [Space]
        [Header("切关动画每一层显示延时")]
        public float delayBetweenCells = 0.1f; // 每个单元格间隔0.3秒
        [Header("切关动画格子缩放时间")]
        public float scaleDuration = 0.2f; // 缩放动画持续时间

        [Header("底部Piece 延时延时")]
        public float delayBetweenPiece = 0.1f;
        [Header("底部Piece 缩放时间")]
        public float pieceScaleDuration = 0.3f;
        public void OnEnterAnimationFinished()
        {
            ELog("OnEnterAnimationFinished()");

            _ = RunStageSwitchAnimation();

        }
        private async Task RunStageSwitchAnimation()
        {
            var animationSequence = DOTween.Sequence();
            var delay = 0f;
            if (boardRenderer)
                boardRenderer.UpdateBoardWithAnim(animationSequence, scaleDuration, delayBetweenCells, out delay);

            for (var i = 0; i < pieceRendererArray.Length; ++i)
            {
                var pieceRenderer = pieceRendererArray[i];
                if (pieceRenderer)
                {
                    pieceRenderer.UpdatePieceWithAnim(animationSequence, pieceScaleDuration, delay + i * delayBetweenPiece);
                }
            }

            // 可选：动画完成后的回调
            animationSequence.OnComplete(OnSwitchStageAnimationEnd);
        }

        private void OnSwitchStageAnimationEnd()
        {
            _ = OnSwitchStageAnimationEndAsync();
        }

        private async Task OnSwitchStageAnimationEndAsync()
        {
            await Awaiters.NextFrame;
            ELog("OnSwitchStageAnimationEnd");
            OnNewGuide();
            // 按钮有效

            await CheckIfCollectFinished();
        }
        private void OnNewGuide()
        {
            var stageId = _thisEventData?.CurrentStagetId ?? -1;
            var cycle = _thisEventData?.Cycle ?? -1;
            if (stageId == 0 && cycle == 0)
            {
                var isGuide = GContext.container.Resolve<GuideDataCenter>().TriggerGuide(nameof(GroupName.Block01), "EventBlockVikingPanel", false, gameObject.name);
                if (isGuide)
                {
                    GContext.OnEvent<AddIndexEvent>().Subscribe(GuideListener).AddTo(disposables); ;
                }
                else
                {
                    // var cycle = _thisEventData?.Cycle ?? -1;
                    if (_thisEventManager.IsInGuideAnim() && cycle == 0)
                    {
                        RunGuide01Anim();
                    }
                    else
                    {
                        _thisEventManager.SetIsInGuideAnim(false);
                    }
                    _canvasGroup.blocksRaycasts = true;
                }
            }
            else
            {
                _canvasGroup.blocksRaycasts = true;
            }
        }
        private async Task ShowCurrentStage()
        {
            await Awaiters.NextFrame;
            var stage = _thisEventData.CurrentStagetId;
            ELog($"ShowCurrentStage-> {stage}");
            ClearBoardAndPieces();
            GContext.Publish(new EventCubeMeltShowMinWeapon());
        }
        private void UpdateGameContext()
        {
            // 更新当前管卡的数据
            if (boardRenderer)
            {
                boardRenderer.UpdateBoard();
            }

            foreach (var pieceRenderer in pieceRendererArray)
            {
                if (pieceRenderer)
                {
                    pieceRenderer.UpdatePiece();
                }
            }
        }

        #endregion
    }
}