NLDClient-yudde/ProjectNLD/Assets/Code/Scripts/Gameplay/UI/UI_LevelSelectController.cs

using System.Collections.Generic;
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 UnityEngine.SceneManagement;
using UnityEngine.Serialization;
using Utils;
using Button = UnityEngine.UI.Button;
using Constants = PhxhSDK.Constants;
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;
	[FormerlySerializedAs("Text_StartNum")] 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 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 PhxhScrollView _levelGroupScrollView;
    private PhxhScrollView _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 _totalMoveTime = 1f;
    private CancellationTokenSource _cts;

    public override void OnAwake()
    {
        //bind UI GameObj
        UI_LevelSelectBinder.GetComponents(this);
        BindProperty();
        BindEvent();
        RegisterSignal();
    }

    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/Scroll View")
            .GetComponent<PhxhScrollView>();
        _levelScrollView = UI_LevelChoose.Find("Image_LevelBG/Scroll View").GetComponent<PhxhScrollView>();
        _starRewardsParent = Image_ProcessBar.transform as RectTransform;

        _levelGroupScrollView.SetUpdateFunc(OnRenderLevelGroup);
        _levelGroupScrollView.SetItemCountFunc(GetLevelGroupCount);
        //_levelGroupScrollView.SetButton(SetOnLevelGroupClick);

        _levelScrollView.SetUpdateFunc(OnRenderLevelInfo);
        _levelScrollView.SetItemCountFunc(GetLevelCount);
        //_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>();
    }

    private void BindEvent()
    {
        BindButton(Button_Back, OnClickBack);
        BindButton(Button_Home, OnClickHome);
        BindButton(Button_Easy, OnClickEasy);
        BindButton(Button_Hard, OnClickHard);
        BindButton(Button_Plot, OnClickPlot);
        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();
                break;
            case PageType.Chapter:
                RefreshChapter();
                break;
            case PageType.Level:
                RefreshLevel();
                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()
    {
    }

    private void RefreshChapter()
    {
        RefreshChapterToShow();
        _levelGroupScrollView.UpdateData(true);
    }

    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.UpdateData(true);
    }

    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;
        //RefreshPage();
        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;
        // 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("LS_MoveOut");
            }

            if (oldLevelGroupInfo.LevelType != LevelType.Plot && currLevelGroupInfo.LevelType == LevelType.Plot)
            {
                _animation.Play("LS_MoveIn");
            }
        }
        
        if (currLevelGroupInfo.LevelType == LevelType.Plot)
        {
            //Image_ProcessBG.gameObject.SetActive(false);
        }
        else
        {
            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.ToString();
            _cts?.Cancel();
            _cts?.Dispose();
            _cts = new CancellationTokenSource();
            PlayProgressAnimation(ratio, progressLength, _cts.Token);
        }

        Refresh();
    }

    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.rectTransform.anchoredPosition =
            new Vector2(0, Image_ProcessBar.rectTransform.anchoredPosition.y);
        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 currStarIndex = 0;
        while (currMoveTime < ratio * _totalMoveTime)
        {
            currMoveTime += Time.deltaTime;
            var t = currMoveTime / _totalMoveTime;
            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 void ShowLevelDetail()
    {
        if (_currSelectLevelInfo == null)
            return;
        if (_currSelectLevelInfo.IsStory)
            LevelManager.Instance.TryEnterLevel(_currSelectLevelInfo.ID);
        else
            UIManager.Instance.OpenWindow(UINameConst.UI_BeforeFight, _currSelectLevelInfo.ID);
        //LevelManager.Instance.TryEnterLevel(_currSelectLevelInfo.ID, CloseSelf);
    }

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

    private void OnRenderLevelGroup(int index, RectTransform item)
    {
        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 int GetLevelCount()
    {
        return _showLevelInfoList.Count;
    }

    private async void OnRenderLevelInfo(int index, RectTransform item)
    {
        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>();

        Text_LevelNum.text = $"{_currChapterInfo.SortIndex + 1:D2}-{levelInfo.SortIndex + 1:D2}";
        Text_LevelName.text = levelInfo.Name;
        var starCount = levelInfo.StarCount;
        Image_Star01.SetActive(starCount >= 1);
        Image_Star02.SetActive(starCount >= 2);
        Image_Star03.SetActive(starCount >= 3);
        Image_environment.sprite = await CommonUtils.GetEnvironmentIcon(levelInfo.EnvironmentType);
        Image_weather.sprite = await CommonUtils.GetWeatherIcon(levelInfo.WeatherType);
        Image_daynight.sprite = await CommonUtils.GetDayNightIcon(levelInfo.DayNightType);

        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 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 void OnClickBack()
    {
        switch (_currPage)
        {
            case PageType.Mode:
                CloseWindow();
                break;
            case PageType.Chapter:
                ExitSelectLevelGroup();
                break;
            case PageType.Level:
                ExitSelectLevel();
                break;
        }
    }

    private void OnClickHome()
    {
        CloseWindow(UIWindowCloseType.HideAndDestroy);
        //UIManager.Instance.CloseAllNormalExcept(UINameConst.UI_MainPanel);
    }

    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(int index)
    {
        LevelManager.Instance.GetStarReward(_currLevelGroupInfo.ID, index);
    }

    #endregion Event

    #region override method

    protected override void OnOpenWindow()
    {
        Refresh();
    }

    //invoke when open window
    protected override void OnOpenWindow(object data = null)
    {
        Refresh();
    }

    //invoke when reload window
    protected override void OnReloadWindow(object data = null)
    {
        Refresh();
    }

    //invoke when close window
    protected override void OnCloseWindow()
    {
        CommonUtils.CloseUIWithScene(WindowName);
        UnRegisterSignal();
        _currPage = PageType.Mode;
        _cts?.Cancel();
        _cts?.Dispose();
    }

    #endregion
}