using TGS;
using System;
using PhxhSDK;
using Gameplay;
using Framework;
using UnityEngine;
using System.Linq;
using Gameplay.Net;
using cfg.CharacterCfg;
using Cysharp.Threading.Tasks;
using System.Collections.Generic;

/// <summary>
/// 编队系统管理器
/// </summary>
public class TeamEditManager : Singlenton<TeamEditManager>, IInitable
{
    public const int MAX_TEAM_COUNT = 10;
    private List<Team> _teamList;
    private Team _selectTeam;
    private int _selectTeamIdx;
    private TeamPreviewNode _teamPreviewNode;
    public static readonly List<string> PreviewNodeOpenList = new List<string>();

    private bool _isOpeningUI;

    public List<Team> TeamList => _teamList;
    public TeamPreviewNode TeamPreviewNode => _teamPreviewNode;

    public int SelectTeamIdx
    {
        get
        {
            var teamStoreData = StorageMgr.Instance.GetStorage<TeamEditStoreData>("DefaultTeamIndex");
            if (_selectTeamIdx <= 0)
            {
                if (teamStoreData != null)
                {
                    _selectTeamIdx = teamStoreData.teamSelectID;
                }
            }

            return _selectTeamIdx;
        }
    }

    void IInitable.Init()
    {
        _teamList = new List<Team>();
        EventManager.Instance.Register(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
    }

    void IInitable.Release()
    {
        _teamList.Clear();
        EventManager.Instance.Unregister(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
    }

    public void RefreshTeams()
    {
        RefreshOwnTeams();
    }

    public Team GetSelectTeam()
    {
        if (_teamList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队");
            return null;
        }

        _selectTeam = _teamList[_selectTeamIdx];
        return _selectTeam;
    }

    //在管理器内部创建一个成员Team
    public void CreateTeam(int idx, string name, int icon, uint[] characterIDs, uint[] playerSkillIDs, uint vehicleID)
    {
        //test
        for (int i = 0; i < characterIDs.Length; i++)
        {
            var dataDic = CharacterDataInfoManager.Instance.DataDic;
            bool isValid = characterIDs[i] == 0 || dataDic.ContainsKey(characterIDs[i]);
            if (!isValid)
            {
                characterIDs[i] = 0;
            }
        }


        _teamList.Add(new Team(idx, name, icon, characterIDs, playerSkillIDs, vehicleID));
    }

    public void CreateTeam(Team team)
    {
        CreateTeam(team.TeamIndex, team.Name, team.IconNumber, team.GetCharacterIDs(), team.GetPlayerSkillIDs(),
            team.GetVehicleID());
    }

    public Team GetTeamByIndex(uint idx)
    {
        for (int i = 0; i < _teamList.Count; i++)
        {
            if (_teamList[i].TeamIndex == idx)
            {
                return _teamList[i];
            }
        }

        return null;
    }

    //设置选中上阵的Team
    public void SetSelectTeam(uint idx)
    {
        if (_teamList.Count <= 0)
        {
            DebugUtil.LogError("----- 当前编队列表为空，请检查！！！-----");
        }

        _selectTeamIdx = (int)idx;

        for (int i = 0; i < _teamList.Count; i++)
        {
            if (_teamList[i].TeamIndex == idx)
            {
                _selectTeam = _teamList[i];
            }
        }

        var teamStoreData = StorageMgr.Instance.GetStorage<TeamEditStoreData>("DefaultTeamIndex");
        if (teamStoreData != null)
        {
            teamStoreData.teamSelectID = _selectTeamIdx;
        }

        StorageMgr.Instance.SyncForce = true;
    }

    public void SaveTeam(Team team)
    {
        if (team == null)
        {
            return;
        }

        uint[] charIds = team.GetCharacterIDs();
        uint[] playerSkillIds = team.GetPlayerSkillIDs();
        NetHelper.CreateTeam((uint)team.TeamIndex, team.Name, (uint)team.IconNumber, charIds, playerSkillIds,
            team.GetVehicleID());
    }

    public async UniTask LoadTeamPreviewNode(int teamIdx, string openPanel = "")
    {
        if (string.IsNullOrEmpty(openPanel))
        {
            DebugUtil.LogError("----- 请传入打开TeamPreviewNode的界面名！！！-----");
        }

        bool isRefresh = _teamPreviewNode && PreviewNodeOpenList.Count > 0;

        if (!PreviewNodeOpenList.Contains(openPanel))
        {
            PreviewNodeOpenList.Add(openPanel);
        }

        if (isRefresh)
        {
            RefreshPreviewNode(teamIdx);
            return;
        }

        await LoadNewTeamPreviewNode(teamIdx);
    }

    public async UniTask LoadNewTeamPreviewNode(int teamIdx)
    {
        DoReleaseTeamPreviewNode();

        var team = _teamList[teamIdx];
        var charIDs = team.GetCharacterIDs();
        var vehicleID = team.GetVehicleID();
        var node = await TeamPreviewNode.LoadNode();
        _teamPreviewNode = node;
        node.SetData(teamIdx, charIDs, vehicleID);
        node.CreateRt();
        await node.Init();
    }

    public async void RefreshPreviewNode(int teamIdx)
    {
        if (_teamPreviewNode)
        {
            var team = _teamList[teamIdx];
            if (team != null)
            {
                var charIDs = team.GetCharacterIDs();
                var vehicleID = team.GetVehicleID();
                _teamPreviewNode.SetData(teamIdx, charIDs, vehicleID);
                await _teamPreviewNode.Init();
                //_teamPreviewNode.RefreshNode(teamIdx);
            }
        }
    }

    public void ReleaseTeamPreviewNode(string releasePanel = "")
    {
        if (string.IsNullOrEmpty(releasePanel))
        {
            //DebugUtil.LogError("----- 请传入释放TeamPreviewNode的界面名！！！-----");
            return;
        }

        PreviewNodeOpenList.Remove(releasePanel);

        if (_teamPreviewNode && PreviewNodeOpenList.Count <= 0)
        {
            DoReleaseTeamPreviewNode();
        }
    }

    public void CompulsoryReleasePreviewNode()
    {
        PreviewNodeOpenList.Clear();
        DoReleaseTeamPreviewNode();
    }

    //外部打开编队信息界面
    public async UniTask OpenTeamInfoUI(int idx)
    {
        if (_isOpeningUI)
        {
            return;
        }

        _isOpeningUI = true;
        Team team = TeamEditManager.Instance.TeamList[idx];
        await TeamEditManager.Instance.LoadTeamPreviewNode(idx, UINameConst.UITeamInfo);
        await UIManager.Instance.CreateAndOpenWindow(UINameConst.UITeamInfo, team);
        _isOpeningUI = false;
    }
    
    private void DoReleaseTeamPreviewNode()
    {
        if (_teamPreviewNode)
        {
            TeamPreviewNode.ReleaseNode(_teamPreviewNode);
            _teamPreviewNode = null;
        }
    }

    private void RefreshOwnTeams()
    {
        _teamList.Clear();
        var partTeam = Actor.Instance.Team;
        var teamInfos = partTeam.Get();
        if (teamInfos != null)
        {
            for (int i = 0; i < teamInfos.Length; i++)
            {
                var info = teamInfos[i];
                if (info != null)
                {
                    string name = info.Name;
                    if (info.Name == "")
                    {
                        name = CommonUtils.GetLocalizeText("team_edit_default" + (i + 1));
                    }

                    CreateTeam(i, name, (int)info.Icon, info.CharacterIDs, info.PlayerSkillIDs, info.VehicleID);
                }
                else
                {
                    //test
                    uint[] testIDs = { 0, 0, 0, 0, 0, 0 };
                    uint[] testSkillIDs = { 0, 0, 0 };
                    CreateTeam(i, CommonUtils.GetLocalizeText("team_edit_default" + (i + 1)), 1, testIDs, testSkillIDs,
                        0);
                }
            }
        }

        var storeData = StorageMgr.Instance.GetStorage<TeamEditStoreData>("DefaultTeamIndex");
        int storeIdx = 0;
        if (storeData != null)
        {
            storeIdx = storeData.teamSelectID;
        }

        _selectTeamIdx = storeIdx;
    }

    private void OnTeamUpdate()
    {
        RefreshOwnTeams();
        EventManager.Instance.Send(EventManager.EventName.TeamUpdate);
    }

    public Team GetTestTeam()
    {
        var characterIDs = new uint[]
        {
            100001,
            100002,
            100003,
            100004,
            100005,
            100011,
            100025,
        };

        var vehicleIDs = new uint[]
        {
            300001,
            300007,
            300008
        };
        var team = new Team(0, "测试编队", 0, characterIDs, new uint[] { 911, 0, 0 }, vehicleIDs);
        return team;
    }
}

/// <summary>
/// 队列类
/// </summary>
public class Team
{
    private string _name;
    private int _icon;
    private uint[] _characterIDs;
    private uint[] _playerSkillIDs;
    private uint[] _vehicleIDs;
    private uint _vehicleID;
    private int _teamIdx;
    private int _allLeadership;
    private ProvideJob[] _provideJob;

    public const int MAX_CHARACTER_COUNT = 7;
    public const int MAX_VEHICLE_COUNT = 1;
    public const uint NONE_ID = 0;

    public Team(int teamIdx, string name, int icon, uint[] characterIDs, uint[] playerSkillIDs, uint vehicleID)
    {
        _teamIdx = teamIdx;
        _name = name;
        _icon = icon;

        uint[] tempIDs =
        {
            NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID
        };
        //判断一下传入的队员列表是否达到固定长度，未达到后面添加0到满足固定长度
        if (characterIDs.Length < MAX_CHARACTER_COUNT)
        {
            for (int i = 0; i < tempIDs.Length; i++)
            {
                if (i < characterIDs.Length)
                {
                    tempIDs[i] = characterIDs[i];
                }
            }

            _characterIDs = tempIDs;
        }
        else
        {
            _characterIDs = (uint[])characterIDs.Clone();
        }

        uint[] tempSkillIDs = { NONE_ID, NONE_ID, NONE_ID };
        // 判断一下传入的技能列表是否达到固定长度，未达到后面添加0到满足固定长度
        if (playerSkillIDs.Length < CommandSkillManager.COMMAND_SKILL_COUNT)
        {
            for (int i = 0; i < tempSkillIDs.Length; i++)
            {
                if (i < playerSkillIDs.Length)
                    tempSkillIDs[i] = playerSkillIDs[i];
            }

            _playerSkillIDs = tempSkillIDs;
        }
        else
            _playerSkillIDs = (uint[])playerSkillIDs.Clone();

        _vehicleID = vehicleID;
    }

    /// <summary>
    /// Test
    /// </summary>
    public Team(int teamIdx, string name, int icon, uint[] characterIDs, uint[] playerSkillIDs, uint[] vehicleID)
    {
        _teamIdx = teamIdx;
        _name = name;
        _icon = icon;

        uint[] tempIDs =
        {
            NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID, NONE_ID
        };
        //判断一下传入的队员列表是否达到固定长度，未达到后面添加0到满足固定长度
        if (characterIDs.Length < MAX_CHARACTER_COUNT)
        {
            for (int i = 0; i < tempIDs.Length; i++)
            {
                if (i < characterIDs.Length)
                {
                    tempIDs[i] = characterIDs[i];
                }
            }

            _characterIDs = tempIDs;
        }
        else
        {
            _characterIDs = (uint[])characterIDs.Clone();
        }

        uint[] tempSkillIDs = { NONE_ID, NONE_ID, NONE_ID };
        // 判断一下传入的技能列表是否达到固定长度，未达到后面添加0到满足固定长度
        if (playerSkillIDs.Length < CommandSkillManager.COMMAND_SKILL_COUNT)
        {
            for (int i = 0; i < tempSkillIDs.Length; i++)
            {
                if (i < playerSkillIDs.Length)
                    tempSkillIDs[i] = playerSkillIDs[i];
            }

            _playerSkillIDs = tempSkillIDs;
        }
        else
            _playerSkillIDs = (uint[])playerSkillIDs.Clone();

        _vehicleIDs = vehicleID;
    }

    public string Name
    {
        get => _name;
    }

    public int IconNumber
    {
        get => _icon;
    }

    public int TeamIndex
    {
        get => _teamIdx;
    }

    //获取队列成员
    public uint[] GetCharacterIDs()
    {
        return _characterIDs;
    }

    /// <summary>
    /// 获取指挥官技能id
    /// </summary>
    public uint[] GetPlayerSkillIDs()
    {
        return _playerSkillIDs;
    }

    public uint GetVehicleID()
    {
        return _vehicleID;
    }

    public uint[] GetVehicleIDs()
    {
        return _vehicleIDs;
    }

    //上阵角色
    public void DoCharacterUp(int idx, uint id = 0)
    {
        if (idx > MAX_CHARACTER_COUNT)
        {
            return;
        }

        _characterIDs[idx] = id;
        RefreshSpendLeadership(id);
    }

    //下阵角色
    public void DoCharacterDown(int idx)
    {
        if (idx > MAX_CHARACTER_COUNT)
        {
            return;
        }

        var oldCharacter = _characterIDs[idx];
        _characterIDs[idx] = NONE_ID;
        RefreshSpendLeadership(oldCharacter, false);
    }

    public void DoCharacterDown(uint id)
    {
        if (!_characterIDs.Contains(id))
        {
            return;
        }

        var idx = Array.IndexOf(_characterIDs, id);
        if (idx > -1)
        {
            var oldCharacter = _characterIDs[idx];
            _characterIDs[idx] = NONE_ID;
            RefreshSpendLeadership(oldCharacter, false);
        }
    }

    /// <summary>
    /// 更新该队伍花费的领导力
    /// </summary>
    /// <param name="id">角色ID</param>
    /// <param name="characterUp">是否为上阵</param>
    private void RefreshSpendLeadership(uint id, bool characterUp = true)
    {
        var leadership = CharacterDataInfoManager.Instance.GetCharacterInfo(id).Cfg.SpendLeadership;
        if (leadership <= 0)
        {
            DebugUtil.LogWarning("角色领导力配置错误为：{0}", leadership);
        }

        //DebugUtil.LogError("原来领导力:{0}，需要改变的领导力:{1}", _allLeadership, leadership);
        if (characterUp)
            _allLeadership += leadership;
        else
            _allLeadership -= leadership;

        //DebugUtil.LogError("上阵后总领导力:{0}", _allLeadership);
    }

    /// <summary>
    /// 更换技能
    /// </summary>
    public void ChangeSkill(int index, uint skillId)
    {
        if (_playerSkillIDs == null)
        {
            DebugUtil.LogError("空");
            return;
        }

        if (index >= _playerSkillIDs.Length)
        {
            DebugUtil.LogError("越界");
            return;
        }

        _playerSkillIDs[index] = skillId;
    }

    public void DoVehicleDown()
    {
        _vehicleID = 0;
    }

    public void DoVehicleUp(uint id)
    {
        _vehicleID = id;
    }

    //判断某个队列位置是否有角色
    public bool IsIndexCharacterEmpty(int idx)
    {
        if (!ValueValidator.IsIdValid(_characterIDs[idx]))
        {
            return true;
        }

        return false;
    }

    public bool IsVehicleEmpty()
    {
        if (_vehicleID != NONE_ID)
        {
            return false;
        }

        return true;
    }

    public bool IsCharEmpty()
    {
        for (int i = 0; i < _characterIDs.Length; i++)
        {
            if (_characterIDs[i] != NONE_ID)
            {
                return false;
            }
        }

        return true;
    }

    public bool IsMemberEmpty()
    {
        return IsVehicleEmpty() && IsCharEmpty();
    }

    //修改属性
    public void ChangeName(string newName)
    {
        _name = newName;
    }


    /// <summary>
    /// 判断是否包含某个角色
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public bool IsCharacterInTeam(uint id)
    {
        return _characterIDs.Contains(id);
    }

    /// <summary>
    /// 判断是否包含某个技能
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public bool IsSkillInTeam(uint id, ref int index)
    {
        for (int i = 0; i < _playerSkillIDs.Length; ++i)
        {
            if (id == _playerSkillIDs[i])
            {
                index = i;
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 获取队伍角色数量
    /// </summary>
    /// <returns></returns>
    public int GetCharacterCount()
    {
        int count = 0;
        foreach (uint id in _characterIDs)
        {
            if (NONE_ID == id)
                continue;

            ++count;
        }

        return count;
    }

    //获取角色索引
    public int GetCharacterIdx(uint id)
    {
        return Array.IndexOf(_characterIDs, id) + 1;
    }

    //获取载具索引
    public int GetVehicleIdx(uint id)
    {
        if (_vehicleIDs != null && _vehicleIDs.Length > 0)
        {
            return Array.IndexOf(_vehicleIDs, id);
        }

        return _characterIDs.Length;
    }
}

public class TeamEditStoreData
{
    public int teamSelectID = 0;
}

/// <summary>
/// 编队系统管理器
/// </summary>
public class TeamEditManagerNew : Singlenton<TeamEditManagerNew>, IInitable
{
    #region 常量

    public const int MaxTeamCount = 10;
    private const int DefaultIconID = 1;
    private const int DefaultConductorID = 0;
    private const string DefaultTeamIndex = "DefaultTeamIndex";

    #endregion

    #region 私有成员变量

    /// <summary>
    /// 队伍列表
    /// </summary>
    private List<TeamNew> _teamList;

    /// <summary>
    /// 选择队伍
    /// </summary>
    private TeamNew _selectTeam;

    /// <summary>
    /// 选择队伍索引
    /// </summary>
    private int _selectTeamIdx;

    /// <summary>
    /// 当前节点
    /// </summary>
    private TeamPreviewNode _teamPreviewNode;

    /// <summary>
    /// 展示节点列表
    /// </summary>
    private readonly List<string> previewNodeOpenList = new();

    #endregion

    #region 成员变量

    public List<TeamNew> TeamList => _teamList;
    public TeamPreviewNode TeamPreviewNode => _teamPreviewNode;

    public int SelectTeamIdx
    {
        get
        {
            var teamStoreData = StorageMgr.Instance.GetStorage<TeamEditStoreData>(DefaultTeamIndex);
            if (_selectTeamIdx > 0) return _selectTeamIdx;
            if (teamStoreData != null)
            {
                _selectTeamIdx = teamStoreData.teamSelectID;
            }

            return _selectTeamIdx;
        }
    }

    #endregion

    #region 初始化与释放

    void IInitable.Init()
    {
        _teamList = new List<TeamNew>();
        EventManager.Instance.Register(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
    }

    void IInitable.Release()
    {
        _teamList.Clear();
        EventManager.Instance.Unregister(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
    }

    #endregion

    #region 对外方法

    /// <summary>
    /// 刷新队伍列表
    /// </summary>
    public void RefreshTeams()
    {
        RefreshOwnTeams();
    }

    /// <summary>
    /// 创建队伍
    /// </summary>
    public void CreateTeam(TeamNew team)
    {
        CreateTeam(team.TeamIndex, team.Name, team.IconNumber, team.Conductor, team.GetUnitIDs(),
            team.GetPlayerSkillIDs());
    }

    /// <summary>
    /// 获取当前选择队伍
    /// </summary>
    public TeamNew GetSelectTeam()
    {
        if (_teamList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队");
            return null;
        }

        _selectTeam = GetTeamByIndex(_selectTeamIdx);
        return _selectTeam;
    }

    /// <summary>
    /// 根据索引获取队伍
    /// </summary>
    public TeamNew GetTeamByIndex(int idx)
    {
        if (_teamList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队");
            return null;
        }

        return _teamList.FirstOrDefault(team => team.TeamIndex == idx);
    }

    /// <summary>
    /// 设置当前选择的队伍
    /// </summary>
    public void SetSelectTeam(int idx)
    {
        if (_teamList.Count <= 0)
        {
            DebugUtil.LogError("----- 当前编队列表为空，请检查！！！-----");
        }

        _selectTeamIdx = idx;

        foreach (var team in _teamList.Where(team => team.TeamIndex == idx))
        {
            _selectTeam = team;
        }

        var teamStoreData = StorageMgr.Instance.GetStorage<TeamEditStoreData>(DefaultTeamIndex);
        if (teamStoreData != null)
        {
            teamStoreData.teamSelectID = _selectTeamIdx;
        }

        StorageMgr.Instance.SyncForce = true;
    }

    /// <summary>
    /// 保存队伍
    /// </summary>
    public void SaveTeam(TeamNew team)
    {
        if (team == null)
        {
            return;
        }

        NetHelper.CreateTeamNew((uint)team.TeamIndex, team.Name, (uint)team.IconNumber, team.Conductor,
            team.GetUnitIDs(), team.GetPlayerSkillIDs());
    }

    #endregion

    #region 内部函数

    /// <summary>
    /// 刷新队伍列表
    /// </summary>
    private void RefreshOwnTeams()
    {
        _teamList.Clear();
        var partTeam = Actor.Instance.Team;
        var teamInfos = partTeam.Get();
        if (teamInfos != null)
        {
            for (var i = 0; i < teamInfos.Length; i++)
            {
                var info = teamInfos[i];
                var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + (i + 1));
                // 获取队伍不为空
                if (info != null)
                {
                    var name = info.Name;
                    if (string.IsNullOrEmpty(name))
                    {
                        name = defaultName;
                    }

                    CreateTeam(i, name, (int)info.Icon, info.Conductor, info.UnitIDs, info.PlayerSkillIDs);
                }
                else
                {
                    uint[] testSkillIDs = { 0, 0, 0 };
                    CreateTeam(i, defaultName, DefaultIconID, DefaultConductorID, null, testSkillIDs);
                }
            }
        }

        var storeData = StorageMgr.Instance.GetStorage<TeamEditStoreData>(DefaultTeamIndex);
        var storeIdx = 0;
        if (storeData != null)
        {
            storeIdx = storeData.teamSelectID;
        }

        _selectTeamIdx = storeIdx;
    }

    /// <summary>
    /// 内部创建Team
    /// </summary>
    private void CreateTeam(int idx, string name, int icon, uint conductor, List<uint> unitIDs, uint[] playerSkillIDs)
    {
        var characterDataDic = CharacterDataInfoManager.Instance.DataDic;
        var vehicleDataDic = VehicleCultivateDataManager.Instance.DataDic;
        if (unitIDs != null)
        {
            // 检索不合法成员
            var illegalIDs = unitIDs.Where(unit =>
                unit != 0 && !vehicleDataDic.ContainsKey(unit) && !characterDataDic.ContainsKey(unit)).ToList();

            foreach (var illegalID in illegalIDs)
            {
                if (unitIDs.Contains(illegalID))
                {
                    unitIDs.Remove(illegalID);
                }
            }
        }

        _teamList.Add(new TeamNew(idx, name, icon, conductor, unitIDs, playerSkillIDs));
    }

    #endregion

    #region 模型展示相关

    /// <summary>
    /// 加载队伍成员展示节点
    /// </summary>
    public async UniTask LoadTeamPreviewNode(int teamIdx, string openPanel = "")
    {
        if (string.IsNullOrEmpty(openPanel))
        {
            DebugUtil.LogError("----- 请传入打开TeamPreviewNode的界面名！！！-----");
        }

        var isRefresh = _teamPreviewNode && previewNodeOpenList.Count > 0;

        if (!previewNodeOpenList.Contains(openPanel))
        {
            previewNodeOpenList.Add(openPanel);
        }

        if (isRefresh)
        {
            RefreshPreviewNode(teamIdx);
            return;
        }

        await LoadNewTeamPreviewNode(teamIdx);
    }

    /// <summary>
    /// 释放展示节点
    /// </summary>
    public void ReleaseTeamPreviewNode(string releasePanel)
    {
        if (string.IsNullOrEmpty(releasePanel))
        {
            return;
        }

        previewNodeOpenList.Remove(releasePanel);

        if (_teamPreviewNode && previewNodeOpenList.Count <= 0)
        {
            DoReleaseTeamPreviewNode();
        }
    }

    /// <summary>
    /// 强制释放
    /// </summary>
    public void CompulsoryReleasePreviewNode()
    {
        previewNodeOpenList.Clear();
        DoReleaseTeamPreviewNode();
    }

    /// <summary>
    /// 通过队伍索引加载队伍展示节点
    /// </summary>
    private async UniTask LoadNewTeamPreviewNode(int teamIdx)
    {
        DoReleaseTeamPreviewNode();

        var team = _teamList[teamIdx];
        var charIDs = team.GetCharacterIDs().ToArray();
        var vehicleIDs = team.GetVehicleIDs().ToArray();
        var node = await TeamPreviewNode.LoadNode();
        _teamPreviewNode = node;
        node.SetDataNew(teamIdx, charIDs, vehicleIDs);
        node.CreateRt();
        await node.Init();
    }

    /// <summary>
    /// 通过队伍索引刷新队伍展示节点
    /// </summary>
    private async void RefreshPreviewNode(int teamIdx)
    {
        if (!_teamPreviewNode) return;
        var team = _teamList[teamIdx];
        if (team == null) return;

        var charIDs = team.GetCharacterIDs().ToArray();
        var vehicleIDs = team.GetVehicleIDs().ToArray();
        _teamPreviewNode.SetDataNew(teamIdx, charIDs, vehicleIDs);
        await _teamPreviewNode.Init();
    }

    /// <summary>
    /// 释放展示节点
    /// </summary>
    private void DoReleaseTeamPreviewNode()
    {
        if (_teamPreviewNode)
        {
            TeamPreviewNode.ReleaseNode(_teamPreviewNode);
            _teamPreviewNode = null;
        }
    }

    #endregion

    #region 事件监听

    private void OnTeamUpdate()
    {
        RefreshOwnTeams();
        EventManager.Instance.Send(EventManager.EventName.TeamUpdate);
    }

    #endregion

    #region 测试队伍

    public TeamNew GetTestTeam()
    {
        var unitIDs = new List<uint>() { 100002, 100003, 100004, 100005, 100011, 100025, };
        return new TeamNew(0, "测试编队", 0, 100001, unitIDs, new uint[] { 911, 0, 0 });
    }

    #endregion
}

/// <summary>
/// 队列类
/// </summary>
public class TeamNew
{
    private const int ConductorIndex = -1;
    private const uint NoneID = 0;

    #region 私有成员变量

    /// <summary>
    /// 队伍名称
    /// </summary>
    private string _name;

    /// <summary>
    /// 队伍图标
    /// </summary>
    private int _icon;

    /// <summary>
    /// 指挥官ID
    /// </summary>
    private uint _conductor;

    /// <summary>
    /// 队伍所有成员
    /// </summary>
    private List<uint> _unitIDs;

    /// <summary>
    /// 队伍中角色成员
    /// </summary>
    private List<uint> _characterIDs;

    /// <summary>
    /// 队伍中载具成员
    /// </summary>
    private List<uint> _vehicleIDs;

    /// <summary>
    /// 角色技能
    /// </summary>
    private uint[] _playerSkillIDs;

    /// <summary>
    /// 队伍索引
    /// </summary>
    private int _teamIdx;

    /// <summary>
    /// 该队伍所花费领导力
    /// </summary>
    private int _allLeadership;

    /// <summary>
    /// 指挥官所提供的职业列表
    /// </summary>
    private List<ProvideJob> _provideJob;

    #endregion

    #region 成员变量

    public uint Conductor
    {
        get => _conductor;
    }

    public string Name
    {
        get => _name;
    }

    public int IconNumber
    {
        get => _icon;
    }

    public int TeamIndex
    {
        get => _teamIdx;
    }

    public int AllLeaderShip
    {
        get => _allLeadership;
    }

    #endregion

    #region 构造函数

    public TeamNew(int teamIdx, string name, int icon, uint conductor, List<uint> unitIDs, uint[] playerSkillIDs)
    {
        _teamIdx = teamIdx;
        _name = name;
        _icon = icon;
        _conductor = conductor;

        // 指挥合法
        if (CheckConductorLegal(_conductor) && unitIDs is { Count: > 0 })
        {
            _unitIDs = CheckTeamLegal(unitIDs) ? unitIDs : new List<uint>();
            _provideJob = CharacterDataInfoManager.Instance.GetCharacterInfo(_conductor).Cfg.ProvideJob.ToList();
        }
        else
        {
            _conductor = NoneID;
            _unitIDs = new List<uint>();
            _provideJob = new List<ProvideJob>();
        }


        InitCharacters();
        InitVehicleIDs();


        // 技能
        uint[] tempSkillIDs = { NoneID, NoneID, NoneID };
        // 判断一下传入的技能列表是否达到固定长度，未达到后面添加0到满足固定长度
        if (playerSkillIDs.Length < CommandSkillManager.COMMAND_SKILL_COUNT)
        {
            for (var i = 0; i < tempSkillIDs.Length; i++)
            {
                if (i < playerSkillIDs.Length)
                    tempSkillIDs[i] = playerSkillIDs[i];
            }

            _playerSkillIDs = tempSkillIDs;
        }
        else
            _playerSkillIDs = (uint[])playerSkillIDs.Clone();
    }

    #endregion

    #region 编辑队伍成员

    /// <summary>
    /// 上阵角色
    /// </summary>
    /// <param name="idx">角色在队伍中的索引</param>
    /// <param name="id">角色ID</param>
    public void DoCharacterUp(int idx, uint id = 0)
    {
        if (idx == ConductorIndex)
        {
            ChangeConductor(id);
            return;
        }

        _unitIDs ??= new List<uint>();
        _characterIDs ??= new List<uint>();

        // 该索引不存在
        if (idx >= _unitIDs.Count)
        {
            _unitIDs.Add(id);
            _characterIDs.Add(id);
        }
        else
        {
            var oldCharacter = _unitIDs[idx];
            var characterIndex = _characterIDs.IndexOf(oldCharacter);
            if (characterIndex >= 0)
                _characterIDs[characterIndex] = id;
            _unitIDs[idx] = id;
        }

        RefreshSpendLeadership(id);
    }

    /// <summary>
    /// 通过索引下阵角色 (直接点空角色)
    /// </summary>
    /// <param name="idx">角色在队伍中的索引</param>
    public void DoCharacterDown(int idx)
    {
        if (idx == ConductorIndex)
        {
            ChangeConductor(NoneID);
            return;
        }

        if (_unitIDs == null || _characterIDs == null) return;

        if (idx >= _unitIDs.Count)
        {
            DebugUtil.LogError("队伍{0}下阵角色时索引{1}错误", _teamIdx, idx);
            return;
        }

        var oldCharacter = _unitIDs[idx];
        _unitIDs.RemoveAt(idx);
        _characterIDs.Remove(oldCharacter);
        RefreshSpendLeadership(oldCharacter, false);
    }

    /// <summary>
    /// 通过ID下阵角色 (更换)
    /// </summary>
    /// <param name="id">角色ID</param>
    public void DoCharacterDown(uint id)
    {
        if (_unitIDs == null || _characterIDs == null) return;
        _unitIDs.Remove(id);
        _characterIDs.Remove(id);
        RefreshSpendLeadership(id, false);
    }

    /// <summary>
    /// 上阵载具
    /// </summary>
    /// <param name="idx">载具在队伍中的索引</param>
    /// <param name="id">载具ID</param>
    public void DoVehicleUp(int idx, uint id = 0)
    {
        _unitIDs ??= new List<uint>();
        _vehicleIDs ??= new List<uint>();

        // 该索引不存在
        if (idx >= _unitIDs.Count)
        {
            _unitIDs.Add(id);
            _vehicleIDs.Add(id);
        }
        else
        {
            var oldVehicle = _unitIDs[idx];
            var vehicleIndex = _characterIDs.IndexOf(oldVehicle);
            if (vehicleIndex >= 0)
                _vehicleIDs[vehicleIndex] = id;
            _unitIDs[idx] = id;
        }

        RefreshSpendLeadership(id, true, true);
    }


    /// <summary>
    /// 通过索引下阵载具 （直接点空载具）
    /// </summary>
    /// <param name="idx">载具在队伍中的索引</param>
    public void DoVehicleDown(int idx)
    {
        if (_unitIDs == null || _characterIDs == null) return;

        if (idx >= _unitIDs.Count)
        {
            DebugUtil.LogError("队伍{0}下阵载具时索引{1}错误", _teamIdx, idx);
            return;
        }

        var oldVehicle = _unitIDs[idx];
        _unitIDs.RemoveAt(idx);
        _vehicleIDs.Remove(oldVehicle);
        RefreshSpendLeadership(oldVehicle, false, true);
    }

    /// <summary>
    /// 通过ID下阵载具 (更换)
    /// </summary>
    /// <param name="id">载具ID</param>
    public void DoVehicleDown(uint id)
    {
        if (_unitIDs == null || _characterIDs == null) return;
        _unitIDs.Remove(id);
        _vehicleIDs.Remove(id);
        RefreshSpendLeadership(id, false, true);
    }

    /// <summary>
    /// 更新该队伍花费的领导力
    /// </summary>
    /// <param name="id">角色ID</param>
    /// <param name="isUp">是否为上阵</param>
    /// <param name="isVehicle">是否为载具</param>
    private void RefreshSpendLeadership(uint id, bool isUp = true, bool isVehicle = false)
    {
        var leadership =
            isVehicle
                ? VehicleCultivateDataManager.Instance.GetVehicleCultivateData(id).Cfg.SpendLeadership
                : CharacterDataInfoManager.Instance.GetCharacterInfo(id).Cfg.SpendLeadership;
        if (leadership <= 0)
        {
            DebugUtil.LogWarning("角色领导力配置错误为：{0}", leadership);
        }

        //DebugUtil.LogError("原来领导力:{0}，需要改变的领导力:{1}", _allLeadership, leadership);
        if (isUp)
            _allLeadership += leadership;
        else
            _allLeadership -= leadership;

        //DebugUtil.LogError("上阵后总领导力:{0}", _allLeadership);
    }

    /// <summary>
    /// 更换指挥
    /// </summary>
    private void ChangeConductor(uint id)
    {
        if (IsCharacterInTeam(id)) return;
        // 错误或为空都需要清空队伍
        ClearAllCharacter();

        _conductor = id;
        if (id == NoneID) return;
        var info = CharacterDataInfoManager.Instance.GetCharacterInfo(id);
        if (info == null)
        {
            DebugUtil.LogError("更换指挥官角色错误:{0}, 没有该角色配置", id);
            return;
        }


        var jobs = info.Cfg.ProvideJob;
        if (jobs.Length == 0)
        {
            DebugUtil.LogError("该指挥 {0} 提供职业为空", id);
            return;
        }

        _provideJob = jobs.ToList();
    }

    #endregion

    #region 技能相关

    /// <summary>
    /// 更换技能
    /// </summary>
    public void ChangeSkill(int index, uint skillId)
    {
        if (_playerSkillIDs == null)
        {
            DebugUtil.LogError("空");
            return;
        }

        if (index >= _playerSkillIDs.Length)
        {
            DebugUtil.LogError("越界");
            return;
        }

        _playerSkillIDs[index] = skillId;
    }

    #endregion

    #region 修改队伍属性相关

    /// <summary>
    /// 更改队伍名称
    /// </summary>
    public void ChangeName(string newName)
    {
        _name = newName;
    }

    /// <summary>
    /// 更改图标
    /// </summary>
    public void ChangeIcon(int icon)
    {
        _icon = icon;
    }

    #endregion

    #region 对外方法

    /// <summary>
    /// 获取队伍成员
    /// </summary>
    public List<uint> GetUnitIDs()
    {
        return _unitIDs;
    }

    /// <summary>
    /// 获取队伍角色列表
    /// </summary>
    public List<uint> GetVehicleIDs()
    {
        return _vehicleIDs;
    }

    /// <summary>
    /// 获取队伍载具列表
    /// </summary>
    public List<uint> GetCharacterIDs()
    {
        return _characterIDs;
    }

    /// <summary>
    /// 获取指挥官技能id
    /// </summary>
    public uint[] GetPlayerSkillIDs()
    {
        return _playerSkillIDs;
    }

    /// <summary>
    /// 队伍成员是否全为空
    /// </summary>
    public bool IsMemberEmpty()
    {
        // 只根据指挥判断
        return _conductor == NoneID;
    }

    /// <summary>
    /// 判断队伍中是否包含某成员
    /// </summary>
    public bool IsCharacterInTeam(uint id)
    {
        return _unitIDs.Contains(id);
    }

    /// <summary>
    /// 判断是否包含某个技能
    /// </summary>
    public bool IsSkillInTeam(uint id, ref int index)
    {
        for (int i = 0; i < _playerSkillIDs.Length; ++i)
        {
            if (id == _playerSkillIDs[i])
            {
                index = i;
                return true;
            }
        }

        return false;
    }

    /// <summary>
    /// 获取队伍角色数量
    /// </summary>
    public int GetCharacterCount()
    {
        //TODO 需判断是否安全正确
        return _characterIDs?.Count ?? 0;
    }

    /// <summary>
    /// 通过ID获取角色索引 TODO 需联调确定是否正确 
    /// </summary>
    public int GetCharacterIdx(uint id)
    {
        if (_unitIDs != null)
            return _unitIDs.IndexOf(id);
        return -1;
    }

    /// <summary>
    /// 通过ID获取载具索引 TODO 需联调确定是否正确  
    /// </summary>
    public int GetVehicleIdx(uint id)
    {
        if (_unitIDs != null)
            return _unitIDs.IndexOf(id);
        return -1;
    }

    #endregion

    #region 内部函数

    /// <summary>
    /// 检查指挥官是否合法
    /// </summary>
    private bool CheckConductorLegal(uint conductorID)
    {
        if (conductorID == NoneID) return false;
        var info = CharacterDataInfoManager.Instance.GetCharacterInfo(conductorID);
        if (info == null)
            return false;
        return info.Cfg.Job == Ejob.Job_Commander;
    }

    /// <summary>
    /// 检查队伍成员是否合法
    /// </summary>
    private bool CheckTeamLegal(List<uint> characters)
    {
        if (characters is not { Count: > 0 }) return false;

        // 获取推荐职业
        var jobs = CharacterDataInfoManager.Instance.GetCharacterInfo(_conductor).Cfg.ProvideJob;
        _provideJob = jobs.ToList();

        // 有职业不为指挥所提供
        foreach (var character in characters)
        {
            var job = CharacterDataInfoManager.Instance.GetCharacterJob(character);
            if (_provideJob.All(pJob => (int)pJob != (int)job))
                return false;
        }

        return true;
    }

    /// <summary>
    /// 初始化角色列表
    /// </summary>
    private void InitCharacters()
    {
        _characterIDs = new List<uint>();
        foreach (var unit in _unitIDs.Where(unit => CharacterDataInfoManager.Instance.DataDic.ContainsKey(unit)))
        {
            _characterIDs.Add(unit);
        }
    }

    /// <summary>
    /// 初始化载具列表
    /// </summary>
    private void InitVehicleIDs()
    {
        _vehicleIDs = new List<uint>();
        foreach (var unit in _unitIDs.Where(unit => VehicleCultivateDataManager.Instance.DataDic.ContainsKey(unit)))
        {
            _vehicleIDs.Add(unit);
        }
    }

    /// <summary>
    /// 获取提供职业中的角色数量
    /// </summary>
    private int GetCharacterCountFromProvideJob()
    {
        return _provideJob.Count(job => job != ProvideJob.Job_Vehicle);
    }

    /// <summary>
    /// 获取提供职业中的载具数量
    /// </summary>
    private int GetVehicleCountFromProvideJob()
    {
        return _provideJob.Count(job => job == ProvideJob.Job_Vehicle);
    }

    /// <summary>
    /// 清空队伍
    /// </summary>
    private void ClearAllCharacter()
    {
        _unitIDs.Clear();
        _characterIDs.Clear();
        _vehicleIDs.Clear();
        _provideJob.Clear();
    }

    #endregion
}