using System.Collections.Generic;
using System.Linq;
using System.Threading;
using cfg.LevelCfg;
using Cysharp.Threading.Tasks;
using Framework;
using Gameplay;
using Gameplay.Level;
using Gameplay.SubSystems;
using PhxhSDK;
using TMPro;
using UnityEngine;
using Button = UnityEngine.UI.Button;
using Image = UnityEngine.UI.Image;

public class UI_LevelSelectController : UIWindow
{
    //UI GameObj
    ///Auto Gen Start///
    public Button Button_Back;

    public TMP_Text Text_Back;
    public Button Button_Home;
    public Button Button_MainLevel;
    public Image Image_MainlevelLogo;
    public Button Button_DungeonlEVEL;
    public Image Image_TextBG;
    public TMP_Text Text_MainLevel;
    public TMP_Text Text_Campaignnode;
    public Image Image_BlackBar;
    public TMP_Text Text_MainLevelProcess;
    public TMP_Text Text_MainLevelNum;
    public TMP_Text Text_MainLevelName;
    public Image Image_Seperate;
    public Image Image_LastRect;
    public TMP_Text Text_LastLevel;
    public TMP_Text Text_LastLevelNum;
    public TMP_Text Text_LastLevelName;
    public Button Button_BranchLevel;
    public Image Image_ChapterBG;
    public TMP_Text Text_Title;
    public Image Image_FractionlLogo;
    public Image Image_LevelBG;
    public TMP_Text Text_ChapterName;
    public TMP_Text Text_ChapterNum;
    public Image Image_ProcessBG;
    public Image Image_ProcessBar;
    public Image Image_Reward01;
    public Image Image_Reward02;
    public Image Image_Reward03;
    public Button Button_GetAll;
    public TMP_Text Text_StarNum;
    public Image Image_Start;
    public Image Image_ModeBG;
    public Image Image_SelectBG;
    public Button Button_Plot;
    public TMP_Text Text_Read;
    public Image Image_Pot;
    public Button Button_Easy;
    public TMP_Text Text_Simple;
    public Button Button_Hard;
    public TMP_Text Text_Hard;
    public Image Image_pot;
    public TMP_Text Text_Mode;

    ///Auto Gen End///
    private const string IN_ANIMATION_NAME = "LS_MoveIn";

    private const string OUT_ANIMATION_NAME = "LS_MoveOut";

    /// <summary>
    /// 电池
    /// </summary>
    private class Batterie : UIGameObjectWrapper
    {
        /// <summary>
        /// 电池电量
        /// </summary>
        private readonly List<GameObject> listBatteryPower;

        public Batterie(GameObject root) : base(root)
        {
            listBatteryPower = new(GoRoot.transform.childCount);
            for (int i = 0; i < GoRoot.transform.childCount; ++i)
            {
                listBatteryPower.Add(GoRoot.transform.GetChild(i).gameObject);
            }
        }

        /// <summary>
        /// 入口
        /// </summary>
        /// <param name="batteryPower"></param>
        public void SetInfo(float batteryPower)
        {
            int showCount = Mathf.CeilToInt(listBatteryPower.Count * batteryPower);
            for (int i = 0; i < listBatteryPower.Count; ++i)
            {
                listBatteryPower[i].IsScaleShow(i + 1 == showCount);
            }
        }
    }

    /// <summary>
    /// WIFI
    /// </summary>
    private class NetSignal : UIGameObjectWrapper
    {
        /// <summary>
        /// Wifi信号
        /// </summary>
        private readonly List<GameObject> listWifi;

        public NetSignal(GameObject root) : base(root)
        {
            listWifi = new(GoRoot.transform.childCount);
            for (int i = 0; i < GoRoot.transform.childCount; ++i)
            {
                listWifi.Add(GoRoot.transform.GetChild(i).gameObject);
            }
        }

        /// <summary>
        /// 入口
        /// </summary>
        /// <param name="networkSignal"></param>
        public void SetInfo(float networkSignal)
        {
            int showCount = Mathf.CeilToInt(listWifi.Count * networkSignal);
            for (int i = 0; i < listWifi.Count; ++i)
            {
                listWifi[i].IsScaleShow(i + 1 == showCount);
            }
        }
    }

    private enum PageType
    {
        Mode = 1,
        Chapter = 2,
        Level = 3,
    }

    private Animation _animation;

    private PageType _currPage = PageType.Mode;
    private LevelChapterType _currChapterType;
    private ChapterInfo _currChapterInfo;
    private LevelGroupInfo _currEasyLevelGroupInfo;
    private LevelGroupInfo _currHardLevelGroupInfo;
    private LevelGroupInfo _currPlotLevelGroupInfo;
    private LevelGroupInfo _currLevelGroupInfo;
    private LevelInfo _currSelectLevelInfo;
    private List<ChapterInfo> _showChapterInfoList = new();
    private List<LevelInfo> _showLevelInfoList = new();

    private RectTransform UI_ModeChoose;
    private RectTransform UI_LevelGroupChoose;
    private RectTransform UI_LevelChoose;
    private RectTransform _modeParent;
    private RecycleView _levelGroupScrollView;
    private RecycleView _levelScrollView;
    private RectTransform _starRewardsParent;
    private RedPointUIController _easyLevelGroupRedPointUI;
    private RedPointUIController _hardLevelGroupRedPointUI;
    private RedPointUIController _plotLevelGroupRedPointUI;

    //private const string STAR_REWARD_PREFAB_PATH = "Assets/Art/UI/Prefab/LevelSelect/Button_StarReward.prefab";
    // private List<GameObject> _starRewardPool = new();
    // private List<GameObject> _showStarReward = new();

    private float _progressmoveSpeed = 1f;
    private CancellationTokenSource _cts;

    /// <summary>
    /// 电量
    /// </summary>
    private Batterie batterie;
    /// <summary>
    /// 网络信号
    /// </summary>
    private NetSignal netSignal;
    /// <summary>
    /// 刷新计时
    /// </summary>
    private float timer;
    private List<Button> _modeButtons = new();

    public override void PreLoad(object data = null)
    {
        CommonUtils.PreLoadOrUnloadEnvironmentWeatherDayNightIcon(true);
    }

    public override void OnInit()
    {
        //bind UI GameObj
        UI_LevelSelectBinder.GetComponents(this);

        batterie = new Batterie(FindObj("UI_BattertSignal/BatteryRoot"));
        netSignal = new NetSignal(FindObj("UI_BattertSignal/SignalRoot"));

        BindProperty();
        BindEvent();
        RegisterSignal();
    }

    protected override void OnShowWindow(object data = null)
    {
        Refresh();
    }

    protected override void OnReloadWindow(object data = null)
    {
        Refresh();
    }

    protected override void OnUpdate()
    {
        timer += Time.deltaTime;
        if (timer >= 1f)
        {
            batterie.SetInfo(DeviceHelper.GetBatteryLevel());
            netSignal.SetInfo(DeviceHelper.GetNetworkSignal());

            timer -= 1f;
        }
    }

    public override void OnRelease()
    {
        base.OnRelease();
        CommonUtils.PreLoadOrUnloadEnvironmentWeatherDayNightIcon(false);
        UnRegisterSignal();
        _currPage = PageType.Mode;
        _cts?.Cancel();
        _cts?.Dispose();
    }

    private void BindProperty()
    {
        UI_ModeChoose = transform.Find("UI_ModeChoose") as RectTransform;
        UI_LevelGroupChoose = transform.Find("UI_LevelGroupChoose") as RectTransform;
        UI_LevelChoose = transform.Find("UI_LevelChoose") as RectTransform;
        _modeParent = UI_ModeChoose.Find("Scroll View/Viewport/Content") as RectTransform;
        _levelGroupScrollView = UI_LevelGroupChoose.Find("Image_ChapterBG/RecyScrollView")
            .GetComponent<RecycleView>();
        _levelScrollView = UI_LevelChoose.Find("Image_LevelBG/Scroll View").GetComponent<RecycleView>();
        _starRewardsParent = Image_ProcessBar.transform as RectTransform;

        //_levelGroupScrollView.SetUpdateFunc(OnRenderChapter);
        //_levelGroupScrollView.SetItemCountFunc(GetLevelGroupCount);
        //_levelGroupScrollView.SetButton(SetOnLevelGroupClick);
        _levelGroupScrollView.Init(OnRenderChapter);
        _levelScrollView.Init(OnRenderLevelInfo);
        //_levelScrollView.SetButton(SetOnLevelClick);

        _easyLevelGroupRedPointUI = Button_Easy.transform.Find("UI_RedPoint").GetComponent<RedPointUIController>();
        _hardLevelGroupRedPointUI = Button_Hard.transform.Find("UI_RedPoint").GetComponent<RedPointUIController>();
        _plotLevelGroupRedPointUI = Button_Plot.transform.Find("UI_RedPoint").GetComponent<RedPointUIController>();

        _animation = GetComponent<Animation>();

        _modeButtons.Clear();
        var modeButtonParent = "UI_ModeChoose/Scroll View/Viewport/Content";
        var modeContent = transform.Find(modeButtonParent);
        if (modeContent != null)
        {
            foreach (Transform child in modeContent)
            {
                var button = child.GetComponent<Button>();
                if (button != null)
                    _modeButtons.Add(button);
            }
        }
    }

    private void BindEvent()
    {
        BindButton(Button_Back, OnClickBack);
        BindButton(Button_Home, OnClickHome);
        BindButton(Button_Easy, OnClickEasy);
        BindButton(Button_Hard, OnClickHard);
        BindButton(Button_Plot, OnClickPlot);
        BindButton(Button_GetAll, OnClickStarReward);
        var modeButtonCount = _modeParent.childCount;
        for (int i = 0; i < modeButtonCount; i++)
        {
            var modeButton = _modeParent.GetChild(i).GetComponent<Button>();
            modeButton.onClick.RemoveAllListeners();
            var index = i;
            modeButton.onClick.AddListener(() =>
            {
                var levelChapterType = (LevelChapterType)index;
                EnterSelectLevelGroup(levelChapterType);
            });
        }
    }

    private void RegisterSignal()
    {
        EventManager.Instance.Register(EventManager.EventName.ChapterInfoChange, Refresh);
        EventManager.Instance.Register(EventManager.EventName.LevelUnlock, Refresh);
        EventManager.Instance.Register(EventManager.EventName.LevelInfoChanged, Refresh);
    }

    private void UnRegisterSignal()
    {
        EventManager.Instance.Unregister(EventManager.EventName.ChapterInfoChange, Refresh);
        EventManager.Instance.Unregister(EventManager.EventName.LevelUnlock, Refresh);
        EventManager.Instance.Unregister(EventManager.EventName.LevelInfoChanged, Refresh);
    }

    private void Refresh()
    {
        RefreshPage();
        switch (_currPage)
        {
            case PageType.Mode:
                {
                    RefreshMode();
                    batterie.IsScaleShow = true;
                    netSignal.IsScaleShow = true;
                }
                break;
            case PageType.Chapter:
                {
                    RefreshChapter();
                    batterie.IsScaleShow = true;
                    netSignal.IsScaleShow = true;
                }
                break;
            case PageType.Level:
                {
                    RefreshLevel();
                    batterie.IsScaleShow = false;
                    netSignal.IsScaleShow = false;
                }
                break;
        }
    }

    //将当前UI看成是三个页面，选模式，选关卡组，选关
    private void RefreshPage()
    {
        UI_ModeChoose.gameObject.SetActive(_currPage == PageType.Mode);
        UI_LevelGroupChoose.gameObject.SetActive(_currPage == PageType.Chapter);
        UI_LevelChoose.gameObject.SetActive(_currPage == PageType.Level);
    }

    private void RefreshMode()
    {
        for (int i = 0; i < (int)LevelChapterType.Count; i++)
        {
            if (i >= _modeButtons.Count)
                return;
            OnRenderModeButton(_modeButtons[i], (LevelChapterType)i);
        }
    }

    private void OnRenderModeButton(Button btn, LevelChapterType type)
    {
        TMP_Text textModeName = btn.transform.Find("Image_TextBG/Text_MainLevel").GetComponent<TMP_Text>();
        textModeName.text = type switch
        {
            LevelChapterType.Main => CommonUtils.GetLocalizeText("LevelSelect_MainLevel"),
            LevelChapterType.Branch => CommonUtils.GetLocalizeText("LevelSelect_BranchLevel"),
            LevelChapterType.Dungeon => CommonUtils.GetLocalizeText("LevelSelect_DungeonLevel"),
            _ => "未处理",
        };

        var Image_BlackBar = btn.transform.Find("Image_TextBG/Image_BlackBar").gameObject;
        var Image_LastRect = btn.transform.Find("Image_TextBG/Image_LastRect").gameObject;

        var latestLevelInfo = LevelManager.Instance.GetLatestLevelInfo(type);
        Image_BlackBar.SetActive(latestLevelInfo != null);
        if (latestLevelInfo != null)
        {
            var Text_MainLevelNum = btn.transform.Find("Image_TextBG/Image_BlackBar/Text_MainLevelNum").GetComponent<TMP_Text>();
            var Text_MainLevelName = btn.transform.Find("Image_TextBG/Image_BlackBar/Text_MainLevelName").GetComponent<TMP_Text>();
            Text_MainLevelNum.text = GetLevelLabel(latestLevelInfo);
            Text_MainLevelName.text = latestLevelInfo.Name;
        }

        var lastFightLevel = LevelManager.Instance.GetLastFightLevelInfo(type);
        Image_LastRect.SetActive(lastFightLevel != null);
        if (lastFightLevel != null)
        {
            var Text_MainLevelNum = btn.transform.Find("Image_TextBG/Image_LastRect/Text_MainLevelNum").GetComponent<TMP_Text>();
            var Text_MainLevelName = btn.transform.Find("Image_TextBG/Image_LastRect/Text_MainLevelName").GetComponent<TMP_Text>();
            Text_MainLevelNum.text = GetLevelLabel(lastFightLevel);
            Text_MainLevelName.text = lastFightLevel.Name;
        }
    }

    private void RefreshChapter()
    {
        RefreshChapterToShow();
        //_levelGroupScrollView.UpdateData(true);#
        _levelGroupScrollView.ShowList(GetLevelGroupCount());
    }

    private void RefreshChapterToShow()
    {
        _showChapterInfoList.Clear();
        var allChapter = LevelManager.Instance.GetAllChapterInfo();
        foreach (var chapterInfo in allChapter)
        {
            if (chapterInfo.ChapterType == _currChapterType && !chapterInfo.IsLock)
            {
                _showChapterInfoList.Add(chapterInfo);
            }
        }

        _showChapterInfoList.Sort((a, b) => { return a.ID.CompareTo(b.ID); });
    }

    private void RefreshLevel()
    {
        RefreshLevelToShow();
        _levelScrollView.ShowList(_showLevelInfoList.Count);
    }

    private void RefreshLevelToShow()
    {
        _showLevelInfoList.Clear();
        foreach (LevelInfo levelInfo in _currLevelGroupInfo)
        {
            if (!levelInfo.IsLock)
                _showLevelInfoList.Add(levelInfo);
        }

        _showLevelInfoList.Sort((a, b) => a.ID.CompareTo(b.ID));
    }

    private void EnterSelectLevelGroup(LevelChapterType type)
    {
        _currChapterType = type;
        _currPage = PageType.Chapter;
        Refresh();
    }

    private void ExitSelectLevelGroup()
    {
        _currPage = PageType.Mode;
        Refresh();
    }

    private void EnterSelectLevel(ChapterInfo chapterInfo)
    {
        _currChapterInfo = chapterInfo;
        _currPage = PageType.Level;
        Text_ChapterName.text = _currChapterInfo.Name;
        Text_ChapterNum.text = $"{_currChapterInfo.Index:00}";
        var defaultLevelGroup = InitChapter();
        if (defaultLevelGroup != null)
            ChangeLevelGroup(defaultLevelGroup);
        Refresh();
    }

    private void ExitSelectLevel()
    {
        _currChapterInfo = null;
        _currEasyLevelGroupInfo = null;
        _currHardLevelGroupInfo = null;
        _currPlotLevelGroupInfo = null;
        _currLevelGroupInfo = null;
        _currSelectLevelInfo = null;
        _currPage = PageType.Chapter;
        Refresh();
    }

    private LevelGroupInfo InitChapter()
    {
        _currEasyLevelGroupInfo = _currChapterInfo.EasyLevelGroup;
        _currHardLevelGroupInfo = _currChapterInfo.HardLevelGroup;
        _currPlotLevelGroupInfo = _currChapterInfo.PlotLevelGroup;

        Button_Easy.interactable = IsChapterValid(_currEasyLevelGroupInfo);
        Button_Hard.interactable = IsChapterValid(_currHardLevelGroupInfo);
        Button_Plot.interactable = IsChapterValid(_currPlotLevelGroupInfo);

        _easyLevelGroupRedPointUI.ResetToDefault();
        _hardLevelGroupRedPointUI.ResetToDefault();
        _plotLevelGroupRedPointUI.ResetToDefault();

        if (_currEasyLevelGroupInfo != null)
            _easyLevelGroupRedPointUI.NodeID = _currEasyLevelGroupInfo.RedPointNode.ID;
        if (_currHardLevelGroupInfo != null)
            _hardLevelGroupRedPointUI.NodeID = _currHardLevelGroupInfo.RedPointNode.ID;
        if (_currPlotLevelGroupInfo != null)
            _plotLevelGroupRedPointUI.NodeID = _currPlotLevelGroupInfo.RedPointNode.ID;

        var result =
            IsChapterValid(_currEasyLevelGroupInfo) ? _currEasyLevelGroupInfo :
            IsChapterValid(_currHardLevelGroupInfo) ? _currHardLevelGroupInfo : _currPlotLevelGroupInfo;
        return result;
    }

    private bool IsChapterValid(LevelGroupInfo chapter)
    {
        return chapter != null && !chapter.IsLock;
    }

    private async void ChangeLevelGroup(LevelGroupInfo currLevelGroupInfo)
    {
        var oldLevelGroupInfo = _currLevelGroupInfo;
        if (_currLevelGroupInfo == currLevelGroupInfo)
            return;
        _currLevelGroupInfo = currLevelGroupInfo;
        SetLevelGroupButtonSelected(Button_Plot, currLevelGroupInfo == _currPlotLevelGroupInfo);
        SetLevelGroupButtonSelected(Button_Easy, currLevelGroupInfo == _currEasyLevelGroupInfo);
        SetLevelGroupButtonSelected(Button_Hard, currLevelGroupInfo == _currHardLevelGroupInfo);
        // Image_Plot.gameObject.SetActive(currLevelGroupInfo == _currPlotLevelGroupInfo);
        // Image_Easy.gameObject.SetActive(currLevelGroupInfo == _currEasyLevelGroupInfo);
        // Image_Hard.gameObject.SetActive(currLevelGroupInfo == _currHardLevelGroupInfo);
        //ReturnAllStarReward();
        if (currLevelGroupInfo.LevelType != LevelType.Plot &&
            (currLevelGroupInfo.StarList == null || currLevelGroupInfo.StarList.Length == 0))
        {
            DebugUtil.LogError($"levelGroup的星级奖励列表未配置!levelGroup ID:{currLevelGroupInfo.ID}");
            return;
        }

        //播放切换levelGroup动画
        if (oldLevelGroupInfo != null)
        {
            if (oldLevelGroupInfo.LevelType == LevelType.Plot && currLevelGroupInfo.LevelType != LevelType.Plot)
                _animation.Play(IN_ANIMATION_NAME);
            if (oldLevelGroupInfo.LevelType != LevelType.Plot && currLevelGroupInfo.LevelType == LevelType.Plot)
                _animation.Play(OUT_ANIMATION_NAME);
        }
        else
        {
            if (currLevelGroupInfo.LevelType != LevelType.Plot)
            {
                _animation.Play(IN_ANIMATION_NAME);
                var clip = _animation[IN_ANIMATION_NAME];
                clip.speed = 0;
                clip.time = clip.length;
                _animation.Sample();
                _animation.Stop(IN_ANIMATION_NAME);
                clip.speed = 1;
            }
        }


        if (currLevelGroupInfo.LevelType != LevelType.Plot)
        {
            //Image_ProcessBG.gameObject.SetActive(true);
            int maxTarget = currLevelGroupInfo.StarList[^1];
            var progressLength = _starRewardsParent.rect.width;
            var currStarCount = currLevelGroupInfo.StarCount;
            var currRewardIndexMax = currLevelGroupInfo.OwnRewardMaxIndex;
            // for (int i = 0; i < currLevelGroupInfo.StarList.Length; i++)
            // {
            //     var target = currLevelGroupInfo.StarList[i];
            //var starReward = await GetAStarReward();
            //var button = starReward.GetComponent<Button>();
            //button.onClick.RemoveAllListeners();
            // var index = i + 1;
            // if (_currLevelGroupInfo.CanGetReward(index))
            // {
            //     button.enabled = true;
            //     button.onClick.AddListener(() => { OnClickStarReward(index); });
            // }
            // else
            //     button.enabled = false;
            //
            // _showStarReward.Add(starReward);
            // var targetText = starReward.transform.Find("target_green").GetComponent<TMP_Text>();
            // var targetWhiteText = starReward.transform.Find("target_white").GetComponent<TMP_Text>();
            // targetText.text = target.ToString();
            // targetWhiteText.text = target.ToString();
            //     var x = ((float)target / maxTarget) * progressLength;
            //     var rectTrans = starReward.transform as RectTransform;
            //     rectTrans.anchoredPosition = new Vector2(x, rectTrans.anchoredPosition.y);
            //     SetStarRewardEnable(starReward, false);
            // }

            var ratio = (float)currStarCount / maxTarget;
            Text_StarNum.text = $"{currStarCount}/{maxTarget}";
            _cts?.Cancel();
            _cts?.Dispose();
            _cts = new CancellationTokenSource();
            PlayProgressAnimation(ratio, progressLength, _cts.Token);
        }

        Refresh();
    }

    private void SetLevelGroupButtonSelected(Button button, bool isSelected)
    {
        var selectedImage = button.transform.Find("selectedImage");
        selectedImage.gameObject.SetActive(isSelected);

        var selectedImage_1 = button.transform.Find("selectedImage_1");
        selectedImage_1.gameObject.SetActive(isSelected);

        var Image_pot = button.transform.Find("Image_pot");
        Image_pot.gameObject.SetActive(!isSelected);
    }

    private void SetStarRewardEnable(GameObject starReward, bool isEnable)
    {
        var starRewardGreen = starReward.transform.Find("starReward_green").gameObject;
        var starReward_white = starReward.transform.Find("starReward_white").gameObject;
        var star_green = starReward.transform.Find("star_green").gameObject;
        var star_white = starReward.transform.Find("star_white").gameObject;
        var target_green = starReward.transform.Find("target_green").gameObject;
        var target_white = starReward.transform.Find("target_white").gameObject;

        starRewardGreen.SetActive(isEnable);
        starReward_white.SetActive(!isEnable);
        star_green.SetActive(isEnable);
        star_white.SetActive(!isEnable);
        target_green.SetActive(isEnable);
        target_white.SetActive(!isEnable);
    }

    private async void PlayProgressAnimation(float ratio, float progressLength, CancellationToken token)
    {
        Image_ProcessBar.fillAmount = 0;
        //var currMoveTime = 0f;
        //var rewardTList = new List<float>();
        var maxStarCount = _currLevelGroupInfo.StarList[^1];
        // foreach (var starCount in _currLevelGroupInfo.StarList)
        // {
        //     var t = (float)starCount / maxStarCount;
        //     rewardTList.Add(t);
        // }
        var targetFillAmount = _currLevelGroupInfo.StarCount / maxStarCount;

        var currStarIndex = 0;
        while (Image_ProcessBar.fillAmount < targetFillAmount)
        {
            var fillAmount = Image_ProcessBar.fillAmount + Time.deltaTime * _progressmoveSpeed;
            fillAmount = Mathf.Min(fillAmount, targetFillAmount);
            Image_ProcessBar.fillAmount = fillAmount;
            // currMoveTime += Time.deltaTime;
            // var t = currMoveTime / _progressmoveSpeed;
            // var x = Mathf.Min(progressLength * ratio, progressLength * t);
            // Image_ProcessBar.rectTransform.anchoredPosition =
            //     new Vector2(x, Image_ProcessBar.rectTransform.anchoredPosition.y);
            // if (t >= rewardTList[0])
            // {
            //     rewardTList.RemoveAt(0);
            //     SetStarRewardEnable(_showStarReward[currStarIndex], true);
            //     currStarIndex++;
            // }


            var isCanceled = await UniTask.DelayFrame(1, PlayerLoopTiming.Update, token).SuppressCancellationThrow();
            if (isCanceled)
                return;
        }
    }

    // private async UniTask<GameObject> GetAStarReward()
    // {
    //     GameObject result = null;
    //     if (_starRewardPool.Count > 0)
    //     {
    //         result = _starRewardPool[^1];
    //         _starRewardPool.RemoveAt(_starRewardPool.Count - 1);
    //     }
    //     else
    //     {
    //         var prefab = await AssetManager.Instance.LoadAssetAsync<GameObject>(STAR_REWARD_PREFAB_PATH);
    //         if (prefab == null)
    //         {
    //             return null;
    //         }
    //
    //         GameObject go = Instantiate(prefab, _starRewardsParent.transform);
    //         result = go;
    //     }
    //
    //     result.SetActive(true);
    //     return result;
    // }

    // private void ReturnAllStarReward()
    // {
    //     foreach (var go in _showStarReward)
    //     {
    //         go.SetActive(false);
    //         _starRewardPool.Add(go);
    //     }
    //
    //     _showStarReward.Clear();
    // }

    private async void ShowLevelDetail()
    {
        if (_currSelectLevelInfo == null)
            return;
        if (_currSelectLevelInfo.IsStory)
            LevelManager.Instance.TryEnterLevel(_currSelectLevelInfo.ID);
        else
        {
            //UIManager.Instance.OpenWindow(UINameConst.UI_BeforeFight, _currSelectLevelInfo.ID);
            await UI_LevelDetailController.Open(_currSelectLevelInfo);
            //LevelManager.Instance.TryEnterLevel(_currSelectLevelInfo.ID, CloseSelf);
        }
    }

    private int GetLevelGroupCount()
    {
        return _showChapterInfoList.Count;
    }

    private void OnRenderChapter(GameObject go, int index)
    {
        var item = go.transform;
        if (index >= _showChapterInfoList.Count || index < 0)
        {
            DebugUtil.LogError($"index out of range,index:{index}");
            return;
        }

        var levelGroupInfo = _showChapterInfoList[index];
        var Text_ChapterNum = item.Find("Text_ChapterNum").GetComponent<TMP_Text>();
        var Text_ChapterName = item.Find("Text_ChapterName").GetComponent<TMP_Text>();
        var Image_ProcessBarEasy = item.Find("UI_Easy/Image_ProcessBarEasy").GetComponent<Image>();
        var Text_EasyStarNow = item.Find("UI_Easy/Text_EasyStarNow").GetComponent<TMP_Text>();
        var Text_EasyStarMax = item.Find("UI_Easy/Text_EasyStarMax").GetComponent<TMP_Text>();
        var Image_ProcessBarHard = item.Find("UI_Hard/Image_ProcessBarHard").GetComponent<Image>();
        var Text_HardStarNow = item.Find("UI_Hard/Text_HardStarNow").GetComponent<TMP_Text>();
        var Text_HardStarMax = item.Find("UI_Hard/Text_HardStarMax").GetComponent<TMP_Text>();

        Text_ChapterNum.text = string.Format("{0:D2}", index + 1);
        Text_ChapterName.text = levelGroupInfo.Name;

        var starCountEasy = levelGroupInfo.EasyLevelGroup?.StarCount ?? 0;
        var starMaxEasy = levelGroupInfo.EasyLevelGroup?.StarMax ?? 0;
        Image_ProcessBarEasy.fillAmount = (float)starCountEasy / starMaxEasy;
        Text_EasyStarNow.text = starCountEasy.ToString();
        Text_EasyStarMax.text = starMaxEasy.ToString();

        var starCountHard = levelGroupInfo.HardLevelGroup?.StarCount ?? 0;
        var starMaxHard = levelGroupInfo.HardLevelGroup?.StarMax ?? 0;
        Image_ProcessBarHard.fillAmount = (float)starCountHard / starMaxHard;
        Text_HardStarNow.text = starCountHard.ToString();
        Text_HardStarMax.text = starMaxHard.ToString();

        var UI_RedPoint = item.Find("UI_RedPoint").GetComponent<RedPointUIController>();
        if (UI_RedPoint != null)
        {
            UI_RedPoint.NodeID = levelGroupInfo.RedPointNode.ID;
        }

        var btn = item.GetComponent<Button>();
        btn.onClick.RemoveAllListeners();
        btn.onClick.AddListener(() => { EnterSelectLevel(levelGroupInfo); });
        //BindButton(item.gameObject,)
    }

    // private void SetOnLevelGroupClick(GameObject obj)
    // {
    //     BindButton(obj, () =>
    //     {
    //         var index = CommonUtils.GetTransformIndex(obj.transform);
    //         if (index >= _showLevelGroupInfoList.Count || index < 0)
    //         {
    //             DebugUtil.LogError($"index out of range,index:{index}");
    //             return;
    //         }
    //
    //         var selectedLevelGroup = _showLevelGroupInfoList[index];
    //         EnterSelectLevel(selectedLevelGroup);
    //         Refresh();
    //     });
    // }

    private void OnRenderLevelInfo(GameObject cell, int index)
    {
        Transform item = cell.transform;
        if (index < 0 || index >= _showLevelInfoList.Count)
        {
            DebugUtil.LogError("index out of range,index:{0}", index);
            return;
        }

        var levelInfo = _showLevelInfoList[index];
        var Text_LevelNum = item.Find("Text_LevelNum").GetComponent<TMP_Text>();
        var Text_LevelName = item.Find("Text_LevelName").GetComponent<TMP_Text>();
        var Image_Star01 = item.Find("Target/Text_01/Image_Yellow").gameObject;
        var Image_Star02 = item.Find("Target/Text_02/Image_Yellow").gameObject;
        var Image_Star03 = item.Find("Target/Text_03/Image_Yellow").gameObject;
        var Image_environment = item.Find("MapDetail/Image_environment").GetComponent<Image>();
        var Image_weather = item.Find("MapDetail/Image_weather").GetComponent<Image>();
        var Image_daynight = item.Find("MapDetail/Image_DayOrNight").GetComponent<Image>();
        var mapDetail = item.Find("MapDetail").gameObject;
        var Target = item.Find("Target").gameObject;
        
        Text_LevelNum.text = GetLevelLabel(levelInfo);
        Text_LevelName.text = levelInfo.Name;

        mapDetail.SetActive(!levelInfo.IsStory);
        Target.SetActive(!levelInfo.IsStory);
        if (!levelInfo.IsStory)
        {
            var StarResult = levelInfo.StarResult;
            Image_Star01.SetActive(StarResult[0]);
            Image_Star02.SetActive(StarResult[1]);
            Image_Star03.SetActive(StarResult[2]);
            Image_environment.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(CommonUtils.GetEnvironmentConfig(levelInfo.EnvironmentType).Icon);
            Image_weather.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(CommonUtils.GetWeatherConfig(levelInfo.WeatherType).Icon);
            Image_daynight.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(CommonUtils.GetDayNightConfig(levelInfo.DayNightType).Icon);
        }
        
        var UI_RedPoint = item.Find("UI_RedPoint").GetComponent<RedPointUIController>();
        if (UI_RedPoint != null)
            UI_RedPoint.NodeID = levelInfo.RedPointNode.ID;

        var btn = item.GetComponent<Button>();
        btn.onClick.RemoveAllListeners();
        btn.onClick.AddListener(() =>
        {
            _currSelectLevelInfo = levelInfo;
            ShowLevelDetail();
        });
    }

    private string GetLevelLabel(LevelInfo levelInfo) =>
        $"{levelInfo.ChapterIndex:00}-{levelInfo.LevelIndex:00}";

    // private void SetOnLevelClick(GameObject go)
    // {
    //     BindButton(go, () =>
    //     {
    //         var index = CommonUtils.GetTransformIndex(go.transform);
    //         if (index >= _showLevelInfoList.Count || index < 0)
    //         {
    //             DebugUtil.LogError("index out of range!,{0}", index);
    //         }
    //
    //         var levelInfo = _showLevelInfoList[index];
    //         if (levelInfo != null)
    //         {
    //             _currSelectLevelInfo = levelInfo;
    //             ShowLevelDetail();
    //         }
    //     });
    // }

    #region Event

    private async void OnClickBack()
    {
        switch (_currPage)
        {
            case PageType.Mode:
                await CommonUtils.CloseUIWithScene(WindowName);
                //CloseWindow();
                break;
            case PageType.Chapter:
                ExitSelectLevelGroup();
                break;
            case PageType.Level:
                ExitSelectLevel();
                break;
        }
    }

    private async void OnClickHome()
    {
        await CommonUtils.CloseUIWithScene(WindowName);
        //CloseWindow(UIWindowCloseType.HideAndDestroy);
        //UIManager.Instance.CloseAllNormalExcept(UINameConst.UI_MainPanel);
    }

    public override async UniTask<bool> OnBack(object data = null)
    {
        await CommonUtils.CloseUIWithScene(WindowName);
        return true;
    }

    private void OnClickEasy()
    {
        if (_currEasyLevelGroupInfo != null)
            ChangeLevelGroup(_currEasyLevelGroupInfo);
    }

    private void OnClickHard()
    {
        if (_currHardLevelGroupInfo != null)
            ChangeLevelGroup(_currHardLevelGroupInfo);
    }

    private void OnClickPlot()
    {
        if (_currPlotLevelGroupInfo != null)
            ChangeLevelGroup(_currPlotLevelGroupInfo);
    }

    private void OnClickStarReward()
    {
        var index = _currLevelGroupInfo.OwnRewardMaxIndex + 1;
        if (_currLevelGroupInfo.CanGetReward(index))
            LevelManager.Instance.GetStarReward(_currLevelGroupInfo.ID, index);
    }

    #endregion Event
}