using NLDPB;
using System;
using PhxhSDK;
using Gameplay;
using Framework;
using System.Linq;
using Gameplay.Net;
using cfg.CharacterCfg;
using Cysharp.Threading.Tasks;
using Gameplay.Character.Utils;
using System.Collections.Generic;
using Gameplay.Common;
using Constants = Framework.Constants;

public class TeamEditStoreData
{
    public int TeamSelectID = 0;
}

public class VehicleSound
{
    private int _vehicleSoundID = -1;

    /// <summary>
    /// 播放载具引擎
    /// </summary>
    public void PlayVehicleSound()
    {
        var team = TeamEditManager.Instance.GetSelectTeam();
        if (team.IsContainsVehicle() && _vehicleSoundID == -1)
        {
            _vehicleSoundID = AudioManager.Instance.PlayAudio(Constants.Sound.TEAM_VEHICLE, loop: true);
        }
        else if (!team.IsContainsVehicle() && _vehicleSoundID != -1)
        {
            CloseVehicleSound();
        }
    }

    /// <summary>
    /// 关闭载具引擎
    /// </summary>
    public void CloseVehicleSound()
    {
        AudioManager.Instance.StopSoundById(_vehicleSoundID);
        _vehicleSoundID = -1;
    }
}

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

    public const int MaxTeamCount = 10;
    private const int DefaultConductorID = 0;
    private const int RedNodeTeam = 70;
    private const string DefaultTeamIndex = "DefaultTeamIndex";

    #endregion

    #region 私有成员变量

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

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

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

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

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

    /// <summary>
    /// 编队红点缓存数据
    /// </summary>
    private TeamRedStorage teamRedStorage;

    /// <summary>
    /// 编队红点信息
    /// </summary>
    private Dictionary<int, RedPointNodeTeam> _redPointNodeTeams;

    /// <summary>
    /// 是否初始化标志
    /// </summary>
    private bool _init;

    #endregion

    #region 成员变量

    public int VehicleBgmID = -1;
    public List<Team> TeamList => _teamList;
    public TeamPreviewNode TeamPreviewNode => _teamPreviewNode;
    public TeamRedStorage TeamRedStorage => teamRedStorage;
    public Dictionary<int, RedPointNodeTeam> RedPointNodeTeams => _redPointNodeTeams;

    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<Team>();
        _teamLegionList = new List<Team>();
        _redPointNodeTeams = new Dictionary<int, RedPointNodeTeam>();
        EventManager.Instance.Register(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
        EventManager.Instance.Register(EventManager.EventName.ActorLeadershipUp, LevelUpToRefreshRedNode);
    }

    void IInitable.Release()
    {
        _teamList = null;

        foreach (var redPointNodeTeam in _redPointNodeTeams)
        {
            RedPointManager.Instance.RemoveDynamicNode(redPointNodeTeam.Value);
        }

        _redPointNodeTeams = null;
        EventManager.Instance.Unregister(EventManager.EventName.TeamEditCreateSucc, OnTeamUpdate);
        EventManager.Instance.Unregister(EventManager.EventName.ActorLeadershipUp, LevelUpToRefreshRedNode);
    }

    #endregion

    #region 对外方法

    /// <summary>
    /// 获取不为空的队伍
    /// </summary>
    public Team GetSelectNotEmptyTeam()
    {
        if (GetSelectTeam().IsMemberEmpty())
        {
            foreach (var team in _teamList)
            {
                if (!team.IsMemberEmpty())
                    return team;
            }
        }

        return GetSelectTeam();
    }

    /// <summary>
    /// 获取当前选择队伍
    /// </summary>
    public Team GetSelectTeam(bool isLegionBattle = false)
    {
        if (_teamList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队，返回测试编队");
            return GetTestTeam();
        }

        _selectTeam = isLegionBattle ? GetLegionTeamByIndex (_selectLegionTeamIdx): GetTeamByIndex(_selectTeamIdx);
        return _selectTeam;
    }

    /// <summary>
    /// 根据索引获取队伍
    /// </summary>
    public Team GetTeamByIndex(int idx, bool isLegionBattle = false)
    {
        if (isLegionBattle)
        {
            return GetLegionTeamByIndex(idx);
        }
        if (_teamList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队，返回测试编队");
            return GetTestTeam();
        }

        return _teamList.FirstOrDefault(team => team.TeamIndex == idx);
    }
    
    public Team GetLegionTeamByIndex(int idx)
    {
        if (_teamLegionList.Count == 0)
        {
            DebugUtil.LogError("当前没有任何编队，返回测试编队");
            return GetTestTeam();
        }

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

    /// <summary>
    /// 设置当前选择的队伍
    /// </summary>
    public void SetSelectTeam(int idx, bool isLegionBattle = false)
    {
        try
        {
            if (isLegionBattle)
            {
                _selectLegionTeamIdx = idx;
                return;
            }
            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;
            EventManager.Instance.Send(EventManager.EventName.SetSelectTeam);
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.SetSelectTeam Error, Team Index:{0}, Exception:{1}", idx, e);
        }
    }

    /// <summary>
    /// 检查默认队伍是否合法
    /// </summary>
    public bool CheckTeamIsLegal(Team team)
    {
        return team.TeamIndex != 0 || !team.IsMemberEmpty();
    }

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

            NetHelper.CreateTeam((uint)team.TeamIndex, team.Name, (uint)team.IconNumber, team.Commander,
                team.GetUnitIDs(), team.GetPlayerSkillIDs());
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.SaveTeam Error, Exception:{0}", e);
        }
    }

    /// <summary>
    /// 判断两只队伍是否相同
    /// </summary>
    public bool SameTeamContent(Team team1, Team team2)
    {
        try
        {
            if (!team1.Name.Equals(team2.Name)) return false;
            if (team1.IconNumber != team2.IconNumber) return false;
            if (team1.Commander != team2.Commander) return false;

            var units1 = team1.GetUnitIDs();
            var units2 = team2.GetUnitIDs();
            for (var i = 0; i < units1.Count; i++)
            {
                if (units1[i] != units2[i])
                    return false;
            }

            return true;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.SameTeamContent Error, Exception:{0}", e);
            return false;
        }
    }

    /// <summary>
    /// 通过索引更换Team
    /// </summary>
    public void ChangeTeamByIndex(int idx, Team team)
    {
        if (idx < 0 || idx >= _teamList.Count) return;
        _teamList[idx] = new Team(idx, team.Name, team.IconNumber, team.Commander, team.GetUnitIDs(),
            team.GetPlayerSkillIDs());
    }

    /// <summary>
    /// 通过索引清空恢复队伍
    /// </summary>
    public void EmptyTeamByIndex(int idx)
    {
        if (idx < 0 || idx >= _teamList.Count) return;
        var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + idx);
        _teamList[idx] = new Team(idx, defaultName, Team.DefaultMark, 0, new List<uint>(),
            new uint[] { Team.DefaultSkillID });
    }

    /// <summary>
    /// 检查成员是否已经上阵
    /// </summary>
    public bool IsUnitInAllTeam(uint id)
    {
        if (id == Team.NoneID)
        {
            DebugUtil.LogError("检查角色ID错误:{0}", id);
            return false;
        }

        foreach (var team in _teamList)
        {
            if (team.IsInTeam(id))
                return true;
        }

        return false;
    }

    #endregion

    #region 红点

    /// <summary>
    /// 通过队伍索引关闭队伍红点
    /// </summary>
    public void CloseTeamShowRedPoint(int index)
    {
        var team = GetTeamByIndex(index);
        if (team == null || !team.ShowRedNode)
            return;
        team.ShowRedNode = false;
        if (teamRedStorage.teamIds.Contains(index))
            teamRedStorage.teamIds.Remove(index);
        StorageMgr.Instance.SyncForce = true;
        EventManager.Instance.Send(EventManager.EventName.TeamRedRefresh);
    }

    /// <summary>
    /// 通过队伍索引获取红点
    /// </summary>
    public RedPointNodeTeam GetTeamRedNode(int index)
    {
        return _redPointNodeTeams.GetValueOrDefault(index);
    }

    private void LevelUpToRefreshRedNode()
    {
        foreach (var team in _teamList)
        {
            if (team.CheckNeedShowRedNode())
            {
                if (!teamRedStorage.teamIds.Contains(team.TeamIndex))
                    teamRedStorage.teamIds.Add(team.TeamIndex);
            }
        }

        StorageMgr.Instance.SyncForce = true;
    }

    private void RefreshOtherRedNode()
    {
        var needRefresh = false;
        foreach (var team in _teamList)
        {
            if (team.ShowRedNode && !team.CheckNeedShowRedNode() && teamRedStorage.teamIds.Contains(team.TeamIndex))
            {
                teamRedStorage.teamIds.Remove(team.TeamIndex);
                needRefresh = true;
            }
        }

        if (needRefresh)
            EventManager.Instance.Send(EventManager.EventName.TeamRedRefresh);
    }

    #endregion

    #region 内部函数

    /// <summary>
    /// 刷新队伍列表
    /// </summary>
    private void RefreshOwnTeams()
    {
        try
        {
            _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);
                    // 获取队伍不为空
                    if (info != null)
                    {
                        var name = info.Name;
                        if (string.IsNullOrEmpty(name))
                        {
                            name = defaultName;
                        }

                        // 技能暂时处理为默认技能
                        uint[] skillIDs = { Team.DefaultSkillID };
                        CreateTeam(i, name, (int)info.Icon, info.Conductor, info.UnitIDs, skillIDs);
                    }
                    else
                    {
                        uint[] skillIDs = { Team.DefaultSkillID };
                        CreateTeam(i, defaultName, Team.DefaultMark, DefaultConductorID, new List<uint>(),
                            skillIDs);
                    }
                }
            }

            RefreshOtherRedNode();

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

            _selectTeamIdx = storeIdx;

            var legionTeamInfos = partTeam.GetLegion();
            if (legionTeamInfos != null)
            {
                for (var i = 0; i < legionTeamInfos.Length; i++)
                {
                    var info = legionTeamInfos[i];
                    var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + i);
                    // 获取队伍不为空
                    if (info != null)
                    {
                        var name = info.Name;
                        if (string.IsNullOrEmpty(name))
                        {
                            name = defaultName;
                        }

                        // 技能暂时处理为默认技能
                        uint[] skillIDs = { Team.DefaultSkillID };
                        CreateLegionTeam(i, name, (int)info.Icon, info.Conductor, info.UnitIDs, skillIDs);
                    }
                    else
                    {
                        uint[] skillIDs = { Team.DefaultSkillID };
                        CreateLegionTeam(i, defaultName, Team.DefaultMark, DefaultConductorID, new List<uint>(),
                            skillIDs);
                    }
                }
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.RefreshOwnTeams Error,  Exception:{0}", e);
        }
    }

    /// <summary>
    /// 内部创建Team
    /// </summary>
    private void CreateTeam(int idx, string name, int icon, uint conductor, List<uint> unitIDs, uint[] playerSkillIDs)
    {
        if (icon == Team.NoneID)
            icon = Team.DefaultMark;

        var team = new Team(idx, name, icon, conductor, unitIDs, playerSkillIDs);
        // 刷新红点信息
        if (teamRedStorage != null && teamRedStorage.teamIds.Contains(idx))
            team.ShowRedNode = true;

        _teamList.Add(team);
    }
    
    /// <summary>
    /// 内部创建Legion Team
    /// </summary>
    private void CreateLegionTeam(int idx, string name, int icon, uint conductor, List<uint> unitIDs, uint[] playerSkillIDs)
    {
        if (icon == Team.NoneID)
            icon = Team.DefaultMark;

        var team = new Team(idx, name, icon, conductor, unitIDs, playerSkillIDs);
        // 刷新红点信息
        if (teamRedStorage != null && teamRedStorage.teamIds.Contains(idx))
            team.ShowRedNode = true;

        _teamLegionList.Add(team);
    }

    #endregion

    #region 模型展示相关

    /// <summary>
    /// 加载队伍成员展示节点
    /// </summary>
    public async UniTask LoadTeamPreviewNode(int teamIdx, string openPanel = "")
    {
        try
        {
            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);
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.LoadTeamPreviewNode Error, Exception:{0}", e);
        }
    }

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

            previewNodeOpenList.Remove(releasePanel);

            if (_teamPreviewNode && previewNodeOpenList.Count <= 0)
            {
                DoReleaseTeamPreviewNode();
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.ReleaseTeamPreviewNode Error, Exception:{0}", e);
        }
    }

    /// <summary>
    /// 强制释放
    /// </summary>
    public void CompulsoryReleasePreviewNode()
    {
        try
        {
            previewNodeOpenList.Clear();
            DoReleaseTeamPreviewNode();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.CompulsoryReleasePreviewNode Error, Exception:{0}", e);
        }
    }

    /// <summary>
    /// 通过队伍索引加载队伍展示节点
    /// </summary>
    private async UniTask LoadNewTeamPreviewNode(int teamIdx)
    {
        try
        {
            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.Refresh();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.LoadNewTeamPreviewNode Error, TeamIndex:{1}, Exception:{0}", e,
                teamIdx);
        }
    }

    /// <summary>
    /// 通过队伍索引刷新队伍展示节点
    /// </summary>
    private async void RefreshPreviewNode(int teamIdx)
    {
        try
        {
            if (!_teamPreviewNode) return;
            Team team;
            if (UI_TeamAndSkillSelectController.CurTab == UI_TeamAndSkillSelectController.ETab.LegionBattle)
            {
                team = _teamLegionList[teamIdx];
            }
            else
            {
                team = _teamList[teamIdx];
            }
            
            if (team == null) return;

            var charIDs = team.GetAllCharacters().ToArray();
            var vehicleIDs = team.GetVehicleIDs().ToArray();
            _teamPreviewNode.SetData(teamIdx, charIDs, vehicleIDs);
            await _teamPreviewNode.Refresh();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.RefreshPreviewNode Error, Exception:{0}", e);
        }
    }

    /// <summary>
    /// 释放展示节点
    /// </summary>
    private void DoReleaseTeamPreviewNode()
    {
        try
        {
            if (_teamPreviewNode)
            {
                TeamPreviewNode.ReleaseNode(_teamPreviewNode);
                _teamPreviewNode = null;
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.DoReleaseTeamPreviewNode Error, Exception:{0}", e);
        }
    }

    #endregion

    #region 事件监听

    private void OnTeamUpdate()
    {
        RefreshOwnTeams();
        EventManager.Instance.Send(EventManager.EventName.TeamUpdate);
        if (!_init)
        {
            teamRedStorage = StorageMgr.Instance.GetStorage<TeamRedStorage>(Constants.Storage.TeamRed);
            teamRedStorage ??= new TeamRedStorage();
            foreach (var teamIdx in teamRedStorage.teamIds)
            {
                var team = GetTeamByIndex(teamIdx);
                team.ShowRedNode = true;
            }

            for (var i = 0; i < MaxTeamCount; i++)
            {
                var redPointNodeTeam =
                    RedPointManager.Instance.AddDynamicNode(cfg.RedPoint.NodeType.Team, RedNodeTeam, i) as
                        RedPointNodeTeam;
                _redPointNodeTeams[i] = redPointNodeTeam;
            }

            _init = true;
        }
    }

    #endregion

    #region 测试队伍

    public Team GetTestTeam()
    {
        try
        {
            var defalutIndex = 0;
            var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + defalutIndex);
            var defaultIcon = TableManager.Instance.Tables.GlobalConfig.DefaultTeamIcon;
            var defaultCommander = (uint)TableManager.Instance.Tables.GlobalConfig.DefaultCommander;
            var unitIDs = TableManager.Instance.Tables.GlobalConfig.DefaultUnitIDs.Select(id => (uint)id).ToList();
            var skills = new uint[] { 911, 0, 0 };
            return new Team(defalutIndex, defaultName, defaultIcon, defaultCommander, unitIDs, skills);
        }
        catch (Exception e)
        {
            DebugUtil.LogError("TeamEditManager.GetTestTeam Error, Exception:{0}", e);
            return null;
        }
    }

    #endregion
    
    #region 军团战编队

    //编队数据
    private List<Team> _teamLegionList;
    public List<Team> TeamLegionList => _teamLegionList;

    private int _selectLegionTeamIdx;

    public int SelectLegionTeamIdx
    {
        get
        {
            return _selectLegionTeamIdx;
        }

        set
        {
            _selectLegionTeamIdx = value;
        }
    }

    /// <summary>
    /// 通过索引清空恢复队伍
    /// </summary>
    public void EmptyLegionTeamByIndex(int idx)
    {
        if (idx < 0 || idx >= _teamLegionList.Count) return;
        var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + idx);
        _teamLegionList[idx] = new Team(idx, defaultName, Team.DefaultMark, 0, new List<uint>(),
            new uint[] { Team.DefaultSkillID });
    }

    public void UpdateLegionTeam()
    {
        for (int i = 0; i < 3; i++)
        {
            var defaultName = CommonUtils.GetLocalizeText("team_edit_default" + i);
            _teamLegionList.Add(new Team(i, defaultName, Team.DefaultMark, 0, new List<uint>(),
                new uint[] { Team.DefaultSkillID }));
        }
        
    }
    #endregion
}

/// <summary>
/// 队列类
/// </summary>
public class Team
{
    public const int ConductorIndex = -1;
    public const uint NoneID = 0;
    public const int DefaultMark = 510001;
    public const int DefaultSkillID = 911;
    public const int MinVehicleLeadership = 20;
    public const int MinCharacterLeadership = 13;

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

    #endregion

    #region 成员变量

    public bool ShowRedNode = false;

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

    public uint Commander
    {
        get => _commander;
    }

    public string Name
    {
        get => _name;
    }

    public int IconNumber
    {
        get => _icon;
        set => _icon = value;
    }

    public int TeamIndex
    {
        get => _teamIdx;
    }

    public int AllLeaderShip
    {
        get => _allLeadership;
    }

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

    #endregion

    #region 构造函数

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

            // 指挥合法
            if (CheckConductorLegal(_commander) && unitIDs != null && unitIDs.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();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team 构造函数 Error, Team Index:{0}, name:{1}, icon:{2}, commander:{3}, Exception:{4}",
                teamIdx, name, icon, commander, e);
        }
    }

    private Team()
    {
    }

    #endregion

    #region 编辑队伍成员

    /// <summary>
    /// 上阵角色
    /// </summary>
    /// <param name="idx">角色在队伍中的索引</param>
    /// <param name="id">角色ID</param>
    public async void AddCharacter(int idx, uint id = 0)
    {
        try
        {
            if (_unitIDs == null || _characterIDs == null) return;
            if (idx == ConductorIndex)
            {
                AddCommander(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;

            RefreshSpendLeadership();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoCharacterUp, CharacterIndex:{0}, CharacterID:{1}, Exception:{2}", idx, id, e);
        }
    }

    /// <summary>
    /// 通过索引下阵角色 (直接点空角色)
    /// </summary>
    /// <param name="idx">角色在队伍中的索引</param>
    public void RemoveCharacter(int idx)
    {
        try
        {
            if (idx == ConductorIndex)
            {
                RemoveCommander();
                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;

            RefreshSpendLeadership();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoCharacterDown with Index, CharacterIndex:{0}, Exception:{1}", idx, e);
        }
    }

    /// <summary>
    /// 通过ID下阵角色 (更换)
    /// </summary>
    /// <param name="id">角色ID</param>
    public void RemoveCharacter(uint id)
    {
        try
        {
            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;
            RefreshSpendLeadership();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoCharacterDown with ID, CharacterID:{0}, Exception:{1}", id, e);
        }
    }

    /// <summary>
    /// 上阵载具
    /// </summary>
    /// <param name="idx">载具在队伍中的索引 载具排在角色后面</param>
    /// <param name="id">载具ID</param>
    public void AddVehicle(int idx, uint id = 0)
    {
        try
        {
            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;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoVehicleUp, VehicleIndex:{0}, VehicleID:{1}, Exception:{2}", idx, id, e);
        }
    }

    /// <summary>
    /// 通过索引下阵载具 （直接点空载具）
    /// </summary>
    /// <param name="idx">载具在队伍中的索引</param>
    public void RemoveVehicle(int idx)
    {
        try
        {
            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;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoVehicleDown with Index, VehicleIndex:{0}, Exception:{1}", idx, e);
        }
    }

    /// <summary>
    /// 通过ID下阵载具 (更换)
    /// </summary>
    /// <param name="id">载具ID</param>
    public void RemoveVehicle(uint id)
    {
        try
        {
            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;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoVehicleDown with ID, VehicleIndex:{0}, Exception:{1}", id, e);
        }
    }

    private async void AddCommander(uint id)
    {
        try
        {
            _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();

            RefreshSpendLeadership();

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

            /*DebugUtil.LogError("------上指挥官后-----------");
            foreach (var job in _unitIDs)
            {
                DebugUtil.LogError("有:{0}", job);
            }
            DebugUtil.LogError("-----------------");*/
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoCommanderUp, ID:{0}, Exception:{1}", id, e);
        }
    }

    /// <summary>
    /// 下阵指挥官
    /// </summary>
    private void RemoveCommander()
    {
        try
        {
            ClearUnits();
            EventManager.Instance.Send(EventManager.EventName.TeamEditAllModelClear);
            _commander = NoneID;
            RefreshSpendLeadership();
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.DoCommanderUp, Exception:{0}", e);
        }
    }

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

            _allLeadership = 0;
            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);
                }
            }

            EventManager.Instance.Send(EventManager.EventName.TeamLeadershipUpdate);
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.RefreshSpendLeadership， Exception:{0}", e);
        }
    }

    #endregion

    #region 技能相关

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

        if (index >= _playerSkillIDs.Length)
        {
            DebugUtil.LogError("传入索引越界错误，index:{0}", index);
            return;
        }

        _playerSkillIDs[index] = skillId;
    }

    #endregion

    #region 修改队伍属性相关

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

    #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> GetUintIDsIncludeCommander()
    {
        try
        {
            var allUints = new List<uint> { _commander };
            allUints.AddRange(_vehicleIDs);
            allUints.AddRange(_characterIDs);
            return allUints;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.GetAllCharacters Error, Exception:{0}", e);
            return null;
        }
    }

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

    /// <summary>
    /// 获取队伍角色 (不包含指挥官)
    /// </summary>
    public List<uint> GetAllCharactersButCommander()
    {
        return _characterIDs;
    }

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

            return characters;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.GetAllCharacters Error, Exception:{0}", e);
            return null;
        }
    }

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

    /// <summary>
    /// 队伍领导力是否超过等级领导力
    /// </summary>
    /// <returns></returns>
    public bool IsOverLeadership()
    {
        var level = Actor.Instance.Base.GetProp(ActorProp.Level);
        var actorCfg = ActorLevelTableHelper.Instance.Get((int)level);
        var leadership = actorCfg.Leadership;
        return leadership < _allLeadership;
    }

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

    /// <summary>
    /// 判断队伍中是否包含某成员(含指挥)
    /// </summary>
    public bool IsInTeam(uint id)
    {
        if (id == _commander)
        {
            return true;
        }

        return _unitIDs.Contains(id);
    }

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

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

        return false;
    }

    /// <summary>
    /// 获取所有角色数量
    /// </summary>
    public int GetAllCharacterCount()
    {
        return GetAllCharacters()?.Count ?? 0;
    }

    /// <summary>
    /// 通过ID获取角色在所有单位中的索引 
    /// </summary>
    public int GetCharacterIdxInAllUnits(uint id)
    {
        if (id != NoneID)
            return GetUintIDsIncludeCommander().IndexOf(id);
        return -1;
    }

    /// <summary>
    /// 通过ID获取载具在所有单位中的索引 
    /// </summary>
    public int GetVehicleIdxInAllUnits(uint id)
    {
        if (id != NoneID)
            return GetUintIDsIncludeCommander().IndexOf(id);
        return -1;
    }

    /// <summary>
    /// 通过ID获取角色列表的索引（包含指挥官）
    /// </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 GetVehicleIdxInVehicles(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 IsEmptyCharacter(int idx)
    {
        try
        {
            if (idx == -1) return _commander == NoneID;
            if (idx >= 0 && idx < _characterIDs.Count)
            {
                return _characterIDs[idx] == NoneID;
            }

            return true;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.IsEmptyCharacter Error, Exception:{0}", e);
            return false;
        }
    }

    public bool IsContainsVehicle()
    {
        foreach (var vehicle in _vehicleIDs)
        {
            if (vehicle != NoneID)
                return true;
        }

        return false;
    }

    public Team Clone()
    {
        try
        {
            return new Team(
                _teamIdx,
                _name,
                _icon,
                _commander,
                new List<uint>(_unitIDs.Select(id => id)),
                (uint[])_playerSkillIDs.Clone()
            )
            {
                // 深拷贝其他字段
                _characterIDs = new List<uint>(_characterIDs.Select(id => id)),
                _vehicleIDs = new List<uint>(_vehicleIDs.Select(id => id)),
                _allLeadership = _allLeadership,
                _provideJob = new List<ProvideJob>(_provideJob.Select(job => job))
            };
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.Clone Error, Exception:{0}", e);
            return null;
        }
    }

    /// <summary>
    /// 清除队伍(但不保存)
    /// </summary>
    public void ClearTeam()
    {
        try
        {
            _commander = NoneID;

            for (int i = 0; i < _unitIDs.Count; ++i)
            {
                _unitIDs[i] = NoneID;
            }

            for (int i = 0; i < _characterIDs.Count; ++i)
            {
                _characterIDs[i] = NoneID;
            }

            for (int i = 0; i < _vehicleIDs.Count; ++i)
            {
                _vehicleIDs[i] = NoneID;
            }

            EventManager.Instance.Send(EventManager.EventName.TeamClear);
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.ClearTeam Error, Exception:{0}", e);
        }
    }

    #endregion

    #region 红点

    public bool CheckNeedShowRedNode()
    {
        if (IsMemberEmpty())
        {
            ShowRedNode = false;
            return false;
        }

        var level = Actor.Instance.Base.GetProp(ActorProp.Level);
        var actorCfg = ActorLevelTableHelper.Instance.Get((int)level);
        var leadership = actorCfg.Leadership;
        var remainLeadership = leadership - _allLeadership;
        for (var i = 0; i < _unitIDs.Count; i++)
        {
            if (_unitIDs[i] == NoneID)
            {
                if (remainLeadership > MinVehicleLeadership && _provideJob[i] == ProvideJob.ProvideJob_Vehicle &&
                    VehicleCanAdd())
                {
                    // DebugUtil.LogError("队伍{0}可以增加一个车", TeamIndex);
                    ShowRedNode = true;

                    return true;
                }

                if (remainLeadership > MinCharacterLeadership && CharacterCanAdd(_provideJob[i]))
                {
                    // DebugUtil.LogError("队伍{0}可以增加一个 {1}", TeamIndex, _provideJob[i]);
                    ShowRedNode = true;
                    return true;
                }
            }
        }

        ShowRedNode = false;
        return false;
    }

    private bool CharacterCanAdd(ProvideJob provideJob)
    {
        var characterDataInfos = CharacterDataInfoManager.Instance.DataList;
        var job = CharacterDataHelper.ProvideJobToNormalJob(provideJob);

        foreach (var character in characterDataInfos)
        {
            if (provideJob == ProvideJob.ProvideJob_Unlimited)
            {
                if (!TeamEditManager.Instance.IsUnitInAllTeam(character.ID))
                    return true;
            }
            else
            {
                if (job == character.Cfg.Job && !TeamEditManager.Instance.IsUnitInAllTeam(character.ID))
                    return true;
            }
        }

        return false;
    }

    private bool VehicleCanAdd()
    {
        var vehicleDataInfos = VehicleCultivateDataManager.Instance.DataList;

        foreach (var vehicle in vehicleDataInfos)
        {
            if (!TeamEditManager.Instance.IsUnitInAllTeam(vehicle.nID))
                return true;
        }

        return false;
    }

    #endregion

    #region 内部函数

    /// <summary>
    /// 检查指挥官是否合法
    /// </summary>
    private bool CheckConductorLegal(uint conductorID)
    {
        try
        {
            if (conductorID == NoneID) return false;
            var info = CharacterDataInfoManager.Instance.GetCharacterInfo(conductorID);
            if (info == null)
                return false;
            return info.Cfg.Job == Ejob.Job_Commander;
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.CheckConductorLegal, CommanderID:{0}, Error, Exception:{1}", conductorID, e);
            return false;
        }
    }

    /// <summary>
    /// 检查队伍成员是否合法
    /// </summary>
    private bool CheckTeamLegal(List<uint> units)
    {
        return units != null && units.Count > 0;
    }

    /// <summary>
    /// 区分角色与载具
    /// </summary>
    private void PartUnits()
    {
        try
        {
            _characterIDs = new List<uint>();
            _vehicleIDs = new List<uint>();
            if (_provideJob == null || _provideJob.Count <= 0) return;
            var index = 0;
            foreach (var unit in _unitIDs)
            {
                if (index >= _provideJob.Count)
                {
                    continue;
                }

                if (CharacterDataInfoManager.Instance.DataDic.ContainsKey(unit) ||
                    (unit == NoneID && _provideJob[index] != ProvideJob.ProvideJob_Vehicle))
                {
                    //DebugUtil.LogError("添加角色:{0}，其职业是:{1}", unit, _provideJob[index]);
                    _characterIDs.Add(unit);
                }

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

                    _vehicleIDs.Add(unit);
                }

                index++;
            }
        }
        catch (Exception e)
        {
            DebugUtil.LogError("Team.PartUnits Error, Exception:{0}", e);
        }
    }

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

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

    #endregion
}