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

public class TeamEditStoreData
{
    public int teamSelectID = 0;
}

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

    public const int MAX_TEAM_COUNT = 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.Commander, 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("----- 当前编队列表为空，请检查！！！-----");
        }

        // DebugUtil.LogError("更换队伍:{0}", idx);
        _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;
        }

        /*DebugUtil.LogWarning("保存的第{0}队的队名:{1}，Icon：{2}, 指挥官:{3}", team.TeamIndex, team.Name, (uint)team.IconNumber,
            team.Commander);

        foreach (var unit in team.GetUnitIDs())
        {
            DebugUtil.LogWarning("及其保存的成员有:{0}", unit);
        }*/
        

        NetHelper.CreateTeamNew((uint)team.TeamIndex, team.Name, (uint)team.IconNumber, team.Commander,
            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)
    {
        /*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);
                }
            }
        }*/

        //DebugUtil.LogError("创建:{0}，索引:{1}，指挥官:{2}", name, idx, conductor);
        _teamList.Add(new TeamNew(idx, name, 510001, 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.GetAllCharacters().ToArray();
        var vehicleIDs = team.GetVehicleIDs().ToArray();
        var node = await TeamPreviewNode.LoadNode();
        _teamPreviewNode = node;
        node.SetData(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.GetAllCharacters().ToArray();
        var vehicleIDs = team.GetVehicleIDs().ToArray();
        _teamPreviewNode.SetData(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, "测试编队", 510001, 100001, unitIDs, new uint[] { 911, 0, 0 });
    }

    #endregion
}

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

    #region 私有成员变量

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

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

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

    /// <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;

    /// <summary>
    /// 指挥官所提供的载具数量
    /// </summary>
    private int _provideVehicleCount;

    #endregion

    #region 成员变量

    public List<ProvideJob> ProvideJobs
    {
        get => _provideJob;
    }

    public uint Commander
    {
        get => _commander;
    }

    public string Name
    {
        get => _name;
    }

    public int IconNumber
    {
        get => _icon;
    }

    public int TeamIndex
    {
        get => _teamIdx;
    }

    public int AllLeaderShip
    {
        get => _allLeadership;
    }

    public int ProvideJobCount
    {
        get
        {
            return _provideJob is { Count: <= 0 }
                ? 0
                : _provideJob.Count(job => job == cfg.CharacterCfg.ProvideJob.Job_Vehicle);
        }
    }

    #endregion

    #region 构造函数

    public TeamNew(int teamIdx, string name, int icon, uint commander, List<uint> unitIDs, uint[] playerSkillIDs)
    {
        //DebugUtil.LogError("创建队伍：名字:{0},指挥官:{1},队标:{2}", name, commander, icon);
        _teamIdx = teamIdx;
        _name = name;
        _icon = icon;
        _commander = commander;

        // 指挥合法
        if (CheckConductorLegal(_commander) && unitIDs is { Count: > 0 })
        {
            _provideJob = CharacterDataInfoManager.Instance.GetCharacterInfo(_commander).Cfg.ProvideJob.ToList();
            if (CheckTeamLegal(unitIDs))
            {
                _unitIDs = unitIDs;
                //DebugUtil.LogError("有成员数量:{0}",unitIDs.Count);
            }
            else
            {
                _unitIDs = new List<uint>();
                foreach (var job in ProvideJobs)
                {
                    _unitIDs.Add(NoneID);
                }
            }
        }
        else
        {
            _commander = NoneID;
            _unitIDs = new List<uint>();
            _provideJob = new List<ProvideJob>();
        }

        PartUnits();
        RefreshSpendLeadership();

        // 技能
        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 (_unitIDs == null || _characterIDs == null) return;
        if (idx == ConductorIndex)
        {
            DoCommanderUp(id);
            return;
        }

        // 该索引不存在
        if (idx >= _unitIDs.Count) return;

        // 替换队内角色
        if (IsUnitInTeam(id))
        {
            var oldIndex = _unitIDs.IndexOf(id);
            if (oldIndex >= 0)
            {
                _unitIDs[oldIndex] = NoneID;
                _characterIDs[oldIndex] = NoneID;
            }
        }

        _characterIDs[idx] = id;
        _unitIDs[idx] = id;
    }

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

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

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

        var oldCharacter = _unitIDs[idx];
        _unitIDs[idx] = 0;

        var idxCharacter = _characterIDs.IndexOf(oldCharacter);
        if (idxCharacter >= 0)
            _characterIDs[idxCharacter] = 0;
    }

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

        var idxUnits = _unitIDs.IndexOf(id);
        _unitIDs[idxUnits] = 0;

        var idxCharacter = _characterIDs.IndexOf(id);
        if (idxCharacter >= 0)
            _characterIDs[idxCharacter] = 0;
    }

    /// <summary>
    /// 上阵载具
    /// </summary>
    /// <param name="idx">载具在队伍中的索引 载具排在角色后面</param>
    /// <param name="id">载具ID</param>
    public void DoVehicleUp(int idx, uint id = 0)
    {
        if (_unitIDs == null || _vehicleIDs == null) return;

        if (IsUnitInTeam(id))
        {
            var unitIndex = _unitIDs.IndexOf(id);
            var vehicleIndex = _vehicleIDs.IndexOf(id);

            _unitIDs[unitIndex] = NoneID;
            _vehicleIDs[vehicleIndex] = NoneID;

            // 添加到新位置
            var newVehicleIndex = idx - _characterIDs.Count;
            if (newVehicleIndex < _vehicleIDs.Count)
                _vehicleIDs[newVehicleIndex] = id;
        }
        else
        {
            var oldVehicle = _unitIDs[idx];
            var oldVehicleIndex = _vehicleIDs.IndexOf(oldVehicle);
            if (oldVehicleIndex >= 0)
                _vehicleIDs[oldVehicleIndex] = id;
        }

        _unitIDs[idx] = id;
    }

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

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

        var oldVehicle = _unitIDs[idx];
        var vehicleIndex = _vehicleIDs.IndexOf(oldVehicle);
        //DebugUtil.LogError("传来的载具的索引{0},找到的载具索引:{1}",idx,vehicleIndex);
        if (vehicleIndex >= 0)
            _vehicleIDs[vehicleIndex] = 0;

        _unitIDs[idx] = NoneID;
    }

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

        if (id >= _unitIDs.Count) return;
        var idxUnits = _unitIDs.IndexOf(id);
        _unitIDs[idxUnits] = 0;

        var idxVehicle = _vehicleIDs.IndexOf(id);
        if (idxVehicle >= 0)
            _vehicleIDs[idxVehicle] = 0;
    }

    /// <summary>
    /// 更新该队伍花费的领导力
    /// </summary>
    public void RefreshSpendLeadership()
    {
        if (_commander == NoneID)
        {
            _allLeadership = 0;
            return;
        }

        _allLeadership = CharacterDataInfoManager.Instance.GetSpendLeadership(_commander);
        foreach (var unitID in _unitIDs)
        {
            if (unitID == NoneID)
                continue;
            if (VehicleCultivateDataManager.Instance.DataDic.ContainsKey(unitID))
            {
                _allLeadership += VehicleCultivateDataManager.Instance.GetSpendLeadership(unitID);
            }
            else
            {
                _allLeadership += CharacterDataInfoManager.Instance.GetSpendLeadership(unitID);
            }
        }

        // DebugUtil.LogError("刷新后的领导力是:{0}", _allLeadership);
    }

    private async void DoCommanderUp(uint id)
    {
        _commander = id;
        var info = CharacterDataInfoManager.Instance.GetCharacterInfo(id);
        if (info == null)
        {
            return;
        }

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

        _provideJob = jobs.ToList();
        // 重置队伍
        ResetUnits();

        // 刷新一下节点
        await TeamEditManagerNew.Instance.LoadTeamPreviewNode(_teamIdx, UINameConst.UI_TeamAndSkillSelect);

        /*DebugUtil.LogError("------上指挥官后-----------");
        foreach (var job in _unitIDs)
        {
            DebugUtil.LogError("有:{0}", job);
        }

        DebugUtil.LogError("-----------------");*/
    }

    private void DoCommanderDown()
    {
        ClearUnits();
        EventManager.Instance.Send(EventManager.EventName.TeamEditVAllModelClear);
        _commander = NoneID;
    }

    /// <summary>
    /// 更新指挥
    /// </summary>
    private void RefreshCommander(uint id)
    {
        ClearUnits();
        EventManager.Instance.Send(EventManager.EventName.TeamEditVAllModelClear);
        _commander = id;

        if (id == NoneID) return;
        var info = CharacterDataInfoManager.Instance.GetCharacterInfo(id);
        if (info == null)
        {
            return;
        }

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

        _provideJob = jobs.ToList();
        // 重置队伍
        ResetUnits();
    }

    #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>
    /// <returns></returns>
    public List<ProvideJob> GetProvideJobs()
    {
        return _provideJob;
    }

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

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

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

    /// <summary>
    /// 获得所有角色 包括指挥官
    /// </summary>
    /// <returns></returns>
    public List<uint> GetAllCharacters()
    {
        var characters = new List<uint>();
        characters.Add(_commander);
        foreach (var id in _characterIDs)
        {
            characters.Add(id);
        }

        return characters;
    }

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

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

    /// <summary>
    /// 判断队伍中是否包含某成员
    /// </summary>
    public bool IsUnitInTeam(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()
    {
        return GetAllCharacters()?.Count ?? 0;
    }

    /// <summary>
    /// 通过ID获取角色列表的索引（包含指挥官） TODO 需联调确定是否正确 
    /// </summary>
    public int GetAllCharacterIdx(uint id)
    {
        var characters = GetAllCharacters();
        if (characters != null && id != NoneID)
            return characters.IndexOf(id);
        return -1;
    }

    /// <summary>
    /// 通过ID获取载具列表的索引 
    /// </summary>
    public int GetVehicleIdx(uint id)
    {
        if (id != NoneID)
            return _vehicleIDs.IndexOf(id);
        return -1;
    }

    /// <summary>
    /// 通过units索引获取载具列表的索引
    /// </summary>
    public int GetVehicleByUnitsIndex(int idx)
    {
        if (idx < 0) return -1;
        var vehicle = _unitIDs[idx];
        return _vehicleIDs.IndexOf(vehicle);
    }

    /// <summary>
    /// 单位是否为角色
    /// </summary>
    public bool IsCharacter(uint id)
    {
        if (id <= 0)
        {
            DebugUtil.LogError("该单位ID错误：{0}", id);
        }

        return CharacterDataInfoManager.Instance.DataDic.ContainsKey(id);
    }

    #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> units)
    {
        if (units is not { Count: > 0 }) return false;

        /*// 获取推荐职业
        var jobs = CharacterDataInfoManager.Instance.GetCharacterInfo(_commander).Cfg.ProvideJob.ToList();
        var index = 0;
        if (jobs.Count != units.Count)
            return false;

        foreach (var unit in units)
        {
            if (jobs[index] == ProvideJob.Job_Unlimited)
            {
                index++;
                continue;
            }

            // 有角色职业不为指挥所提供
            if (CharacterDataInfoManager.Instance.DataDic.ContainsKey(unit))
            {
                var job = CharacterDataInfoManager.Instance.GetCharacterJob(unit);
                if (jobs.All(pJob => (int)pJob != (int)job))
                    return false;
            }

            // 有载具但是不为指挥所提供
            if (VehicleCultivateDataManager.Instance.DataDic.ContainsKey(unit) &&
                !jobs.Contains(ProvideJob.Job_Vehicle))
            {
                return false;
            }
        }*/

        return true;
    }

    /// <summary>
    /// 区分角色与载具
    /// </summary>
    private void PartUnits()
    {
        _characterIDs = new List<uint>();
        _vehicleIDs = new List<uint>();
        if (_provideJob is { Count: <= 0 }) return;
        var index = 0;
        foreach (var unit in _unitIDs)
        {
            if (CharacterDataInfoManager.Instance.DataDic.ContainsKey(unit) ||
                (unit == NoneID && _provideJob[index] != ProvideJob.Job_Vehicle))
            {
                //DebugUtil.LogError("添加角色:{0}，其职业是:{1}", unit, _provideJob[index]);
                _characterIDs.Add(unit);
            }

            if (VehicleCultivateDataManager.Instance.DataDic.ContainsKey(unit) ||
                (unit == NoneID && _provideJob[index] == ProvideJob.Job_Vehicle))
            {
                //DebugUtil.LogError("添加载具:{0}，其职业是:{1}", unit, _provideJob[index]);

                _vehicleIDs.Add(unit);
            }

            index++;
        }
    }

    /// <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 ClearUnits()
    {
        _unitIDs.Clear();
        _characterIDs.Clear();
        _vehicleIDs.Clear();
        _provideJob.Clear();
    }


    /// <summary>
    /// 根据推荐职业重置队伍
    /// </summary>
    private void ResetUnits()
    {
        _unitIDs.Clear();
        _characterIDs.Clear();
        _vehicleIDs.Clear();
        foreach (var job in ProvideJobs)
        {
            // DebugUtil.LogError("指挥官更换后，提供的职业有：{0}", job);
            _unitIDs.Add(NoneID);
            if (job == ProvideJob.Job_Vehicle)
            {
                _vehicleIDs.Add(NoneID);
            }
            else
            {
                _characterIDs.Add(NoneID);
            }
        }

        /*
        DebugUtil.LogError("------更换指挥官后-----------");
        foreach (var job in _provideJob)
        {
            DebugUtil.LogError("职业有:{0}", job);
        }

        DebugUtil.LogError("-----------------");*/
    }

    #endregion
}