using asap.core;
using cfg;
using DG.Tweening;
using EnhancedUI.EnhancedScroller;
using GameCore;
using System;
using System.Collections;
using System.Collections.Generic;
using TMPro;
using UniRx;
using UnityEngine;
using UnityEngine.UI;

namespace game
{
    public class EventPotionPanel : BasePanel
    {
        public RawImage ScenePotionRawImage;
        public GameObject TopMouth;

        public float show_base_waiting_time = 0.5f;
        public float show_gap_time = 0.2f;
        public float show_waitfor_spine_shake_time = 0.6f;
        public string show_spine_shake_anim = "potion_shake_01_2";
        public float show_spine_shake_duration_time = 1.433f;

        public float jump_move_duration_time = 0.6f;
        public float jump_waitfor_spine_shake_time = 0.6f;
        public string jump_spine_shake_anim = "potion_shake_01_1";
        public float jump_spine_shake_duration_time = 2.333f;

        public float jumpdown_move_duration_time = 0.6f;
        public float jumpdown_waitfor_spine_shake_time = 0.6f;
        public string jumpdown_spine_shake_anim = "potion_shake_01_1";
        public float jumpdown_spine_shake_duration_time = 2.333f;

        public float check_base_waiting_time = 0.8f;
        public float check_gap_time = 0.2f;
        public string check_spine_shake1_anim = "potion_shake_02";
        public float check_waitfor_spine_shake2_time = 0.2f;
        public string check_spine_shake2_anim = "potion_shake_03";
        public float check_spine_shake2_duration_time = 2.333f;

        public float dock_base_waiting_time = 0.6f;
        public float dock_gap_time = 0f;
        public float dock_move_duration_time = 0.6f;
        public float dock_scale = 1.8f;
        public float dock_waitfor_final_time = 0.1f;

        public float dock_animation_gap_duration_time = 0.5f;

        public float final_gap_time = 0f;
        public float final_move_duration_time = 0.5f;
        public float final_scale = 0.7f;
        public float final_pour_duration_time = 1.467f;
        public float final_ui_fx_duration_time = 1f;

        public float Lock_Time = 1.0f;
        public float Changing_Fountain_Effect_Waiting_Time = 0.5f;

        public RectTransform m_DockPoint;

        public GameObject fx_eventpoison_ui_reward;

        [NonSerialized] public List<Vector3> operatingPointTransformList = new List<Vector3>();
        [NonSerialized] public Vector3 centerPointPosition;
        [NonSerialized] public Vector3 centerOfTopMouth = new Vector3(float.MinValue, float.MinValue);

        private EventPotionDataManager m_DataManager;
        //由于界面刷新是在奖励界面关闭的时候进行的，所以这里需要一个临时变量来存储奖励数据，判断是不是升级奖励
        List<ItemData> itemDataList;
        #region 音效相关
        public List<GameObject> m_AudioPouringList = new List<GameObject>();
        public void CloseAudioPouring()
        {
            foreach (var gameObject in m_AudioPouringList)
            {
                gameObject.SetActive(false);
            }
        }
        public void OpenAudioPouring()
        {
            foreach (var gameObject in m_AudioPouringList)
            {
                gameObject.SetActive(true);
            }
        }
        #endregion

        #region EventPotionController
        private EventPotionController m_EventPotionController;
        public void SetEventPotionController(EventPotionController eventPotionController)
        {
            m_EventPotionController = eventPotionController;
        }
        #endregion

        #region 功能锁定相关
        public float m_LockScrollViewMaxTime = 2.0f;
        private float m_LockScrollViewCumulativeTime = 0.0f;
        private int m_ScrollViewMinimumQuantity = 0;
        public int ScrollViewMinimumQuantity { get => m_ScrollViewMinimumQuantity; }
        public bool IsScrollViewLocked
        {
            get { return m_LockScrollViewCumulativeTime > 0f; }
        }
        public void StartLockScrollView()
        {
            m_LockScrollViewCumulativeTime = m_LockScrollViewMaxTime;
            if (m_LockScrollViewCumulativeTime > 0f)
            {
                LockScrollView();
            }
        }
        public void StopLockScrollView()
        {
            m_LockScrollViewCumulativeTime = 0f;
        }
        public void LockScrollView()
        {
            if (m_PotionScrollViewController == null) return;
            m_PotionScrollViewController.LockScrollView();
        }
        public void UnlockScrollView()
        {
            if (m_PotionScrollViewController == null) return;

            if (m_DataManager == null || m_DataManager.PotionData == null) return;

            int processedCount = m_DataManager.PotionData.LevelProcessedList.Count;

            if (processedCount >= m_ScrollViewMinimumQuantity)
            {
                m_PotionScrollViewController.UnlockScrollView();
            }
            else
            {
                m_PotionScrollViewController.LockScrollView();
            }
        }
        private float m_LockClickOperationCumulativeTime = 0f;
        public bool IsClickOperationLocked
        {
            get
            {
                return m_LockClickOperationCumulativeTime > 0f || m_IsCheckingColorType;
            }
        }
        public bool IsClickOperationLockedPure
        {
            get
            {
                return m_LockClickOperationCumulativeTime > 0f;
            }
        }
        public void StartLockClickOperation()
        {
            m_LockClickOperationCumulativeTime = Lock_Time;
        }
        public void StopLockClickOperation()
        {
            m_LockClickOperationCumulativeTime = 0f;
        }
        bool m_IsCheckingColorType = false;
        public bool IsCheckingColorType { get { return m_IsCheckingColorType; } set { m_IsCheckingColorType = value; } }
        private void UpdateLockAction(float deltaTime)
        {
            if (m_LockScrollViewCumulativeTime > 0f)
            {
                m_LockScrollViewCumulativeTime -= deltaTime;
                if (m_LockScrollViewCumulativeTime > 0f)
                {
                    LockScrollView();
                }
            }
            if (m_LockScrollViewCumulativeTime <= 0f)
            {
                m_LockScrollViewCumulativeTime = 0f;
                if (!m_IsCheckingColorType)
                {
                    UnlockScrollView();
                }
            }

            if (m_LockClickOperationCumulativeTime > 0f)
            {
                m_LockClickOperationCumulativeTime -= deltaTime;
            }
            if (m_LockClickOperationCumulativeTime < 0f)
            {
                m_LockClickOperationCumulativeTime = 0f;
            }
        }
        #endregion

        #region 喷泉相关
        //public bool IsFountainChanged()
        //{
        //    EventPotionStage stage = m_DataManager.GetEventPotionStage(0);
        //    int fountainLevel = stage.FountainLevel;
        //    return false;
        //}
        public void ChangeFountain()
        {
            EventPotionStage preLevel = m_DataManager.GetEventPotionStage(m_DataManager.PotionData.PreLevelID);
            EventPotionStage curLevel = m_DataManager.GetCurrentPotionLevel();
            if (preLevel.FountainLevel != curLevel.FountainLevel)
            {
                m_EventPotionController.ChangeFountain(curLevel.FountainLevel, true, Changing_Fountain_Effect_Waiting_Time);
            }
        }
        public void InitFountain()
        {
            EventPotionStage curLevel = m_DataManager.GetCurrentPotionLevel();
            m_EventPotionController.ChangeFountain(curLevel.FountainLevel, false, 0);
        }
        #endregion

        #region 倒水特效相关
        public bool IsLocatedLeftOfCenterPoint(Vector3 point)
        {
            if (point.x > centerPointPosition.x)
            {
                return false;
            }
            return true;
        }
        public float fountain_ripple_effect_waiting_time = 0.3f;
        public List<GameObject> m_FountainRippleEffectList = new List<GameObject>();
        public void StopFountainRippleEffect()
        {
            foreach (var gameObject in m_FountainRippleEffectList)
            {
                gameObject.SetActive(false);
            }
        }
        public IEnumerator StartFountainRippleEffect()
        {
            yield return new WaitForSeconds(fountain_ripple_effect_waiting_time);

            foreach (var gameObject in m_FountainRippleEffectList)
            {
                gameObject.SetActive(true);
            }
        }
        #endregion

        #region 飞行特效相关临时数据
        [SerializeField] private List<PotionGridUI> m_TemporaryItemList = new List<PotionGridUI>();
        public PotionGridUI GetIdleTemporaryGridUI()
        {
            foreach (var item in m_TemporaryItemList)
            {
                if (item.IsIdle == true)
                {
                    return item;
                }
            }
            return null;
        }
        public void ClearTemporaryGridUIToIdle()
        {
            foreach (var item in m_TemporaryItemList)
            {
                item.IsIdle = true;
            }
        }
        public bool IsAllTemporaryIdle()
        {
            foreach (var item in m_TemporaryItemList)
            {
                if (item.IsIdle == false)
                {
                    return false;
                }
            }
            return true;
        }
        #endregion

        #region 操作处理
        private void CheckForPreLevelOperation()
        {
            if (m_DataManager == null || m_DataManager.PotionData == null) return;

            if (m_DataManager.PotionData.IsOver)
            {
                CheckForLevelReward();
            }
            else
            {
                CheckForAddNewStepData();
            }

            //StopLockClickOperation();
        }
        private void CheckForAddNewStepData()
        {
            PotionItemData operationItemData = m_DataManager.GetOperationItemData();
            if (operationItemData == null) return;

            int count = m_DataManager.PotionData.LevelDisplayData.GridStateList.Count;
            for (int i = 0; i < count; ++i)
            {
                if (m_DataManager.PotionData.LevelDisplayData.GridStateList[i] == EventPotionGridState.GridState_Over) continue;
                m_DataManager.PotionData.LevelDisplayData.GridStateList[i] = EventPotionGridState.GridState_Empty;
            }

            count = operationItemData.ColorTypeList.Count;

            int validColorNum = operationItemData.GetValidColorTypeNum();

            if (validColorNum == count)
            {
                // 操作区全部上架
                bool flag = true;
                m_CommitColorTypeList.Clear();
                for (int i = 0; i < count; ++i)
                {
                    EventPotionGridState gridState = operationItemData.GetGridState(i);
                    if (gridState == EventPotionGridState.GridState_Over) continue;

                    int operationColor = operationItemData.GetColorType(i) % 100;
                    int targetColor = m_DataManager.PotionData.LevelTargetData.GetColorType(i);
                    int fromDisplayAreaIndex = operationItemData.FromDisplayAreaIndexList[i];

                    m_CommitColorTypeList.Add(operationColor);

                    if (operationColor == targetColor)
                    {
                        operationItemData.SetGridState(i, EventPotionGridState.GridState_Ok);
                        if (fromDisplayAreaIndex >= 0 && fromDisplayAreaIndex < count)
                        {
                            m_DataManager.PotionData.LevelDisplayData.SetGridState(fromDisplayAreaIndex, EventPotionGridState.GridState_Over);
                        }
                    }
                    else
                    {
                        flag = false;
                        operationItemData.SetGridState(i, EventPotionGridState.GridState_Wrong);
                        operationItemData.SetColorType(i, operationColor + 100);
                        if (fromDisplayAreaIndex >= 0 && fromDisplayAreaIndex < count)
                        {
                            m_DataManager.PotionData.LevelDisplayData.SetGridState(fromDisplayAreaIndex, EventPotionGridState.GridState_Empty);
                        }
                    }
                }

                if (flag)
                {
                    CheckForLevelReward();
                }
                else
                {
                    AddNewStepData(false);
                }
            }
            else
            {
                // 操作区未全部上架
                for (int i = 0; i < count; ++i)
                {
                    EventPotionGridState gridState = operationItemData.GetGridState(i);
                    if (gridState == EventPotionGridState.GridState_Over) continue;

                    int fromDisplayAreaIndex = operationItemData.FromDisplayAreaIndexList[i];

                    int operationColor = operationItemData.GetColorType(i);
                    if (operationColor <= 0)
                    {
                        operationItemData.SetGridState(i, EventPotionGridState.GridState_Empty);
                        if (fromDisplayAreaIndex >= 0 && fromDisplayAreaIndex < count)
                        {
                            m_DataManager.PotionData.LevelDisplayData.SetGridState(fromDisplayAreaIndex, EventPotionGridState.GridState_Empty);
                        }
                        continue;
                    }

                    if (operationColor > 100)
                    {
                        operationItemData.SetColorType(i, operationColor % 100);
                    }
                    operationItemData.SetGridState(i, EventPotionGridState.GridState_Occupied);

                    if (fromDisplayAreaIndex >= 0 && fromDisplayAreaIndex < count)
                    {
                        m_DataManager.PotionData.LevelDisplayData.SetGridState(fromDisplayAreaIndex, EventPotionGridState.GridState_Occupied);
                    }
                }
            }
        }
        private async void CheckForLevelReward()
        {
            m_IsCheckingColorType = true;
            StartLockScrollView();

            // 未领取奖励，则执行领取奖励操作
            int levelCount = m_DataManager.GetPreLevelCountInCurRound();

            if (m_DataManager.PotionData.LevelIndex == levelCount - 1)
            {
                EventPotionStage lastLevel = m_DataManager.GetLastStageInCurRound();
                var rewardList = GContext.container.Resolve<PlayerItemData>()?.AddItemByDrop(lastLevel.Reward, false);

                if (rewardList == null || rewardList.Count < 1) return;

                var panelObj = await UIManager.Instance.ShowUI(UITypes.EventPotionRewardPopupPanel);
                if (panelObj == null) return;
                var rewardPopupPanel = panelObj.GetComponent<EventPotionRewardPopupPanel>();
                rewardPopupPanel.Init(rewardList);

                m_DataManager.GetNextPotionLevel();
            }
            else
            {
                // 展示奖励界面
                EventPotionStage level = m_DataManager.GetCurrentPotionLevel();
                itemDataList = GContext.container.Resolve<PlayerItemData>().AddItemByDrop(level.Reward, true, RewardType.NormalOne);
                GContext.Publish(new ShowData());

                m_DataManager.GetNextPotionLevel();
            }
            StopLockClickOperation();
        }
        private async void OnFinalOperationComplete()
        {
            AddDropStatisticalData(true);
            int levelCount = m_DataManager.GetLevelCountInCurRound();
            if (m_DataManager.PotionData.LevelIndex == levelCount - 1)
            {
                EventPotionStage lastLevel = m_DataManager.GetLastStageInCurRound();
                var rewardList = GContext.container.Resolve<PlayerItemData>()?.AddItemByDrop(lastLevel.Reward, false);
                if (rewardList == null || rewardList.Count < 1) return;

                var panelObj = await UIManager.Instance.ShowUI(UITypes.EventPotionRewardPopupPanel);
                if (panelObj == null) return;
                var rewardPopupPanel = panelObj.GetComponent<EventPotionRewardPopupPanel>();
                rewardPopupPanel.Init(rewardList);

                m_DataManager.GetNextPotionLevel();
            }
            else
            {
                // 展示奖励界面
                EventPotionStage level = m_DataManager.GetCurrentPotionLevel();
                itemDataList = GContext.container.Resolve<PlayerItemData>().AddItemByDrop(level.Reward, true, RewardType.NormalOne);
                GContext.Publish(new ShowData());

                m_DataManager.GetNextPotionLevel();
            }
            StopLockClickOperation();
        }
        private void GoToNextLevel()
        {
            m_DataManager.InitScrollerDataList();

            var position = 0f;
            m_PotionScrollViewController.ReloadData();
            m_PotionWallScrollViewController.ReloadData();
            m_PotionScrollViewController.ScrollPosition = position;
            m_PotionWallScrollViewController.ScrollPosition = position;

            int index = m_DataManager.WallBeforeCount + m_DataManager.PotionData.LevelProcessedList.Count;
            m_PotionScrollViewController.JumpToDataIndex(index);

            // 重置下方Item展示区域
            ResetItemsDisplayArea();

            UpdateReward();
            UpdateProgress();

            // 切换喷泉
            ChangeFountain();
        }
        private void AddNewStepData(bool isResetUI = true)
        {
            m_IsCheckingColorType = true;
            StartLockScrollView();

            foreach (var item in m_DataManager.PotionData.LevelProcessedList)
            {
                item.isOver = true;
                item.DataType = EventPotionDataType.Data_Item;
                item.ResetFromDisplayAreaIndexList(-1);
            }

            PotionItemData newPotionItemData = new PotionItemData();
            newPotionItemData.name = "AddNewStepData_" + DateTime.Now.Ticks;
            newPotionItemData.index = m_DataManager.PotionData.LevelProcessedList.Count;
            newPotionItemData.Clear();
            newPotionItemData.isOver = false;
            newPotionItemData.DataType = EventPotionDataType.Data_ItemAndOperation;

            int count = m_DataManager.PotionData.LevelProcessedList.Count;
            PotionItemData lastProcessedItemData = m_DataManager.PotionData.LevelProcessedList[count - 1];

            EventPotionStage potionLevel = m_DataManager.GetCurrentPotionLevel();
            count = potionLevel.ResourceList.Count;
            for (int i = 0; i < count; i++)
            {
                int preColorType = lastProcessedItemData.ColorTypeList[i];
                int preFromDisplayAreaIndex = lastProcessedItemData.FromDisplayAreaIndexList[i];
                if (preColorType > 0 && preColorType < 100)
                {
                    newPotionItemData.ColorTypeList.Add(preColorType);
                    newPotionItemData.ShelfTypeList.Add(EventPotionShelfType.Shelf_Success);
                    newPotionItemData.GridStateList.Add(EventPotionGridState.GridState_Over);
                    newPotionItemData.FromDisplayAreaIndexList.Add(preFromDisplayAreaIndex);
                }
                else
                {
                    newPotionItemData.ColorTypeList.Add(-1);
                    newPotionItemData.ShelfTypeList.Add(EventPotionShelfType.Shelf_Default);
                    newPotionItemData.GridStateList.Add(EventPotionGridState.GridState_Empty);
                    newPotionItemData.FromDisplayAreaIndexList.Add(-1);
                }
            }
            m_DataManager.PotionData.LevelProcessedList.Add(newPotionItemData);

            m_DataManager.InitScrollerDataList();

            AddDropStatisticalData(false);

            if (isResetUI)
            {
                var position = m_PotionScrollViewController.ScrollPosition;
                m_PotionScrollViewController.ReloadData();
                m_PotionWallScrollViewController.ReloadData();
                m_PotionScrollViewController.ScrollPosition = position;
                m_PotionWallScrollViewController.ScrollPosition = position;

                count = m_DataManager.WallBeforeCount + m_DataManager.PotionData.LevelProcessedList.Count;
                m_PotionScrollViewController.JumpToDataIndex(count, 0, 0f, true, EnhancedScroller.TweenType.linear, 0.3f);

                // 重置下方Item展示区域
                ResetItemsDisplayArea();
            }
        }
        private void OnGridItemBtnClickCallback(PotionGridUI gridUI)
        {
            if (IsClickOperationLocked) return;

            StartLockClickOperation();

            StartLockScrollView();

            int index = m_DataManager.WallBeforeCount + m_DataManager.PotionData.LevelProcessedList.Count;

            m_PotionScrollViewController.JumpToDataIndex(index, 0, 0, true, EnhancedScroller.TweenType.immediate, 0, () =>
            {
                this.StartCoroutine(OnScrollViewJumpCompleteCallback(gridUI));
            });
        }
        public IEnumerator OnScrollViewJumpCompleteCallback(PotionGridUI gridUI)
        {
            yield return null;
            PotionItem operationItem = GetOperationItem();
            if (operationItem == null) yield break;

            // 找到停靠点
            PotionGridUI target = FindFirstEmptyPotionGridUI();
            if (target == null) yield break;
            target.Copy(gridUI, false, false);
            target.HideUpperUI();

            // 找到用于显示飞行轨迹的临时PotionGridUI并初始化和播放初始动画
            PotionGridUI temporary = GetIdleTemporaryGridUI();
            if (temporary == null) yield break;
            temporary.SetTemporaryData(gridUI);

            // 消耗代币
            if (!ConsumeTokens(EventPotionConfig.Token_Consume_Num))
            {
                temporary.IsIdle = true;
                temporary.gameObject.SetActive(false);
                yield break;
            }

            // 更新目标数据
            target.SetColorType(gridUI.GetColorType());
            target.SetGridState(EventPotionGridState.GridState_Occupied);
            target.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);
            target.SetFromGridUI(gridUI);

            // 隐藏当前瓶子
            gridUI.SetGridState(EventPotionGridState.GridState_Occupied);
            gridUI.gameObject.SetActive(false);

            temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_fly, true);
            temporary.PlayAnimation(EventPotionConfig.anim_gild_jump);

            Vector3 targetPosition = target.transform.position;
            temporary.DOKill();

            //temporary.transform.DOMove(targetPosition, jump_move_duration_time).SetEase(Ease.OutQuad);
            //this.StartCoroutine(HandleJumpStep(1, gridUI, target, temporary));

            CheckFirstWrongGuide(target);

            // 锁定操作
            //int validNum = operationItem.GetVaildNum();
            int targetIndex = target.Index;
            int lastIndex = operationItem.GetLastValidIndex();
            if (targetIndex == lastIndex)
            {
                temporary.transform.DOMove(targetPosition, jump_move_duration_time).SetEase(Ease.OutQuad).OnComplete(() =>
                {
                    target.ShowIcon();
                    target.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);

                    temporary.IsIdle = true;
                    temporary.gameObject.SetActive(false);

                    //CheckFirstWrongGuide(target);
                    //UnlockScrollView();
                });
            }
            else
            {
                temporary.transform.DOMove(targetPosition, jump_move_duration_time).SetEase(Ease.OutQuad);
                this.StartCoroutine(HandleJumpStep(1, gridUI, target, temporary));
            }

            if (m_DataManager != null)
            {
                m_DataManager.SyncData();
            }
        }
        public IEnumerator HandleJumpStep(int type, PotionGridUI src, PotionGridUI target, PotionGridUI temporary)
        {
            yield return new WaitForSeconds(jump_waitfor_spine_shake_time);

            target.ShowIcon();
            target.PlaySpinAnimation(0, jump_spine_shake_anim, true);

            temporary.IsIdle = true;
            temporary.gameObject.SetActive(false);

            yield return new WaitForSeconds(jump_spine_shake_duration_time);

            target.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);

            //CheckFirstWrongGuide(target);

            //UnlockScrollView();
        }
        public void CheckForUpdate()
        {
            if (m_IsCheckingColorType == true) return;

            // 检查操作区是否全部上架
            PotionItem operationItem = GetOperationItem();
            if (operationItem == null) return;
            bool isOperationAllOnline = operationItem.CheckOperationAreaIsAllOnline();
            if (!isOperationAllOnline)
            {
                //Debug.LogWarning("----- CheckForUpdate 操作区没有完全上架");
                return;
            }

            // 检查展示区是否全部上架
            bool isAllDisplayAreaOnline = CheckAllDisplayAreaIsOnline();
            if (!isAllDisplayAreaOnline)
            {
                //Debug.LogWarning("----- CheckForUpdate 显示区没有完全上架");
                return;
            }

            // 检查临时区是否完全恢复为Idle状态
            bool isAllTemporaryIdle = IsAllTemporaryIdle();
            if (!isAllTemporaryIdle)
            {
                //Debug.LogWarning("----- CheckForUpdate 临时区没有完全恢复为Idle状态");
                return;
            }

            //Debug.LogWarning("===== Check 所有瓶子都移至上方格子");

            StartLockScrollView();

            if (CheckForWrongAsPreviously(operationItem) == true) return;

            m_IsCheckingColorType = true;

            m_DataManager.PotionData.CorrectNum = 0;
            if (operationItem.CheckGridListIsOk(PrepareGoToNextLevel, PrepareAddNewStepData))
            {
                m_DataManager.PotionData.IsOver = true;
                //Debug.LogWarning("===== Check 所有瓶子颜色都对齐了");
            }
            else
            {
                m_DataManager.PotionData.IsOver = false;
                //Debug.LogWarning("===== Check 瓶子颜色没有完全对齐");
            }
            operationItem.Reset_FromPotionGridUI_GridState();
            //m_DataManager.ResetDisplayAreaGridState(EventPotionGridState.GridState_Empty);
        }
        public PotionItem GetOperationItem()
        {
            if (m_PotionScrollViewController == null) return null;
            return m_PotionScrollViewController.GetOperationPotionItem();
        }
        private List<int> m_CommitColorTypeList = new List<int>();
        public List<int> CommitColorTypeList { get { return m_CommitColorTypeList; } }
        public void AddDropStatisticalData(bool isAllOk)
        {
            if (m_DataManager == null || m_DataManager.PotionData == null) return;

            PotionItemData operationItemData = m_DataManager.GetOperationItemData();
            if (operationItemData == null)
            {
                return;
            }
            string color_submit = Newtonsoft.Json.JsonConvert.SerializeObject(m_CommitColorTypeList);

            int combine_id = m_DataManager.PotionData.Round * 100 + m_DataManager.PotionData.LevelIndex + 1;
            var potionLevel = m_DataManager.GetCurrentPotionLevel();
            if (potionLevel == null) return;

            int is_correct = isAllOk ? 1 : 0;

            m_DataManager.PotionData.SubmitNum++;

#if AGG
            using (var e = GEvent.GameEvent("event_color_potion"))
            {
                e.AddContent("round", m_DataManager.PotionData.StageID)
                    .AddContent("stage", m_DataManager.PotionData.LevelIndex)
                    .AddContent("color_count", m_DataManager.PotionData.LevelDisplayData.ColorTypeList.Count)
                    .AddContent("correct_color", Newtonsoft.Json.JsonConvert.SerializeObject(m_DataManager.PotionData.LevelTargetData.ColorTypeList))
                    .AddContent("color_show", Newtonsoft.Json.JsonConvert.SerializeObject(m_DataManager.PotionData.LevelDisplayData.ColorTypeList))
                    .AddContent("color_submit", color_submit)
                    .AddContent("is_correct", is_correct)
                    .AddContent("item_count", m_DataManager.PotionData.ConsumedToken)
                    .AddContent("rule", m_DataManager.PotionData.Rule)
                    .AddContent("submit_count", m_DataManager.PotionData.SubmitNum)
                    .AddContent("drop_list", potionLevel.Reward)
                 .AddContent("combine_id", combine_id);

                var itemDataList = GContext.container.Resolve<PlayerItemData>()?.GetItemDataByDropId(potionLevel.Reward);
                if (itemDataList != null)
                {
                    for (int i = 0; i < itemDataList.Count; i++)
                    {
                        if (itemDataList[i].id == 1001)
                        {
                            e.AddContent("reward_hook", itemDataList[i].count);
                        }
                        //else if (itemDataList[i].id == 1002)
                        //{
                        //    e.AddContent("reward_cash", itemDataList[i].count);
                        //}
                    }
                }
            }
#endif
        }
        public void PrepareGoToNextLevel(int type, PotionGridUI gridUI)
        {
            // 进入下一关
            this.StartCoroutine(HandleDockStep(gridUI));
        }
        public IEnumerator HandleDockStep(PotionGridUI gridUI)
        {
            yield return new WaitForSeconds(dock_base_waiting_time);
            // 找到停靠点
            Vector3 dockPoint = m_DockPoint.position;

            var potionItem = gridUI.PotionItem;
            int count = potionItem.GetVaildNum();

            List<int> tmpIndexList = new List<int>();
            for (int i = 0; i < count; ++i)
            {
                tmpIndexList.Add(i);
            }
            m_DataManager.ShuffleList(tmpIndexList, false);

            List<PotionGridUI> temporaryList = new List<PotionGridUI>();

            float scale = dock_scale;
            float duration = dock_move_duration_time;
            float gapTime = dock_gap_time;
            int lastIndex = count - 1;

            for (int i = 0; i < count; i++)
            {
                int tmpIndex = tmpIndexList[i];

                PotionGridUI itemGridUI = potionItem.GetGridUI(tmpIndex);
                itemGridUI.HideUpperUI();

                PotionGridUI temporary = GetIdleTemporaryGridUI();
                //if (temporary == null) return;
                temporary.SetTemporaryData(itemGridUI);

                temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);

                temporaryList.Add(temporary);

                Vector3 dockPosition = new Vector3(itemGridUI.transform.position.x, dockPoint.y, dockPoint.z);
                temporary.transform.DOKill();

                int index = tmpIndex;
                bool isLast = i == lastIndex;

                temporary.OpenAudioFly();
                temporary.transform.DOMove(dockPosition, duration).SetEase(Ease.OutQuad).OnComplete(() =>
                {
                    temporary.CloseAudioFly();
                    this.StartCoroutine(HandleFinalStepByGridUI(temporaryList, temporary, index, count, isLast));
                });

                temporary.transform.DOScale(scale, duration).SetEase(Ease.Linear);
                if (gapTime > 0 && !isLast)
                {
                    yield return new WaitForSeconds(gapTime);
                }
            }
        }
        public IEnumerator HandleFinalStep(List<PotionGridUI> temporaryList)
        {
            yield return new WaitForSeconds(dock_waitfor_final_time);

            int count = temporaryList.Count;
            List<Vector3> finalPositionList = GetFinalPositionList(count);

            float scale = final_scale;
            float duration = final_move_duration_time;
            //float baseDelayTime = final_base_waiting_time;
            float gapTime = final_gap_time;
            int lastIndex = count - 1;

            for (int i = 0; i < count; i++)
            {
                PotionGridUI temporary = temporaryList[i];

                Vector3 finalPosition = finalPositionList[i];

                temporary.transform.DOKill();

                if (i == lastIndex)
                {
                    temporary.transform.DOLocalMove(finalPosition, duration).SetEase(Ease.OutQuad).OnComplete(() =>
                    {
                        this.StartCoroutine(HandleFountainStep(temporaryList));
                    });
                }
                else
                {
                    temporary.transform.DOLocalMove(finalPosition, duration).SetEase(Ease.OutQuad);
                }
                temporary.transform.DOScale(scale, duration).SetEase(Ease.Linear);

                if (gapTime > 0)
                {
                    yield return new WaitForSeconds(gapTime);
                }
            }
        }
        public IEnumerator HandleFountainStep(List<PotionGridUI> temporaryList)
        {
            int count = temporaryList.Count;

            float scale = final_scale;
            float duration = final_move_duration_time;
            //float baseDelayTime = final_base_waiting_time;
            float gapTime = final_gap_time;
            int lastIndex = count - 1;

            for (int i = 0; i < count; i++)
            {
                PotionGridUI temporary = temporaryList[i];

                temporary.PlayAnimation(EventPotionConfig.anim_gild_settlement);

                if (temporary.transform.position.x < centerPointPosition.x)
                {
                    temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_R, false);
                    temporary.SetPourWaterRight();
                }
                else
                {
                    temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_L, false);
                    temporary.SetPourWaterLeft();
                }

                if (gapTime > 0)
                {
                    yield return new WaitForSeconds(gapTime);
                }
            }

            yield return new WaitForSeconds(final_pour_duration_time);

            for (int i = 0; i < count; i++)
            {
                PotionGridUI temporary = temporaryList[i];

                temporary.IsIdle = true;
                temporary.gameObject.SetActive(false);
            }

            if (fx_eventpoison_ui_reward != null)
            {
                fx_eventpoison_ui_reward.SetActive(true);
            }

            yield return new WaitForSeconds(final_ui_fx_duration_time);

            OnFinalOperationComplete();

            if (fx_eventpoison_ui_reward != null)
            {
                fx_eventpoison_ui_reward.SetActive(false);
            }

            yield return new WaitForSeconds(0.2f);

            StartCoroutine(ResetTemporary());
        }
        public IEnumerator HandleFinalStepByGridUI(List<PotionGridUI> temporaryList, PotionGridUI temporary, int index, int count, bool isLast)
        {
            //yield return new WaitForSeconds(dock_waitfor_final_time);

            temporary.PlayAnimation(EventPotionConfig.anim_gild_gap);
            yield return new WaitForSeconds(dock_animation_gap_duration_time);

            List<Vector3> finalPositionList = GetFinalPositionList(count);

            float scale = final_scale;
            float duration = final_move_duration_time;
            float gapTime = final_gap_time;

            Vector3 finalPosition = finalPositionList[index];

            temporary.transform.DOKill();

            if (isLast)
            {
                temporary.transform.DOLocalMove(finalPosition, duration).SetEase(Ease.OutQuad).OnComplete(() =>
                {
                    this.StartCoroutine(HandleFountainStepByGridUI(temporaryList, temporary, index, count, isLast));
                });
            }
            else
            {
                temporary.transform.DOLocalMove(finalPosition, duration).SetEase(Ease.OutQuad);
            }

            temporary.transform.DOScale(scale, duration).SetEase(Ease.Linear);
        }
        public IEnumerator HandleFountainStepByGridUI(List<PotionGridUI> temporaryList, PotionGridUI temporary, int index, int count, bool isLast)
        {
            float scale = final_scale;
            float duration = final_move_duration_time;
            float gapTime = final_gap_time;

            //int num = m_Data.ColorTypeList.Count;
            int num = temporaryList.Count;

            for (int i = 0; i < num; ++i)
            {
                PotionGridUI item = temporaryList[i];
                EventPotionGridState gridState = item.GetGridState();
                if (gridState == EventPotionGridState.GridState_Over)
                {
                    continue;
                }

                item.PlayAnimation(EventPotionConfig.anim_gild_settlement);

                if (item.transform.position.x < centerPointPosition.x)
                {
                    item.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_R, false);
                    item.SetPourWaterRight();
                }
                else
                {
                    item.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_L, false);
                    item.SetPourWaterLeft();
                }


            }
            //temporary.PotionItem.

            //temporary.PlayAnimation(EventPotionConfig.anim_gild_settlement);

            OpenAudioPouring();

            if (TopMouth != null)
            {
                TopMouth.SetActive(true);
            }

            //if (temporary.transform.position.x < centerPointPosition.x)
            //{
            //    temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_R, false);
            //    temporary.SetPourWaterRight();
            //}
            //else
            //{
            //    temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_pour_L, false);
            //    temporary.SetPourWaterLeft();
            //}

            //if (index == 0)
            //{
            //    this.StartCoroutine(StartFountainRippleEffect());
            //}

            this.StartCoroutine(StartFountainRippleEffect());

            yield return new WaitForSeconds(final_pour_duration_time);

            for (int i = 0; i < num; ++i)
            {
                PotionGridUI item = temporaryList[i];
                EventPotionGridState gridState = item.GetGridState();
                if (gridState == EventPotionGridState.GridState_Over)
                {
                    continue;
                }

                item.IsIdle = true;
                item.gameObject.SetActive(false);
            }

            //temporary.IsIdle = true;
            //temporary.gameObject.SetActive(false);

            if (TopMouth != null)
            {
                TopMouth.SetActive(false);
            }

            if (isLast)
            {
                CloseAudioPouring();

                StopFountainRippleEffect();

                if (fx_eventpoison_ui_reward != null)
                {
                    fx_eventpoison_ui_reward.SetActive(true);
                }

                yield return new WaitForSeconds(final_ui_fx_duration_time);

                OnFinalOperationComplete();

                if (fx_eventpoison_ui_reward != null)
                {
                    fx_eventpoison_ui_reward.SetActive(false);
                }

                yield return new WaitForSeconds(0.1f);

                StartCoroutine(ResetTemporary());
            }
        }

        public void PrepareAddNewStepData(int type, PotionGridUI gridUI)
        {
            // 添加新的数据
            AddNewStepData(true);
        }
        public IEnumerator HandleShowStep(PotionGridUI gridUI, int index, float delayTime, EventPotionGridState gridState)
        {
            yield return new WaitForSeconds(delayTime);

            // 找到用于显示飞行轨迹的临时PotionGridUI并初始化和播放初始动画
            PotionGridUI temporary = GetIdleTemporaryGridUI();
            if (temporary != null)
            {
                temporary.SetTemporaryData(gridUI);
                temporary.PlayAnimation(EventPotionConfig.anim_gild_show);
                temporary.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);

                gridUI.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);

                yield return new WaitForSeconds(show_waitfor_spine_shake_time);

                temporary.PlaySpinAnimation(0, show_spine_shake_anim, true);

                yield return new WaitForSeconds(show_spine_shake_duration_time);

                temporary.IsIdle = true;
                temporary.gameObject.SetActive(false);

                gridUI.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, true);
                gridUI.gameObject.SetActive(true);
            }
        }
        private IEnumerator ResetTemporary()
        {
            foreach (var item in m_TemporaryItemList)
            {
                Vector3 position = item.transform.localPosition;
                position.y = -2000;
                item.gameObject.SetActive(true);
                item.transform.localPosition = position;
                item.PlaySpinAnimation(0, EventPotionConfig.spine_potion_idle, false);
            }
            yield return new WaitForSeconds(0.2f);

            foreach (var item in m_TemporaryItemList)
            {
                item.gameObject.SetActive(false);
            }
        }
        public PotionGridUI FindFirstEmptyPotionGridUI()
        {
            PotionItem potionItem = GetOperationItem();

            if (potionItem == null) return null;

            int count = potionItem.GetVaildNum();
            for (int i = 0; i < count; ++i)
            {
                var gridUI = potionItem.GetGridUI(i);
                if (gridUI.GetGridState() == EventPotionGridState.GridState_Empty) return gridUI;
            }
            return null;
        }
        private LinkedList<PotionAction> m_ActionChain = new LinkedList<PotionAction>();
        private void UpdateActionChain()
        {
            float deltaTime = Time.deltaTime;
            LinkedListNode<PotionAction> currentNode = m_ActionChain.First;
            while (currentNode != null)
            {
                LinkedListNode<PotionAction> nextNode = currentNode.Next;

                currentNode.Value.Update(deltaTime);
                if (currentNode.Value.IsValid() == false)
                {
                    currentNode.Value.Action();
                    m_ActionChain.Remove(currentNode);
                }
                currentNode = nextNode;
            }
        }
        public void AddAction(PotionAction action)
        {
            m_ActionChain.AddLast(action);
        }
        #endregion

        #region 新手引导
        public IEnumerator InitGuidance(float waitTime)
        {
            yield return new WaitForSeconds(waitTime);

            m_FirstWrongGridUI = null;

            GContext.container.Resolve<GuideDataCenter>().InspectTriggerGuide("EventPotionPanel", curPanelName: gameObject.name);
        }
        PotionGridUI m_FirstWrongGridUI = null;
        public void CheckFirstWrongGuide(PotionGridUI gridUI)
        {
            if (gridUI == null) return;

            EventPotionGridState gridState = gridUI.GetGridState();
            if (gridState == EventPotionGridState.GridState_Over) return;

            int count = m_DataManager.PotionData.LevelProcessedList.Count;
            if (count < 0) return;

            var potionItem = gridUI.PotionItem;
            if (potionItem == null) return;

            PotionItemData curData = potionItem.Data;
            int curIndex = m_DataManager.PotionData.LevelProcessedList.IndexOf(curData);
            if (curIndex < 1) return;

            int preIndex = curIndex - 1;
            PotionItemData preData = m_DataManager.PotionData.LevelProcessedList[preIndex];
            if (preData == null) return;

            int index = gridUI.Index;
            int curColorType = gridUI.GetColorType();
            int preColorType = preData.GetColorType(index);
            if (preColorType < 100) return;

            int colorType = preColorType % 100;
            if (curColorType != colorType) return;

            //if (curColorType == m_DataManager.PotionData.LevelTargetData.ColorTypeList[index]) return;

            if (m_DataManager.HasPotionIDSaveKey(EventPotionConfig.key_first_check_wrong)) return;

            StartLockClickOperation();
            StartLockScrollView();

            StartCoroutine(ShowFirstWrongGuide(gridUI));
        }
        public IEnumerator ShowFirstWrongGuide(PotionGridUI gridUI)
        {
            yield return new WaitForSeconds(jump_move_duration_time);
            isLockMask = true;

            mask.gameObject.SetActive(true);
            PotionFirstWrongGuideTips.SetActive(true);

            Vector3 position = gridUI.transform.position;
            position.x = PotionFirstWrongGuideTips.transform.position.x;
            position.y += 50;
            PotionFirstWrongGuideTips.transform.position = position;

            gridUI.FirstWrongGuide();
            m_FirstWrongGridUI = gridUI;

            //StartCoroutine(AutoReleaseUnclockMaskOperation());
            yield return new WaitForSeconds(lock_mask_operation_time);
            isLockMask = false;
            StopLockClickOperation();
        }
        //public IEnumerator AutoReleaseUnclockMaskOperation()
        //{
        //    yield return new WaitForSeconds(lock_mask_operation_time);
        //    isLockMask = false;
        //}
        public bool CheckForWrongAsPreviously(PotionItem potionItem)
        {
            if (potionItem == null || potionItem.Data == null) return false;

            int count = m_DataManager.PotionData.LevelProcessedList.Count;
            if (count < 0) return false;

            PotionItemData curData = potionItem.Data;
            int index = m_DataManager.PotionData.LevelProcessedList.IndexOf(curData);
            if (index < 1) return false;

            int preIndex = index - 1;
            PotionItemData preData = m_DataManager.PotionData.LevelProcessedList[preIndex];
            if (preData == null) return false;

            if (m_DataManager.HasPotionIDSaveKey(EventPotionConfig.key_first_check_combination_wrong)) return false;

            bool flag = true;
            count = curData.ColorTypeList.Count;
            for (int i = 0; i < count; ++i)
            {
                var curState = curData.GetGridState(i);
                if (curState == EventPotionGridState.GridState_Over)
                {
                    continue;
                }

                var curColorType = curData.GetColorType(i) % 100;
                var preColorType = preData.GetColorType(i) % 100;
                if (curColorType != preColorType)
                {
                    flag = false;
                }
            }

            if (flag == true)
            {
                ToastPanel.Show(LocalizationMgr.GetText("UI_ToastPanel_96"));
                potionItem.ReturnAllUncertainGridUI();
                //if (potionItem.ReturnAllUncertainGridUI())
                //{
                //    m_IsCheckingColorType = false;
                //}
            }

            m_DataManager.SavePotionIDData(EventPotionConfig.key_first_check_combination_wrong, "ok");

            return flag;
        }
        #endregion

        #region 生命周期
        public void OpenUI()
        {
            CloseAudioPouring();

            InitEvent();

            InitUIData();

            // 判断是否存在前一关未完成操作
            CheckForPreLevelOperation();

            ShowUI();

            FishingPotionAct.IsInitPanelComplete = true;
        }
        private void ProcessAdaptation()
        {
            InitUI();

            RectTransform scrollViewRectTransform = m_PotionScrollViewController.transform.GetComponent<RectTransform>();

            float scrollViewHeight = scrollViewRectTransform.rect.height;

            float itemHeight = m_PotionScrollViewController.GetCellViewSize(null, 0);

            int times = (int)Mathf.Ceil(scrollViewHeight / itemHeight);

            m_ScrollViewMinimumQuantity = times - 1;

            m_DataManager.InitWalls(times);
            m_DataManager.InitScrollerDataList();
        }
        protected override void Start()
        {
            base.Start();

            m_DataManager = GContext.container.Resolve<EventPotionDataManager>();

            ProcessAdaptation();

            OpenUI();

            UnlockScrollView();
        }
        private void Update()
        {
            if (m_PotionScrollViewController != null && m_PotionWallScrollViewController != null)
            {
                m_PotionWallScrollViewController.ScrollPosition = m_PotionScrollViewController.ScrollPosition;
            }
            CheckForUpdate();
            UpdateLockAction(Time.deltaTime);
            //UpdateActionChain();
        }
        #endregion

        #region 数据处理
        private void InitUIData()
        {
            isLockMask = false;
            m_IsCheckingColorType = false;

            StopLockClickOperation();

            ClearTemporaryGridUIToIdle();

            UpdateToken(null);
            UpdateReward();
            UpdateProgress();
        }

        private void UpdateReward()
        {
            var level = m_DataManager.GetCurrentPotionLevel();
            if (level == null) return;
            var rewardList = GContext.container.Resolve<PlayerItemData>()?.GetItemDataByDropId(level.Reward);
            if (rewardList == null || rewardList.Count < 1) return;

            int count = m_RewardRootList.Count;
            int num = rewardList.Count;
            for (int i = 0; i < count; i++)
            {
                if (i < num)
                {
                    m_RewardRootList[i].SetActive(true);
                    m_RewardItemNewList[i].SetData(rewardList[i]);
                }
                else
                {
                    m_RewardRootList[i].SetActive(false);
                }
            }
        }
        private void UpdateProgress()
        {
            if (m_DataManager == null || m_DataManager.PotionData == null) return;

            // 获取当前轮次等级总数
            int levelCount = 0;
            if (m_DataManager.PotionData.StageID == 1) levelCount = m_DataManager.PotionData.Stage1TotalLevel;
            else levelCount = m_DataManager.PotionData.Stage2TotalLevel;

            // 计算坐标相关数据
            RectTransform rectTransform = layout_line.GetComponent<RectTransform>();
            Vector2 tmp = rectTransform.sizeDelta;
            float totalWidth = layout_line.GetComponent<RectTransform>().sizeDelta.x;
            float gapW = totalWidth / levelCount;
            float baseX = (-totalWidth / 2) + gapW;
            float y = img_progress_line.transform.localPosition.y;
            float z = img_progress_line.transform.localPosition.z;

            // 增加Image
            int num = img_progress_line_list.Count;
            Vector2 size = img_progress_line.GetComponent<RectTransform>().sizeDelta;
            int lineCount = levelCount - 1;
            for (int i = num; i < lineCount; i++)
            {
                GameObject gameObject = new GameObject("line_" + i);
                gameObject.transform.SetParent(layout_line);

                Image image = gameObject.AddComponent<Image>();
                image.sprite = img_progress_line.sprite;

                gameObject.transform.GetComponent<RectTransform>().sizeDelta = size;
                gameObject.transform.localScale = img_progress_line.transform.localScale;
                gameObject.transform.localPosition = img_progress_line.transform.localPosition;

                img_progress_line_list.Add(image);
            }

            // 调整间隔坐标
            num = img_progress_line_list.Count;
            for (int i = 0; i < num; i++)
            {
                Image image = img_progress_line_list[i];
                if (i < lineCount)
                {
                    image.gameObject.SetActive(true);
                    image.transform.localPosition = new Vector3(baseX + i * gapW, y, z);
                }
                else
                {
                    image.gameObject.SetActive(false);
                }
            }

            // 更新process bar
            int index = 0;
            if (m_DataManager.PotionData.IsOver == true)
            {
                index = m_DataManager.PotionData.LevelIndex + 1;
            }
            else
            {
                index = m_DataManager.PotionData.LevelIndex;
            }
            bar.fillAmount = ((float)index) / levelCount;
            text_progress.text = index + "/" + levelCount;
        }
        private List<Vector3> GetFinalPositionList(int num)
        {
            EventPotionBottle eventPotionBottle = m_DataManager.GetEventPotionBottle(num);
            int count = eventPotionBottle.BottleLsit.Count;

            List<Vector3> list = new List<Vector3>();
            for (int i = 0; i < count; ++i)
            {
                int index = eventPotionBottle.BottleLsit[i];
                list.Add(operatingPointTransformList[index]);
            }
            return list;
            //System.Random random = new System.Random();
            //return operatingPointTransformList.OrderBy(x => random.Next()).Take(num).ToList();
        }
        public List<int> FindValidDisplayGridUIRefList()
        {
            List<int> list = new List<int>();
            int count = m_DisplayGridItemList.Count;
            for (int i = 0; i < count; ++i)
            {
                PotionGridUI item = m_DisplayGridItemList[i];
                if (item.GetGridState() == EventPotionGridState.GridState_Empty &&
                    item.ItemData.GetColorType(item.Index) > EventPotionConfig.PotionItemType_Empty)
                {
                    list.Add(i);
                }
            }
            return list;
        }
        public bool CheckAllDisplayAreaIsOnline()
        {
            int count = m_DisplayGridItemList.Count;
            int validNum = m_DataManager.PotionData.LevelDisplayData.ColorTypeList.Count;

            for (int i = 0; i < count; ++i)
            {
                var gridUI = m_DisplayGridItemList[i];
                if (gridUI.IsActive()) return false;

                if (i < validNum)
                {
                    if (gridUI.ItemData == null) continue;
                    var gridState = gridUI.GetGridState();
                    if (gridState != EventPotionGridState.GridState_Occupied && gridState != EventPotionGridState.GridState_Over)
                    {
                        return false;
                    }
                }
            }
            return true;
        }
        private float ResetItemsDisplayArea()
        {
            m_IsCheckingColorType = false;
            UnlockScrollView();

            // 处理item_group
            List<int> displayIndexRefList = m_DataManager.GetValidDisplayDataList();
            int num = displayIndexRefList.Count;

            RectTransform itemRectTransform = m_DisplayGridItemList[0].GetComponent<RectTransform>();

            Vector2 itemAnchorPosition = itemRectTransform.pivot;

            float itemWidth = itemRectTransform.sizeDelta.x;
            float totalWidth = num * itemWidth;

            float baseX = totalWidth / 2;
            baseX = -baseX + itemWidth * itemAnchorPosition.x;
            float baseY = itemRectTransform.localPosition.y;
            float baseZ = itemRectTransform.localPosition.z;

            int indexForPosition = 0;
            int indexForTime = 0;
            int count = m_DisplayGridItemList.Count;
            float baseDelayTime = show_base_waiting_time;
            float gapTime = show_gap_time;

            float waitTime = 0f;

            num = m_DataManager.PotionData.LevelDisplayData.ColorTypeList.Count;
            for (int i = 0; i < count; ++i)
            {
                PotionGridUI item = m_DisplayGridItemList[i];
                if (i < num)
                {
                    EventPotionGridState gridState = m_DataManager.PotionData.LevelDisplayData.GridStateList[i];

                    if (gridState == EventPotionGridState.GridState_Over)
                    {
                        item.SetData(m_DataManager.PotionData.LevelDisplayData, i, null, false);
                        continue;
                    }

                    item.SetRootPosition(new Vector3(baseX + indexForPosition * itemWidth, baseY, baseZ));
                    item.SetData(m_DataManager.PotionData.LevelDisplayData, i, null, true);
                    item.gameObject.SetActive(false);
                    indexForPosition++;

                    if (gridState == EventPotionGridState.GridState_Empty)
                    {
                        int index = i;
                        float delayTime = baseDelayTime + indexForTime * gapTime;
                        this.StartCoroutine(HandleShowStep(item, index, delayTime, gridState));
                        indexForTime++;

                        waitTime = delayTime;
                    }
                }
                else
                {
                    item.SetData(null, -1, null, false);
                }
            }

            StopLockClickOperation();

            waitTime += show_waitfor_spine_shake_time;
            return waitTime;
        }
        public PotionGridUI GetDisplayPotionGridUI(int index)
        {
            if (m_DisplayGridItemList == null || m_DisplayGridItemList.Count < 1 || index >= m_DisplayGridItemList.Count) return null;

            return m_DisplayGridItemList[index];
        }
        #endregion

        #region UI
        // questionmark
        private Button btn_questionmark;
        private async void OnBtnQuestionmarkClickListener()
        {
            if (IsClickOperationLockedPure) return;
            await UIManager.Instance.ShowUI(m_DataManager.GetInfoPanel());
        }

        // progress bar
        private Image bar;
        private TMP_Text text_progress;
        private Transform layout_line;
        private Image img_progress_line;
        private List<Image> img_progress_line_list = new List<Image>();
        private Button btn_reward;
        private async void OnBtnRewardClickListener()
        {
            if (IsClickOperationLockedPure) return;
            var panel = await UIManager.Instance.ShowUI(UITypes.EventPotionRewardTips);
            if (panel == null)
                return;
            var rewardList = GContext.container.Resolve<PlayerItemData>().GetItemDataByDropId(m_DataManager.GetLastStageInCurRound().Reward);
            panel.GetComponent<EventPotionRewardTips>().Init(rewardList, btn_reward.transform);
        }

        // Reward
        private List<GameObject> m_RewardRootList = new List<GameObject>();
        private List<RewardItemNew> m_RewardItemNewList = new List<RewardItemNew>();

        // item group
        private List<PotionGridUI> m_DisplayGridItemList = new List<PotionGridUI>();

        // icon_ticket
        private TMP_Text text_num;
        private TicketTips ticket_tips;
        private Button icon_ticket;
        private void OnBtnIconTicketClickListener()
        {
            if (IsClickOperationLockedPure) return;
            ticket_tips.gameObject.SetActive(true);
        }

        // Guide
        private Button mask;
        private GameObject PotionFirstWrongGuideTips;
        public float lock_mask_operation_time = 1.0f;
        bool isLockMask = false;
        private void OnBtnMaskClickListener()
        {
            if (isLockMask == true) return;

            mask.gameObject.SetActive(false);
            PotionFirstWrongGuideTips.SetActive(false);

            //PotionItem operationItem = GetOperationItem();
            //if (operationItem == null) return;
            //operationItem.ResumeFromGuide();

            if (m_FirstWrongGridUI == null) return;
            m_FirstWrongGridUI.ResumeFromGuide();
            m_FirstWrongGridUI.PotionItem.OnBtnClickCallback(m_FirstWrongGridUI);
            m_FirstWrongGridUI = null;

            m_DataManager.SavePotionIDData(EventPotionConfig.key_first_check_wrong, "ok");
        }

        private void InitUI()
        {
            int num = 0;

            // btn_questionmark
            btn_questionmark = transform.Find("root_main/title/btn_questionmark").GetComponent<Button>();
            btn_questionmark.onClick.RemoveAllListeners();
            btn_questionmark.onClick.AddListener(OnBtnQuestionmarkClickListener);

            // reward
            num = 4;
            for (int i = 1; i < num; i++)
            {
                GameObject gameObject = transform.Find($"root_main/reward_group/reward_{i}").gameObject;
                m_RewardRootList.Add(gameObject);
                RewardItemNew rewardItem = gameObject.transform.Find("reward").GetComponent<RewardItemNew>();
                m_RewardItemNewList.Add(rewardItem);
            }

            // progress bar
            bar = transform.Find("root_main/btn_bubble_task/bg_bar/bar").GetComponent<Image>();
            text_progress = transform.Find("root_main/btn_bubble_task/text_progress").GetComponent<TMP_Text>();
            layout_line = transform.Find("root_main/btn_bubble_task/bg_bar/layout_line");
            img_progress_line = transform.Find("root_main/btn_bubble_task/bg_bar/layout_line/line").GetComponent<Image>();
            btn_reward = transform.Find("root_main/btn_bubble_task/btn_reward").GetComponent<Button>();
            btn_reward.onClick.RemoveAllListeners();
            btn_reward.onClick.AddListener(OnBtnRewardClickListener);
            img_progress_line_list.Clear();
            img_progress_line_list.Add(img_progress_line);

            // item group
            num = 8;
            for (int i = 1; i < num; i++)
            {
                PotionGridUI gridUI = transform.Find($"root_main/item_group/displayItem{i}").GetComponent<PotionGridUI>();

                gridUI.Init(i - 1, OnGridItemBtnClickCallback, null, m_DataManager);

                m_DisplayGridItemList.Add(gridUI);
            }

            // icon_ticket
            text_num = transform.Find("root_main/icon_ticket/text_num").GetComponent<TMP_Text>();
            ticket_tips = transform.Find("root_main/ticket_tips").GetComponent<TicketTips>();
            icon_ticket = transform.Find("root_main/icon_ticket").GetComponent<Button>();
            icon_ticket.onClick.RemoveAllListeners();
            icon_ticket.onClick.AddListener(OnBtnIconTicketClickListener);

            // Guide
            mask = transform.Find("mask").GetComponent<Button>();
            mask.onClick.RemoveAllListeners();
            mask.onClick.AddListener(OnBtnMaskClickListener);
            mask.gameObject.SetActive(false);
            PotionFirstWrongGuideTips = transform.Find("PotionFirstWrongGuideTips").gameObject;
            PotionFirstWrongGuideTips.SetActive(false);

            // EnhancedScroller
            m_PotionWallScrollViewController = transform.Find("root_main/PotionWallScrollView").GetComponent<PotionWallScrollViewController>();
            m_PotionScrollViewController = transform.Find("root_main/PotionScrollView").GetComponent<PotionScrollViewController>();

            // 关闭按钮
            btn_close = transform.Find("btn_close").GetComponent<Button>();
            btn_close.onClick.RemoveAllListeners();
            btn_close.onClick.AddListener(OnBtnCloseClickListener);

            foreach (var item in m_TemporaryItemList)
            {
                item.Init(0, null, null, m_DataManager);
            }
        }

        private void ShowUI()
        {
            StopFountainRippleEffect();

            if (m_DataManager.PotionData == null) return;

            // EnhancedScroller
            m_PotionWallScrollViewController.Init(m_PotionWallScrollViewController, m_DataManager);
            m_PotionScrollViewController.Init(m_PotionScrollViewController, this, m_DataManager);

            int index = m_DataManager.WallBeforeCount + m_DataManager.PotionData.LevelProcessedList.Count;
            m_PotionScrollViewController.JumpToDataIndex(index);

            var operationItem = GetOperationItem();
            if (operationItem != null && operationItem.CheckOperationAreaIsAllOnline())
            {
                //LockScrollView();
                ////if (CheckForWrongAsPreviously(operationItem) == true) return;

                if (operationItem.CheckGridListIsOk(PrepareGoToNextLevel, PrepareAddNewStepData))
                {
                    m_DataManager.PotionData.IsOver = true;
                    //Debug.LogWarning("===== ShowUI 所有瓶子颜色都对齐了");
                }
                else
                {
                    m_DataManager.PotionData.IsOver = false;
                    //Debug.LogWarning("===== ShowUI 瓶子颜色没有完全对齐");
                }
                if (m_DataManager != null)
                {
                    m_DataManager.ResetDisplayAreaGridState(EventPotionGridState.GridState_Empty);
                }

                int count = m_DisplayGridItemList.Count;
                for (int i = 0; i < count; ++i)
                {
                    var gridUI = m_DisplayGridItemList[i];
                    gridUI.gameObject.SetActive(false);
                }
            }

            // item group
            float waitTime = ResetItemsDisplayArea();
            StartCoroutine(InitGuidance(waitTime));
        }
        #endregion

        #region 事件相关
        private void InitEvent()
        {
            FishingPotionAct.Subscribe<EventPotionTokenUpdateData>(UpdateToken);
            // 监听关闭奖励面板
            GContext.OnEvent<RewardPanelClose>().Subscribe(OnRewardPanelClose).AddTo(FishingPotionAct.Disposables);
        }
        private void UpdateToken(EventPotionTokenUpdateData data)
        {
            if (m_DataManager == null || text_num == null) return;
            int token = m_DataManager.GetToken();
            text_num.text = "" + m_DataManager.GetToken();
            if (token > 0)
            {
                text_num.color = Color.white;
            }
            else
            {
                text_num.color = Color.red;
            }
        }
        private void OnRewardPanelClose(RewardPanelClose data)
        {
            if (itemDataList != null && itemDataList.Count > 0)
            {
                itemDataList = null;
                GoToNextLevel();
            }
        }
        #endregion

        #region 代币相关
        public bool ConsumeTokens(int count)
        {
            if (m_DataManager == null) return false;
            bool isEnough = m_DataManager.ConsumeTokens(count);
            if (isEnough == false)
            {
                ticket_tips.gameObject.SetActive(true);
            }
            return isEnough;
        }
        #endregion

        #region EnhancedScroller Handlers
        PotionScrollViewController m_PotionScrollViewController;
        PotionWallScrollViewController m_PotionWallScrollViewController;

        #endregion

        #region 关闭按钮
        // 关闭按钮
        Button btn_close;
        public void OnBtnCloseClickListener()
        {
            if (IsClickOperationLockedPure) return;
            FishingPotionAct.Publish<EventPotionCloseCameraData>(new EventPotionCloseCameraData());
            // 关闭当前Act
            GContext.Publish(new UnloadActToNextAct());
        }
        #endregion
    }
}