using cfg.CharacterCfg;
using Cysharp.Threading.Tasks;
using Framework;
using Gameplay;
using Gameplay.Guide;
using NLDPB;
using PhxhSDK;
using System;
using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using Image = UnityEngine.UI.Image;

public class UISelectCharacterController : UIWindow
{
    public static async UniTask<UIWindow> OpenLoadedUI(Team team, int index)
    {
        InputData inputData = new()
        {
            OpenType = E_OpenType.EditTeam,
            Data = team,
            Idx = index,
            job = -1
        };
        
        UIManager.WindowInfo wInfo;
        wInfo = UIManager.Instance.WindowInfos[UINameConst.UISelectCharacter];
        var window = UIManager.Instance.GetOpenedWindowByPath(UINameConst.UISelectCharacter);
        // if (mMemoryWindows.ContainsKey(UINameConst.UISelectCharacter))
        // {
        //     mMemoryWindows[UINameConst.UISelectCharacter].CreateWindow(data, wInfo.NotSetMainCamera);
        // }
        if (window != null)
        {
            window.CreateWindow(inputData, wInfo.NotSetMainCamera);
        }

        return window;
    }
    
    public static async UniTask<UIWindow> OpenLoadedUI(Team team, int index, Ejob ejob)
    {
        InputData inputData = new()
        {
            OpenType = E_OpenType.EditTeam,
            Data = team,
            Idx = index,
            job = (int)ejob
        };
        
        UIManager.WindowInfo wInfo;
        wInfo = UIManager.Instance.WindowInfos[UINameConst.UISelectCharacter];
        var window = UIManager.Instance.GetOpenedWindowByPath(UINameConst.UISelectCharacter);
        // if (mMemoryWindows.ContainsKey(UINameConst.UISelectCharacter))
        // {
        //     mMemoryWindows[UINameConst.UISelectCharacter].CreateWindow(data, wInfo.NotSetMainCamera);
        // }
        if (window != null)
        {
            window.CreateWindow(inputData, wInfo.NotSetMainCamera);
        }

        return window;
    }
    /// <summary>
    /// 打开角色界面(队伍编辑)
    /// </summary>
    /// <param name="team"></param>
    /// <param name="index"></param>
    /// <returns></returns>
    public static async UniTask<UIWindow> Open(Team team, int index)
    {
        InputData inputData = new()
        {
            OpenType = E_OpenType.EditTeam,
            Data = team,
            Idx = index,
            job = -1
        };

        return await UIManager.Instance.CreateAndOpenWindow(UINameConst.UISelectCharacter, inputData);
    }

    public static async UniTask<UIWindow> Open(Team team, int index, Ejob ejob)
    {
        InputData inputData = new()
        {
            OpenType = E_OpenType.EditTeam,
            Data = team,
            Idx = index,
            job = (int)ejob
        };

        return await UIManager.Instance.CreateAndOpenWindow(UINameConst.UISelectCharacter, inputData);
    }

    /// <summary>
    /// 打开角色界面
    /// </summary>
    /// <param name="team"></param>
    /// <param name="index"></param>
    /// <returns></returns>
    public static async UniTask<UIWindow> Open()
    {
        InputData inputData = new()
        {
            OpenType = E_OpenType.Default
        };

        return await UIManager.Instance.CreateAndOpenWindow(UINameConst.UISelectCharacter, inputData);
    }

    #region 结构

    private struct InputData
    {
        public E_OpenType OpenType;
        public Team Data;
        public int Idx;
        public int job;
    }

    /// <summary>
    /// 打开类型
    /// </summary>
    private enum E_OpenType
    {
        /// <summary>
        /// 默认
        /// </summary>
        Default,

        /// <summary>
        /// 队伍编辑
        /// </summary>
        EditTeam
    }

    /// <summary>
    /// 角色排序类型
    /// </summary>
    private enum E_CharacterSortType
    {
        /// <summary>
        /// 按星级(稀有度)排序
        /// </summary>
        EStar,

        /// <summary>
        /// 按等级排序
        /// </summary>
        ELevel,

        /// <summary>
        /// 按进修等级排序
        /// </summary>
        EAwake,

        /// <summary>
        /// 按考核等级排序
        /// </summary>
        EBreak,

        /// <summary>
        /// 按好感度排序
        /// </summary>
        ELikely,

        /// <summary>
        /// 按领导力消耗排序
        /// </summary>
        Cost,
    }

    /// <summary>
    /// 排序状态
    /// </summary>
    private enum E_SortState
    {
        /// <summary>
        /// 不排序
        /// </summary>
        None = 0,

        /// <summary>
        /// 升序
        /// </summary>
        Up,

        /// <summary>
        /// 降序
        /// </summary>
        Down,
    }

    public class CultivateStruct
    {
        public List<CharacterDataInfo> showList;
        public CharacterDataInfo info;
    }

    /// <summary>
    /// 角色
    /// </summary>
    private class CharacterItem : UIGameObjectWrapper
    {
        #region UI

        private Image imageBg;

        /// <summary>
        /// 等级进度条
        /// </summary>
        private Image imageLevel;

        /// <summary>
        /// 职业图标
        /// </summary>
        private Image imageProfessionLogo;

        /// <summary>
        /// 角色立绘
        /// </summary>
        private Image imagePoster;

        /// <summary>
        /// 等级
        /// </summary>
        private TMP_Text textLevel;

        /// <summary>
        /// 角色名
        /// </summary>
        private TMP_Text textCharacterName;

        /// <summary>
        /// 角色稀有度颜色遮罩
        /// </summary>
        private Image RarityCover;

        private TMP_Text textDebugId;

        /// <summary>
        /// 遮罩
        /// </summary>
        private GameObject goMask;

        /// <summary>
        /// 卸下
        /// </summary>
        private GameObject goClear;

        private Button button;
        private RedPointUIController RedPointUI;

        #endregion

        private CharacterDataInfo info;

        /// <summary>
        /// 星星列表
        /// </summary>
        private readonly List<GameObject> listStar;

        private readonly Action<CharacterDataInfo> callback;

        public bool IsShowMask
        {
            set { goMask.IsScaleShow(value); }
        }

        public bool IsShowClear
        {
            set { goClear.IsScaleShow(value); }
        }

        public bool IsShowPoster
        {
            set { imagePoster.gameObject.IsScaleShow(value); }
        }

        public CharacterItem(GameObject root, Action<CharacterDataInfo> callbackAction) : base(root)
        {
            callback = callbackAction;

            imageBg = GetComponent<Image>("Bg"); //GoRoot.
            imageLevel = GetComponent<Image>("Bg/Image_Poster/Image_Rect/Image_LevelBar");
            imageProfessionLogo = GetComponent<Image>("Bg/Image_Poster/Image_Rect/Image_ProfessionLogo");
            imagePoster = GetComponent<Image>("Bg/Image_Poster");
            textLevel = GetComponent<TMP_Text>("Bg/Image_Poster/Image_Rect/Image_LevelBar/Text_Level");
            textCharacterName =
                GetComponent<TMP_Text>("Bg/Image_Poster/Image_ColorCover/Image_CharacterName/Text_CharacterName");
            RarityCover = GetComponent<Image>("Bg/Image_Poster/Image_ColorCover");
            textDebugId = GetComponent<TMP_Text>("Bg/DebugID");
            goMask = FindObj("Bg/Image_Mask");
            goClear = FindObj("Bg/Image_Clear");
            button = GoRoot.GetComponent<Button>();
            RedPointUI = GetComponent<RedPointUIController>("Bg/UI_RedPoint");

            Transform tsStarRoot = FindObj("Bg/Image_Poster/Image_ColorCover/Image_CharacterName/Stars").transform;
            listStar = new(tsStarRoot.childCount);
            for (int i = 0; i < tsStarRoot.childCount; ++i)
            {
                listStar.Add(tsStarRoot.GetChild(i).gameObject);
            }

            CommonUtils.BindButton(button, OnClick);
        }

        public void SetInfo(CharacterDataInfo characterDataInfo, E_OpenType openType, Team team)
        {
            info = characterDataInfo;
            //RedPointUI.gameObject.SetActive(true);
            RedPointUI.NodeID = info.RedPointNode.ID;
            DataCharacterBreak breakCfg =
                TableManager.Instance.Tables.CharacterBreak.Get(info.Cfg.RoleID, (int)info.BreakLevel);
            int levelLimit = breakCfg?.LevelLimit ?? 1000;

            if (info.Level >= levelLimit)
            {
                imageLevel.fillAmount = 1f;
                //imageLevel.fillAmount = (float)info.Level / levelLimit;
            }
            else
            {
                var LevelExpCfg = TableManager.Instance.Tables.CharacterLevelExp;
                imageLevel.fillAmount = info.Exp * 1.0f / (LevelExpCfg.Get((int)info.Level + 1).EXP == 0
                    ? 1
                    : LevelExpCfg.Get((int)info.Level + 1).EXP);
            }

            textLevel.text = info.Level.ToString();
            imageProfessionLogo.sprite =
                AssetManager.Instance.GetPreLoadResult<Sprite>(TableManager.Instance.Tables.JobAttri
                    .GetOrDefault((int)info.Cfg.Job).IconPath);

            textCharacterName.text = CommonUtils.GetLocalizeText(info.Cfg.Name);

            IsShowMask = openType == E_OpenType.EditTeam && TeamEditManager.Instance.IsUnitInAllTeam(info.Uid);

            var imgPath =
                CommonUtils.GetCharacterPicPath(info.Cfg.RoleID, CommonUtils.ECharacterPicPathType.SelectCharacter, (int)info.SkinID);
            var sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(imgPath); //获取预加载好的角色立绘
            CommonUtils.RefreshCharacter2DPic(imagePoster, sprite);


            for (int i = 0; i < listStar.Count; i++)
            {
                GameObject goStar = listStar[i];
                goStar.IsScaleShow((i + 1) < info.Cfg.StartStar);
            }

            var coverPath = "Assets/Art/UI/Texture/UI_Pic_Main/UI_Pic_ShowAllCharacter/SAC_AllPart/";
            if (info.Cfg.StartStar == 3)
            {
                RarityCover.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(coverPath + "UI_RarityWhite.png"); //白色：三星
            }
            else if (info.Cfg.StartStar == 4)
            {
                RarityCover.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(coverPath + "UI_RarityBlue.png"); //蓝色：四星
            }
            else
            {
                RarityCover.sprite = AssetManager.Instance.GetPreLoadResult<Sprite>(coverPath + "UI_RarityRed.png"); //红色：五星
            }

            textDebugId.gameObject.IsScaleShow(DisplayIDForCeHua.IsDisplayID);
            textDebugId.text = $"ID:{info.Cfg.RoleID}";

            IsShowPoster = true;
            IsShowClear = false;
            imageBg.color = new Color(imageBg.color.r, imageBg.color.g, imageBg.color.b, 1f);

            IsScaleShow = true;
        }

        /// <summary>
        /// 队伍编辑特殊下阵入口
        /// 
        /// </summary>
        public void SetInfoByTeamEditorEmpty()
        {
            info = null;
            //RedPointUI.gameObject.SetActive(false);
            IsShowPoster = false;
            IsShowMask = false;
            IsShowClear = true;
            imageBg.color = new Color(imageBg.color.r, imageBg.color.g, imageBg.color.b, 0f);

            IsScaleShow = true;
        }

        private void OnClick()
        {
            callback?.Invoke(info);
        }
    }

    /// <summary>
    /// 排序按钮
    /// </summary>
    private class SortItem : UIGameObjectWrapper
    {
        private readonly Color SELECT_COLOR = Color.white;
        private readonly Color NORMAL_COLOR = new(1f, 1f, 1f, 0.3f);

        private Button button;

        /// <summary>
        /// 升序状态
        /// </summary>
        private GameObject goUp;

        /// <summary>
        /// 降序状态
        /// </summary>
        private GameObject goDown;

        /// <summary>
        /// 排序名
        /// </summary>
        private TMP_Text text;

        /// <summary>
        /// 排序回调
        /// </summary>
        private readonly Action<SortItem> sortAction;

        /// <summary>
        /// 排序类型
        /// </summary>
        private E_CharacterSortType sortType;

        /// <summary>
        /// 排序状态
        /// </summary>
        private E_SortState sortState;

        /// <summary>
        /// 排序状态
        /// </summary>
        public E_SortState SortState
        {
            get { return sortState; }
            set
            {
                sortState = value;
                switch (sortState)
                {
                    case E_SortState.Up:
                    {
                        goUp.IsScaleShow(true);
                        goDown.IsScaleShow(false);
                    }
                        break;
                    case E_SortState.Down:
                    {
                        goUp.IsScaleShow(false);
                        goDown.IsScaleShow(true);
                    }
                        break;
                    default:
                    {
                        goUp.IsScaleShow(false);
                        goDown.IsScaleShow(false);
                        IsSelect = false;
                    }
                        break;
                }
            }
        }

        public E_CharacterSortType SortType
        {
            set { sortType = value; }
            get { return sortType; }
        }

        public bool IsSelect
        {
            set { text.color = value ? SELECT_COLOR : NORMAL_COLOR; }
        }

        public SortItem(GameObject root, E_CharacterSortType sortType, Action<SortItem> sort) : base(root)
        {
            this.sortType = sortType;
            sortAction = sort;

            button = GoRoot.GetComponent<Button>();
            goUp = FindObj("Image_Default/Image_UP");
            goDown = FindObj("Image_Default/Image_Down");
            text = GetComponent<TMP_Text>("Text_Default");

            SortState = E_SortState.None;

            CommonUtils.BindButton(button, OnClick);

            IsScaleShow = true;
        }

        private void OnClick()
        {
            //if (SortState == E_SortState.None)
            //    SortState = E_SortState.Down;
            //else if (SortState == E_SortState.Down)
            //    SortState = E_SortState.Up;
            //else
            //    SortState = E_SortState.None;

            if (SortState == E_SortState.Down)
                SortState = E_SortState.Up;
            else
                SortState = E_SortState.Down;
            //改为两种状态切换

            sortAction?.Invoke(this);
        }
    }

    #endregion

    /// <summary>
    /// 没有角色状态
    /// </summary>
    private GameObject goEmpty;

    /// <summary>
    /// 循环列表
    /// </summary>
    private RecycleView recycleView;

    /// <summary>
    /// 下拉框全选值
    /// </summary>
    private const int DROPDOWN_ALL_VALUE = -1;

    /// <summary>
    /// 展示职业种类数量
    /// </summary>
    private int JOB_MAX;

    /// <summary>
    /// 职业下拉框全选图标路径
    /// </summary>
    private const string DROPDOWN_JOBALL_ICON_PATH = "Assets/Art/UI/Texture/Icon/Job/UI_Profession_All.png";

    private Dictionary<int, int> CharacterSkinDic = new Dictionary<int, int>();

    #region 私有变量

    /// <summary>
    /// 势力下拉框
    /// </summary>
    private UITextDropdown<int> factionDropDown;

    /// <summary>
    /// 下拉框展示的势力枚举值 (包括全选枚举值)
    /// </summary>
    private List<int> shownFactions = new List<int>();

    /// <summary>
    /// 其他下拉框
    /// </summary>
    private UITextDropdown<int> otherDropDown;

    /// <summary>
    /// 职业下拉框
    /// </summary>
    private UIImageDropDown<int> jobDropDown;

    /// <summary>
    /// 职业配置
    /// </summary>
    private JobAttri jobAttriCfg;

    /// <summary>
    /// 势力排序
    /// </summary>
    private FactionAttri factionAttriCfg;

    /// <summary>
    /// 打开界面类型
    /// </summary>
    private E_OpenType openType = E_OpenType.Default;

    /// <summary>
    /// 打开时传入队伍信息
    /// </summary>
    private Team curTeam;

    /// <summary>
    /// 打开时传入的队伍人员索引
    /// </summary>
    private int teamIndex;

    /// <summary>
    /// 打开的职业索引界面
    /// </summary>
    private int jobIndex;

    /// <summary>
    /// 角色字典
    /// </summary>
    private readonly Dictionary<int, CharacterItem> dicCharacter = new();

    /// <summary>
    /// 当前筛选的势力
    /// </summary>
    private int selectFractionIndex = DROPDOWN_ALL_VALUE;

    /// <summary>
    /// 当前筛选的职业
    /// </summary>
    private int selectJobIndex = DROPDOWN_ALL_VALUE;

    /// <summary>
    /// 所有角色列表
    /// </summary>
    private List<CharacterDataInfo> listAllCharacter = new();

    /// <summary>
    /// 要显示的角色列表
    /// </summary>
    private readonly List<CharacterDataInfo> listShowCharacter = new();

    /// <summary>
    /// 排序选项列表
    /// </summary>
    private readonly List<SortItem> listSortItem = new();

    /// <summary>
    /// 当前选择排序
    /// </summary>
    private SortItem curSortItem;

    #endregion

    public override async void PreLoad(object data = null)
    {
        if (data == null)
            return;

        InputData input = (InputData)data;
        openType = input.OpenType;
        if (openType == E_OpenType.EditTeam)
        {
            curTeam = input.Data;
            teamIndex = input.Idx;
            jobIndex = input.job + 1;
        }

        JOB_MAX = TableManager.Instance.Tables.GlobalConfig.CharacterJobCount;

        #region 获取配置

        jobAttriCfg = TableManager.Instance.Tables.JobAttri;
        factionAttriCfg = TableManager.Instance.Tables.FactionAttri;

        #endregion

        #region 获取角色数据

        listAllCharacter = CharacterDataInfoManager.Instance.DataList;
        for (int i = 0; i < listAllCharacter.Count; i++)
        {
            string path = CommonUtils.GetCharacterPicPath(listAllCharacter[i].Cfg.RoleID,
                CommonUtils.ECharacterPicPathType.SelectCharacter, (int)listAllCharacter[i].SkinID);
            CharacterSkinDic.Add(listAllCharacter[i].Cfg.RoleID, (int)listAllCharacter[i].SkinID);
            AssetManager.Instance.PostPreload<Sprite>(path).Forget();
        }

        #endregion

        #region 获取职业图标

        foreach (Ejob factionItem in Enum.GetValues(typeof(Ejob)))
        {
            if ((int)factionItem >= JOB_MAX)
            {
                continue;
            }
            DataJobAttri dataJobAttri = jobAttriCfg.Get((int)factionItem);
            if (null == dataJobAttri)
            {
                DebugUtil.Log($"配置获取失败，职业ID: {(int)factionItem}");
                continue;
            }

            AssetManager.Instance.PostPreload<Sprite>(dataJobAttri.IconPath).Forget();
        }

        AssetManager.Instance.PostPreload<Sprite>(DROPDOWN_JOBALL_ICON_PATH).Forget();

        #endregion

        #region 稀有度颜色遮罩
        var coverPath = "Assets/Art/UI/Texture/UI_Pic_Main/UI_Pic_ShowAllCharacter/SAC_AllPart/";
        AssetManager.Instance.PostPreload<Sprite>(coverPath + "UI_RarityWhite.png").Forget();
        AssetManager.Instance.PostPreload<Sprite>(coverPath + "UI_RarityBlue.png").Forget();
        AssetManager.Instance.PostPreload<Sprite>(coverPath + "UI_RarityRed.png").Forget();
        #endregion
    }

    public override void OnInit()
    {
        recycleView = GetComponent<RecycleView>("ScrollView_SelectCharacter");
        //recycleView.cell = FindObj("ScrollView_SelectCharacter/Viewport/Content/Cell");
        goEmpty = FindObj("Nothing");

        factionDropDown = new UITextDropdown<int>(FindObj("Image_BG/Button_Group"),
            FindObj("Image_BG/Button_Group/Text_Group"), FactionDropdownValueChanged, FactionDropdownData2Text);
        otherDropDown = new UITextDropdown<int>(FindObj("Image_BG/Image_Menu/Button_ChangeLevel"),
            FindObj("Image_BG/Image_Menu/Button_AdvanceLevel/Text_Default"), OtherDropdownValueChanged,
            OtherDropdownData2Text);
        jobDropDown = new UIImageDropDown<int>(FindObj("Image_BG/Button_Profession"),
            FindObj("Image_BG/Button_Profession/Text_Profession"), JobDropdownValueChanged, JobDropdownData2Text,
            JobDropdownData2Image);
        listSortItem.Add(new SortItem(FindObj("Image_BG/Image_Menu/Button_Rarity"), E_CharacterSortType.EStar, OnSort));
        listSortItem.Add(new SortItem(FindObj("Image_BG/Image_Menu/Button_Level"), E_CharacterSortType.ELevel, OnSort));
        listSortItem.Add(new SortItem(FindObj("Image_BG/Image_Menu/Button_AdvanceLevel"), E_CharacterSortType.EAwake,
            OnSort));

        recycleView.Init(OnRefreshItem);
        AddDropDownOption();
        if (openType == E_OpenType.EditTeam)
        {
            if (jobIndex != -1)
            {
                jobDropDown.SetValue(jobIndex);
                if (jobIndex != 0)
                    FindObj("Image_BG/Button_Profession").GetComponent<TMP_Dropdown>().interactable = false;
            }
            otherDropDown.SetValue((int)E_CharacterSortType.Cost);
            curSortItem = listSortItem[^1];
            curSortItem.SortState = E_SortState.Down;
        }
        else
        {
            //进入时默认选择一种排序        
            curSortItem = listSortItem[1];
            listSortItem[1].SortState = E_SortState.Down;
        }

        BindButton("Image_BG/Button_Back/Button_back", OnBack);
        BindButton("Image_BG/Button_Back/Button_Home", OnHome);

        //OnSort(listSortItem[1]);
        EventManager.Instance.Register(EventManager.EventName.ItemUse,RefreshSprite);
    }

    void RefreshSprite()
    {
        listAllCharacter = CharacterDataInfoManager.Instance.DataList;
        for (int i = 0; i < listAllCharacter.Count; i++)
        {
            var roleID = listAllCharacter[i].Cfg.RoleID;
            if (CharacterSkinDic.ContainsKey(roleID) && CharacterSkinDic[roleID] != listAllCharacter[i].SkinID)
            {
                string path = CommonUtils.GetCharacterPicPath(roleID, CommonUtils.ECharacterPicPathType.SelectCharacter, CharacterSkinDic[roleID]);
                AssetManager.Instance.Unload(path);


                var newPath = CommonUtils.GetCharacterPicPath(roleID, CommonUtils.ECharacterPicPathType.SelectCharacter, (int)listAllCharacter[i].SkinID);
                CharacterSkinDic[roleID] = (int)listAllCharacter[i].SkinID;
                AssetManager.Instance.PostPreload<Sprite>(newPath).Forget();
            }
        }

        RefreshUI();
    }
    protected override void OnShowWindow(object data = null)
    {
        base.OnShowWindow(data);

        RefreshUI();

        EventManager.Instance.Register(EventManager.EventName.EN_ShowAllCharacterSortType,
            OnReceiveShowAllCharacterSortEvent);
        EventManager.Instance.Register(EventManager.EventName.EN_CharacterLevelUp,
            (Action<UpgradeType>)OnCharacterLevelup);
    }

    protected override void OnHideWindow()
    {
        EventManager.Instance.Unregister(EventManager.EventName.EN_CharacterLevelUp,
            (Action<UpgradeType>)OnCharacterLevelup);
        EventManager.Instance.Unregister(EventManager.EventName.EN_ShowAllCharacterSortType,
            OnReceiveShowAllCharacterSortEvent);

        base.OnHideWindow();
    }

    public override void OnRelease()
    {
        #region 卸载职业图标

        foreach (Ejob factionItem in Enum.GetValues(typeof(Ejob)))
        {
            if ((int)factionItem >= JOB_MAX)
            {
                continue;
            }
            DataJobAttri dataJobAttri = jobAttriCfg.Get((int)factionItem);
            if (null == dataJobAttri)
            {
                DebugUtil.Log($"配置获取失败，职业ID: {(int)factionItem}");
                continue;
            }
            AssetManager.Instance.Unload(dataJobAttri.IconPath);
        }

        AssetManager.Instance.Unload(DROPDOWN_JOBALL_ICON_PATH);

        #endregion

        #region 卸载角色立绘

        foreach(var kvPair in CharacterSkinDic)
        {
            string path = CommonUtils.GetCharacterPicPath(kvPair.Key, CommonUtils.ECharacterPicPathType.SelectCharacter, kvPair.Value);
            AssetManager.Instance.Unload(path);
        }
        CharacterSkinDic.Clear();
        #endregion

        #region 稀有度颜色遮罩
        var coverPath = "Assets/Art/UI/Texture/UI_Pic_Main/UI_Pic_ShowAllCharacter/SAC_AllPart/";
        AssetManager.Instance.Unload(coverPath + "UI_RarityWhite.png");
        AssetManager.Instance.Unload(coverPath + "UI_RarityBlue.png");
        AssetManager.Instance.Unload(coverPath + "UI_RarityRed.png");
        #endregion

        foreach (CharacterItem characterItem in dicCharacter.Values)
        {
            characterItem.Dispose();
        }

        dicCharacter.Clear();

        EventManager.Instance.Unregister(EventManager.EventName.ItemUse, RefreshSprite);

        base.OnRelease();
    }

    /// <summary>
    /// 队伍编辑返回
    /// </summary>
    private void BackInTeam()
    {
        if (openType == E_OpenType.EditTeam)
            EventManager.Instance.Send(EventManager.EventName.TeamModified, curTeam.TeamIndex);

        CloseWindow();
    }

    /// <summary>
    /// 排序角色
    /// </summary>
    /// <param name="sortType"></param>
    private void SortCharacter()
    {
        if (curSortItem == null || curSortItem.SortState == E_SortState.None)
            return;

        switch (curSortItem.SortType)
        {
            case E_CharacterSortType.EStar:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, a.Cfg.StartStar.CompareTo(b.Cfg.StartStar));
                        });
                    else
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, b.Cfg.StartStar.CompareTo(a.Cfg.StartStar));
                        });
                    break;
                }
            case E_CharacterSortType.ELevel:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) => { return CharacterSort(a, b, a.Level.CompareTo(b.Level)); });
                    else
                        listShowCharacter.Sort((a, b) => { return CharacterSort(a, b, b.Level.CompareTo(a.Level)); });
                    break;
                }
            case E_CharacterSortType.EAwake:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, a.AwakeLevel.CompareTo(b.AwakeLevel));
                        });
                    else
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, b.AwakeLevel.CompareTo(a.AwakeLevel));
                        });
                    break;
                }
            case E_CharacterSortType.EBreak:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, a.BreakLevel.CompareTo(b.BreakLevel));
                        });
                    else
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, b.BreakLevel.CompareTo(a.BreakLevel));
                        });
                    break;
                }
            case E_CharacterSortType.ELikely:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, a.LikelyLevel.CompareTo(b.LikelyLevel));
                        });
                    else
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, b.LikelyLevel.CompareTo(a.LikelyLevel));
                        });
                    break;
                }
            case E_CharacterSortType.Cost:
                {
                    if (curSortItem.SortState == E_SortState.Up)
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, a.Cfg.SpendLeadership.CompareTo(b.Cfg.SpendLeadership));
                        });
                    else
                        listShowCharacter.Sort((a, b) =>
                        {
                            return CharacterSort(a, b, b.Cfg.SpendLeadership.CompareTo(a.Cfg.SpendLeadership));
                        });
                    break;
                }

            default:
                {
                    DebugUtil.LogError("未处理的排序类型：" + curSortItem.SortType);
                    break;
                }
        }

        if (openType == E_OpenType.EditTeam)//将已上阵的角色排在最后面
        {
            int index = 0;
            for (int i = 0; i < listShowCharacter.Count; i++)
            {
                if (TeamEditManager.Instance.IsUnitInAllTeam(listShowCharacter[index].Uid))
                {
                    listShowCharacter.Insert(listShowCharacter.Count, listShowCharacter[index]);
                    listShowCharacter.RemoveAt(index);
                }
                else
                {
                    index++;
                }
            }
        }
    }

    /// <summary>
    /// 角色排序多层逻辑
    /// 按等级＞稀有度＞突破等级＞觉醒等级＞好感度＞ID这样的优先级依次来排
    /// 遇到同级别情况就往后一个优先级取
    /// </summary>
    /// <param name="a"></param>
    /// <param name="b"></param>
    /// <param name="FirstCompare"></param>
    /// <returns></returns>
    int CharacterSort(CharacterDataInfo a, CharacterDataInfo b, int FirstCompare)
    {
        int ret = FirstCompare;
        if (ret != 0)
            return FirstCompare;
        else
        {
            ret = b.Level.CompareTo(a.Level); //等级
            if (ret != 0) return ret;
            ret = b.Cfg.StartStar.CompareTo(a.Cfg.StartStar); //稀有度
            if (ret != 0) return ret;
            ret = b.BreakLevel.CompareTo(a.BreakLevel); //突破等级
            if (ret != 0) return ret;
            ret = b.AwakeLevel.CompareTo(a.AwakeLevel); //觉醒等级
            if (ret != 0) return ret;
            ret = b.LikelyLevel.CompareTo(a.LikelyLevel); //好感度
            if (ret != 0) return ret;
            ret = a.Cfg.RoleID.CompareTo(b.Cfg.RoleID); //ID
            return ret;
        }
    }


    #region 刷新方法

    /// <summary>
    /// 刷新动态列表
    /// </summary>
    /// <param name="cell"></param>
    /// <param name="index"></param>
    private void OnRefreshItem(GameObject cell, int index)
    {
        if (!dicCharacter.TryGetValue(cell.GetInstanceID(), out CharacterItem item))
        {
            item = new CharacterItem(cell, OnCharacter);
            dicCharacter.Add(cell.GetInstanceID(), item);
        }

        if (openType == E_OpenType.Default && (index < 0 || index >= listShowCharacter.Count))
        {
            DebugUtil.LogError($"索引错误 {index}");
            return;
        }

        //editTeam && isEmptyCharacter时，无empty的item显示
        //realIndex = index
        //
        //不是EmptyCharacter时，有empty的item显示，多一个index=0的空item
        //realIndex = index - 1

        var realIndex = openType == E_OpenType.EditTeam && index != 0 ? index - 1 : index;
        if (openType == E_OpenType.EditTeam && curTeam.IsEmptyCharacter(teamIndex))
        {
            realIndex = index;
            item.SetInfo(listShowCharacter[realIndex], openType, curTeam);
            return;
        }

        if (openType == E_OpenType.EditTeam && index <= 0)
            item.SetInfoByTeamEditorEmpty();
        else
            item.SetInfo(listShowCharacter[realIndex], openType, curTeam);
    }

    /// <summary>
    /// 刷新全部
    /// </summary>
    private void RefreshUI()
    {
        SelectListByJobAndFraction(); // 先筛选
        SortCharacter(); // 再排序

        if (listShowCharacter.Count == 0)
            goEmpty.IsScaleShow(true);
        else
        {
            goEmpty.IsScaleShow(false);
            var count = listShowCharacter.Count;
            if (openType == E_OpenType.EditTeam && !curTeam.IsEmptyCharacter(teamIndex))//非空角色的点击进入编队会多一个下阵的按钮item
            {
                ++count;
            }

            recycleView.ShowList(count);
        }
    }

    #endregion

    #region 回调方法

    /// <summary>
    /// 返回
    /// </summary>
    private void OnBack()
    {
        if (openType == E_OpenType.EditTeam)
        {
            BackInTeam();
            return;
        }

        CloseWindow();
    }

    /// <summary>
    /// 主页
    /// </summary>
    private void OnHome()
    {
        if (GuideManager.Instance.IsGuiding && GuideManager.Instance.IsEditTeamGuide) // 编队引导不能退出
            return;

        if (openType == E_OpenType.EditTeam)
        {
            EventManager.Instance.Send<Action>(EventManager.EventName.ExitEditTeamOnOtherPanel, SureHome);
            return;
        }

        SureHome();
    }

    private async void SureHome()
    {
        CommonUtils.ChangeUIScene(Framework.Constants.MAIN_SCENE_PATH);
        if (!UIManager.Instance.CheckWindowCreated(UINameConst.UI_MainPanel))
        {
            await UIManager.Instance.LoadWindow(UINameConst.UI_MainPanel);
            UIManager.Instance.CloseAllNormalExcept(UINameConst.UI_MainPanel);
            await UI_MainPanelController.Open();
        }
        else
            //await UI_MainPanelController.Open();
            UIManager.Instance.CloseAllNormalExcept(UINameConst.UI_MainPanel);
    }
    

    /// <summary>
    /// 排序
    /// </summary>
    private void OnSort(SortItem item)
    {
        curSortItem = item;
        foreach (SortItem sortItem in listSortItem)
        {
            if (sortItem != curSortItem)
            {
                sortItem.SortState = E_SortState.None;
            }

            sortItem.IsSelect = sortItem == curSortItem;
        }

        StopScroll();

        RefreshUI();
    }

    void StopScroll()
    {
        recycleView.ScrollRect.velocity = Vector2.zero;
        recycleView.ScrollRect.content.anchoredPosition = Vector2.zero;
    }

    /// <summary>
    /// 点击角色
    /// </summary>
    /// <param name="go"></param>
    private async void OnCharacter(CharacterDataInfo info)
    {
        if (openType != E_OpenType.EditTeam)
        {
            CultivateStruct cultivateStruct = new()
            {
                showList = listShowCharacter,
                info = info
            };

            await UIManager.Instance.CreateAndOpenWindow(UINameConst.UI_Cultivate, cultivateStruct);

            return;
        }

        if (info == null)
        {
            curTeam.RemoveCharacter(teamIndex);
            RefreshUI();
            EventManager.Instance.Send(EventManager.EventName.TeamEditCharacterModelClear, teamIndex + 1);
            BackInTeam();
            return;
        }

        uint id = info.Uid;
        if (TeamEditManager.Instance.IsUnitInAllTeam(id))
        {
            CommonUtils.ShowMessageTips(CommonUtils.GetLocalizeText("Selected_click"));
            //var idx = curTeam.GetAllCharacterIdx(id);
            //if (idx >= 0 || teamIndex == TeamNew.ConductorIndex)
            //{
            //    EventManager.Instance.Send(EventManager.EventName.TeamEditCharacterModelClear, idx);
            //}
            //curTeam.DoCharacterDown(id);
            //队内角色不可再点击
            return;
        }
        else if (teamIndex == Team.ConductorIndex)
        {
            var idx = curTeam.GetAllCharacterIdx(id);
            if (idx >= 0)
            {
                EventManager.Instance.Send(EventManager.EventName.TeamEditCharacterModelClear, idx);
            }
            curTeam.RemoveCharacter(teamIndex);
        }

        // 传入的指挥官角色为-1 展示界面的索引需要+1
        EventManager.Instance.Send(EventManager.EventName.TeamEditCharacterModelCreate,
            new TeamPreviewNode.CharAddData { ID = id, Idx = teamIndex + 1 });

        curTeam.AddCharacter(teamIndex, id);
        PlayCharacterAudio(id);

        RefreshUI();
        BackInTeam();
    }

    private async void PlayCharacterAudio(uint id)
    {
        AudioManager.Instance.PlayAudio(Framework.Constants.Sound.TEAM_INFO_CLICK);
        await UniTask.WaitForSeconds(0.3f);
        AudioManager.Instance.StopAllSpeaks();
        DialogueManager.Instance.PlayDiaogue((int)id, cfg.DialogueCfg.E_DialogueType.FightChoose);
    }

    /// <summary>
    /// 角色升级
    /// </summary>
    /// <param name="type"></param>
    private void OnCharacterLevelup(UpgradeType type)
    {
        if (type != UpgradeType.UtLevel)
            return;

        RefreshUI();
    }

    private void OnReceiveShowAllCharacterSortEvent()
    {
        DebugUtil.Log("事件接收成功");
    }

    #endregion

    #region DropDown

    /// <summary>
    /// 势力下拉框获取文本
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    private string FactionDropdownData2Text(int value)
    {
        if (value == DROPDOWN_ALL_VALUE)
            return CommonUtils.GetLocalizeText("cultivate_AllFraction");
        else
            return CommonUtils.GetLocalizeText(E_LocalizePrefix.faction,
                value); // factionAttriCfg.Get(value).Faction
    }

    /// <summary>
    /// 职业下拉框获取文本
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    private string JobDropdownData2Text(int value)
    {
        if (value == DROPDOWN_ALL_VALUE)
            return CommonUtils.GetLocalizeText("cultivate_AllJob");
        else
            return CommonUtils.GetLocalizeText(jobAttriCfg.Get(value).DisplayName);
    }

    /// <summary>
    /// 职业下拉框获取图片
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    private Sprite JobDropdownData2Image(int value)
    {
        if (value == DROPDOWN_ALL_VALUE)
            return AssetManager.Instance.GetPreLoadResult<Sprite>(DROPDOWN_JOBALL_ICON_PATH);
        else
            return AssetManager.Instance.GetPreLoadResult<Sprite>(jobAttriCfg.Get(value).IconPath);
    }

    /// <summary>
    /// 其他下拉框获取文本
    /// </summary>
    /// <param name="value"></param>
    /// <returns></returns>
    private string OtherDropdownData2Text(int value)
    {
        return GetCharactererSortTypeLocalize((E_CharacterSortType)value);
    }

    /// <summary>
    /// 势力下拉框选中回调
    /// </summary>
    /// <param name="value"></param>
    private void FactionDropdownValueChanged(int value)
    {
        if (selectFractionIndex == value)
            return;
        var oldIndex = selectFractionIndex;
        selectFractionIndex = value;

        if (value != DROPDOWN_ALL_VALUE && !IsExistEligible())
        {
            CommonUtils.ShowMessageTips(CommonUtils.GetLocalizeText("cultivate_notHaveFractionJob"));
            for (int index = 0; index < shownFactions.Count; index++)
            {
                if ((int)shownFactions[index] == oldIndex)
                {
                    factionDropDown.SetValue(index); //设置回原来的值
                    return;
                }
            }

            return;
        }

        RefreshUI();
    }

    /// <summary>
    /// 职业下拉框选中回调
    /// </summary>
    /// <param name="value"></param>
    private void JobDropdownValueChanged(int value)
    {
        if (selectJobIndex == value)
            return;
        var oldIndex = selectJobIndex;
        selectJobIndex = value;

        if (value != DROPDOWN_ALL_VALUE && !IsExistEligible())
        {
            CommonUtils.ShowMessageTips(CommonUtils.GetLocalizeText("cultivate_notHaveFractionJob"));
            if (openType != E_OpenType.EditTeam || jobIndex <= 0)//选定职业的编队时如果没有符合条件的角色，不允许切换职业，显示空
            {
                jobDropDown.SetValue(oldIndex + 1); //设置回原来的值 (index -1 对应dropdown内value 0 选项
                return;
            }
        }

        RefreshUI();
    }

    /// <summary>
    /// 其他下拉框选中回调
    /// </summary>
    /// <param name="value"></param>
    private void OtherDropdownValueChanged(int value)
    {
        listSortItem[^1].SortType = (E_CharacterSortType)value;
    }

    /// <summary>
    /// 添加下拉框选项
    /// </summary>
    private void AddDropDownOption()
    {
        List<int> listDropDownData;

        #region 添加势力下拉框选项

        listDropDownData = new() { DROPDOWN_ALL_VALUE };

        //只显示拥有角色的势力
        var containsFactions = new List<Efaction>();
        foreach (var character in listAllCharacter)
        {
            if (containsFactions.Contains(character.Cfg.Fraction))
                continue;
            else
                containsFactions.Add(character.Cfg.Fraction);
        }

        foreach (Efaction faction in Enum.GetValues(typeof(Efaction)))
        {
            if (containsFactions.Contains(faction))
                listDropDownData.Add((int)faction);
        }

        shownFactions.Clear();
        foreach (var item in listDropDownData)
        {
            shownFactions.Add(item);
        }

        factionDropDown.SetData(listDropDownData);

        #endregion

        #region 职业下拉框选项

        listDropDownData = new() { DROPDOWN_ALL_VALUE };
        foreach (Ejob factionItem in Enum.GetValues(typeof(Ejob)))
        {
            if ((int)factionItem >= JOB_MAX)
            {
                continue;
            }
            DataJobAttri dataJobAttri = jobAttriCfg.Get((int)factionItem);
            if (null == dataJobAttri)
            {
                DebugUtil.Log($"配置获取失败，职业ID: {(int)factionItem}");
                continue;
            }
            listDropDownData.Add(((int)factionItem));
        }

        jobDropDown.SetData(listDropDownData);

        #endregion

        #region 其他下拉框选项

        listDropDownData = new();
        foreach (E_CharacterSortType sortType in Enum.GetValues(typeof(E_CharacterSortType)))
        {
            if (sortType == E_CharacterSortType.EStar)
                continue;

            if (sortType == E_CharacterSortType.ELevel)
                continue;

            listDropDownData.Add((int)sortType);
        }

        otherDropDown.SetData(listDropDownData);

        #endregion
    }

    private string GetCharactererSortTypeLocalize(E_CharacterSortType sortType)
    {
        return sortType switch
        {
            E_CharacterSortType.EAwake => CommonUtils.GetLocalizeText("culitivate_AwakeLevel"),
            E_CharacterSortType.EBreak => CommonUtils.GetLocalizeText("culitivate_BreakLevel"),
            E_CharacterSortType.ELikely => CommonUtils.GetLocalizeText("culitivate_likely"),
            E_CharacterSortType.Cost => CommonUtils.GetLocalizeText("culitivate_Cost"),
            _ => "",
        };
    }

    /// <summary>
    /// 是否存在符合条件的
    /// </summary>
    /// <param name="fraction"></param>
    /// <returns></returns>
    private bool IsExistEligible()
    {
        foreach (CharacterDataInfo info in listAllCharacter)
        {
            if (!IsConditionValid(selectFractionIndex, (int)info.Cfg.Fraction))
                continue;

            if (!IsConditionValid(selectJobIndex, (int)info.Cfg.Job))
                continue;

            return true;
        }

        return false;
    }

    /// <summary>
    /// 筛选势力和职业
    /// </summary>
    private void SelectListByJobAndFraction()
    {
        listShowCharacter.Clear();

        #region 引导特殊处理
        if (GuideManager.Instance.IsGuiding && GuideManager.Instance.CurGuideStepId < 200)
        {
            for (int i = 0; i < listAllCharacter.Count; i++)
            {
                if (100011 != listAllCharacter[i].Cfg.RoleID)
                    continue;

                listShowCharacter.Add(listAllCharacter[i]);
            }

            return;
        }
        #endregion

        for (int i = 0; i < listAllCharacter.Count; i++)
        {
            if (!IsConditionValid(selectFractionIndex, (int)listAllCharacter[i].Cfg.Fraction))
                continue;

            if (!IsConditionValid(selectJobIndex, (int)listAllCharacter[i].Cfg.Job))
                continue;

            listShowCharacter.Add(listAllCharacter[i]);
        }
    }

    /// <summary>
    /// 筛选条件是否有效
    /// </summary>
    private bool IsConditionValid(int selectId, int comparisonsId)
    {
        if (selectId == DROPDOWN_ALL_VALUE)
            return true;

        return selectId == comparisonsId;
    }

    #endregion
}