using LitJson;
using System;
using System.Collections.Generic;
using System.Linq;
using vnxbqy.UI;


public class CrossServerGodBattleFieldAssortModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
{
    public readonly uint FuncMapID = 32060;                     //古神战场组队功能地图ID
    public readonly uint FuncMapEx = 0;
    public readonly byte QueryCount = 20;                       //查询条数

    //当前展示中的类型
    public uint HaveSpace = 1;                         // 是否只查看有空位置的队伍
    public uint IDLimitType = 0;                       // ID限制类型：1-同仙盟队长；2-同ServerGroupID队长；3-同ServerID队长
    //<索引,<队伍ID,队伍信息>> 所有队伍信息字典
    //索引 = FuncMapID * 1000 + FuncMapEx     分辨是哪个功能的 古神战场组队是32060000
    Dictionary<uint, Dictionary<uint, AssortTeamInfo>> assortTeamInfoDict = new Dictionary<uint, Dictionary<uint, AssortTeamInfo>>();
    //<索引,<类型，队伍ID列表>> 队伍信息的所属类型
    //类型 = HaveSpace * 1000 + IDLimitType   
    Dictionary<uint, Dictionary<uint, List<uint>>> assortFindTypeTeamIdDict = new Dictionary<uint, Dictionary<uint, List<uint>>>();
    Dictionary<uint, PlayerOnlineStateInfo> playerOnlineStateInfoDict = new Dictionary<uint, PlayerOnlineStateInfo>();

    public uint StartIndex;         // 查看的起始索引， 默认0
    public byte QueryCnt;           // 查看条数，默认20，最大不超过100
    public byte SearchLen;
    public string SearchMsg;        // 指定搜索时有用，可搜索指定队伍ID或模糊搜索队伍名称，搜索时返回最多QueryCnt个数的队伍
    public uint LoopIndex;          // 服务器检索到的索引，列表下拉时下一个查询包的StartIndex从这个LoopIndex开始
    public byte TeamCount;          // 如果返回的队伍数小于QueryCnt，代表服务器已经没有满足条件的队伍了，列表再下拉时不再发查询包

    public bool isOnlyServerGroupIDLeader = false;              //是否经查看自己服务器的队长    
    public bool isAutoJoin = false;                             //是否允许自动加入    
    public bool isSendB924Pack = false;
    public long nowPowerNum;                                    //玩家设定多少战力才能加入
    public int lastWorldChannelTime;                               //上次点击世界频道按钮的时间
    public int lastCrossServiceChannelTime;                       //上次点击跨服频道按钮的时间
    public int worldChannelTimeCD;                               //上次点击世界频道按钮的时间,秒
    public int crossServiceChannelTimeCD;                       //上次点击跨服频道按钮的时间,秒

    public bool isDisplayRedPoint = true;

    public event Action UpdateQueryPlayerFuncTeamRetInfoEvent;  //玩家没有队伍
    public event Action UpdateTeamInfoEvent;                    //队伍信息更新
    public event Action UpdateFindInfoEvent;                    //队伍查找信息更新
    public event Action UpdateTeamDissolveEvent;                //队伍销毁
    public event Action UpdatePlayerOnlineStateInfoEvent;       //玩家在线状态变化

    public event Action AddScrollerEvent;                    //增加项

    Redpoint entranceRedPoint = new Redpoint(21304, MainRedDot.CrossServerGodBattleFieldAssort);                        //队伍入口红点
    Redpoint manageRedPoint = new Redpoint(MainRedDot.CrossServerGodBattleFieldAssort, MainRedDot.CrossServerGodBattleFieldAssort * 10 + 1);     //申请审理按钮红点
    DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }
    RankModel rankModel { get { return ModelCenter.Instance.GetModel<RankModel>(); } }

    public override void Init()
    {
        rankModel.onRankRefresh += UpdatePlayerBillboardEvent;
        ILCrossServerModel.Instance.onSelectUpdate += OnSelectUpdate;
        dailyQuestModel.dailyQuestProgressUpdateEvent += DailyQuestProgressUpdateEvent;
        worldChannelTimeCD = int.Parse(FuncConfigConfig.Get("GodBattleFieldAssort").Numerical1);
        crossServiceChannelTimeCD = int.Parse(FuncConfigConfig.Get("GodBattleFieldAssort").Numerical2);
    }

    public override void UnInit()
    {
        rankModel.onRankRefresh -= UpdatePlayerBillboardEvent;
        ILCrossServerModel.Instance.onSelectUpdate -= OnSelectUpdate;
        dailyQuestModel.dailyQuestProgressUpdateEvent -= DailyQuestProgressUpdateEvent;
    }

    public void OnBeforePlayerDataInitialize()
    {
        //清除所有封包
        assortTeamInfoDict.Clear();
        assortFindTypeTeamIdDict.Clear();
        //选项赋初始值
        isOnlyServerGroupIDLeader = false;
        isSendB924Pack = false;
        isDisplayRedPoint = true;
    }

    public void OnPlayerLoginOk()
    {
        LoadAllTime();
        LoadPowerNum();
        isAutoJoin = LocalSave.GetBool(StringUtility.Contact("gszczd_toggle1_", PlayerDatas.Instance.baseData.PlayerID));
        TrySendQueryPlayerFuncTeam();
    }

    //保证只发一次B924包
    public void TrySendQueryPlayerFuncTeam()
    {
        if (isSendB924Pack)
            return;
        //没开古神战场
        if (!FuncOpen.Instance.IsFuncOpen(208))
            return;
        SendQueryPlayerFuncTeam(FuncMapID);
        isSendB924Pack = true;
    }

    //尝试获得指定索引的所有队伍字典
    public bool TryGetTeamInfoDict(out Dictionary<uint, AssortTeamInfo> teamInfoDict)
    {
        teamInfoDict = null; // 初始化输出参数为 null
        uint index = FuncMapID * 1000 + FuncMapEx;
        if (assortTeamInfoDict.IsNullOrEmpty())
            return false;
        if (!assortTeamInfoDict.TryGetValue(index, out teamInfoDict))
            return false;
        return true;
    }

    //尝试获得古神战场的所有队伍类型信息
    public bool TryGetTeamTypeDict(out Dictionary<uint, List<uint>> teamTypeDict)
    {
        teamTypeDict = null; // 初始化输出参数为 null
        uint index = FuncMapID * 1000 + FuncMapEx;
        if (assortFindTypeTeamIdDict.IsNullOrEmpty())
            return false;
        if (!assortFindTypeTeamIdDict.TryGetValue(index, out teamTypeDict))
            return false;
        return true;
    }

    //尝试获取指定类型的队伍id列表
    public bool TryGetTeamTypeList(uint haveSpace, uint iDLimitType, out List<uint> teamTypeList)
    {
        teamTypeList = null;
        if (!TryGetTeamTypeDict(out Dictionary<uint, List<uint>> teamTypeDict))
            return false;
        uint type = haveSpace * 1000 + iDLimitType;
        if (!teamTypeDict.TryGetValue(type, out teamTypeList))
            return false;
        return true;
    }

    //清除寻找队伍指定类型的列表
    public void ClearTeamTypeList()
    {
        if (!TryGetTeamTypeDict(out var teamTypeDict))
            return;
        teamTypeDict.Clear();
    }

    /// <summary>
    /// 获取玩家所在的队伍信息
    /// </summary>
    /// <param name="isCaptainID">玩家是不是所在的队伍的队长</param>
    /// <param name="teamID">玩家所在队伍的teamID</param>
    /// <param name="teamInfo">玩家所在队伍的详细信息</param>
    /// <returns>返回false说明玩家没有队伍</returns>
    public bool TryGetPlayerTeamInfo(out bool isCaptain, out uint teamID, out AssortTeamInfo teamInfo)
    {
        isCaptain = false;
        teamID = 0;
        teamInfo = null;

        if (!TryGetTeamInfoDict(out var teamInfoDict))
            return false;

        var keyArray = teamInfoDict.Keys.ToArray();
        for (int i = 0; i < keyArray.Length; i++)
        {
            uint nowTeamID = keyArray[i];
            var team = teamInfoDict[nowTeamID];
            uint captainID = team.CaptainID;
            var memberDict = team.MemberDict;

            if (memberDict.ContainsKey(PlayerDatas.Instance.baseData.PlayerID))
            {
                isCaptain = captainID == PlayerDatas.Instance.baseData.PlayerID;
                teamID = nowTeamID;
                teamInfo = team;
                return true;
            }
        }

        return false;
    }

    //尝试获得指定teamID的队伍信息
    public bool TryGetTeamInfo(uint teamID, out AssortTeamInfo teamInfo)
    {
        teamInfo = null;
        if (!TryGetTeamInfoDict(out var teamInfoDict))
            return false;
        if (!teamInfoDict.TryGetValue(teamID, out teamInfo))
            return false;
        return true;
    }

    //尝试获得队长信息
    public bool TryGetTeamCaptainMemberInfo(AssortTeamInfo teamInfo, out AssortMemberInfo memberInfo)
    {
        memberInfo = null;
        uint captainID = teamInfo.CaptainID;
        if (teamInfo.MemberDict.IsNullOrEmpty())
            return false;
        if (!teamInfo.MemberDict.TryGetValue(captainID, out memberInfo))
            return false;
        return true;
    }

    //获得指定队伍成员的总战力
    public ulong GetTeamTotalPower(AssortTeamInfo teamInfo)
    {
        if (teamInfo.MemberDict.IsNullOrEmpty())
            return 0;
        ulong result = 0;
        var keyArray = teamInfo.MemberDict.Keys.ToArray();
        for (int i = 0; i < keyArray.Length; i++)
        {
            uint playerId = keyArray[i];
            var members = teamInfo.MemberDict[playerId];
            result += members.FightPower;
        }
        return result;
    }

    public List<uint> GetApplicantSortList(List<uint> list)
    {
        int sortType = FunctionTeamSetConfig.Get((int)FuncMapID).SortType;
        int sortReverse = FunctionTeamSetConfig.Get((int)FuncMapID).SortReverse;
        //按队员总战力排序 倒序
        if (sortType == 1 && sortReverse == 1)
        {
            list.Sort(CmpApplicantTeamByPower);
        }
        //按队员总战力排序 正序
        else if (sortType == 1 && sortReverse == 0)
        {
            list.Sort(CmpApplicantTeamByPower);
            list.Reverse();
        }
        //按队伍创建顺序排序 倒序
        else if (sortType == 0 && sortReverse == 1)
        {
            list.Sort(CmpApplicantTeamByCreateTime);
        }
        //按队伍创建顺序排序 正序
        else
        {
            list.Sort(CmpApplicantTeamByCreateTime);
            list.Reverse();
        }
        return list;
    }

    int CmpApplicantTeamByPower(uint a, uint b)
    {
        ulong fightPower1;
        ulong fightPower2;
        TryGetPlayerTeamInfo(out bool isCaptain, out uint teamID, out AssortTeamInfo teamInfo);
        fightPower1 = teamInfo.ApplicantDict[a].FightPower;
        fightPower2 = teamInfo.ApplicantDict[b].FightPower;
        if (fightPower1 > fightPower2)
        {
            return -1;
        }
        else if (fightPower1 < fightPower2)
        {
            return 1;
        }
        else
        {
            return 0;
        }

    }

    int CmpApplicantTeamByCreateTime(uint a, uint b)
    {
        uint createTime1;
        uint createTime2;
        TryGetPlayerTeamInfo(out bool isCaptain, out uint teamID, out AssortTeamInfo teamInfo);
        createTime1 = teamInfo.CreateTime;
        createTime2 = teamInfo.CreateTime;
        if (createTime1 > createTime2)
        {
            return -1;
        }
        else if (createTime1 < createTime2)
        {
            return 1;
        }
        else
        {
            return 0;
        }

    }
    public List<uint> GetShowList()
    {
        //获得当前的类型的队伍id
        List<uint> teamTypeList;
        if (!TryGetTeamTypeList(HaveSpace, IDLimitType, out teamTypeList))
            teamTypeList = new List<uint>();
        teamTypeList = GetTeamSortList(teamTypeList); // 排序：战力高的在前

        //获得玩家所有正在申请中的队伍
        var requestTeamList = GetPlayerRequestTeam();
        requestTeamList = GetTeamSortList(requestTeamList); // 排序：战力高的在前

        // 从 teamTypeList 中移除所有正在申请中的队伍，并添加到 containsList 中
        for (int i = 0; i < requestTeamList.Count; i++)
        {
            uint teamID = requestTeamList[i];
            if (teamTypeList.Contains(teamID))
            {
                teamTypeList.Remove(teamID);
            }
        }

        // 将正在申请的队伍插入到列表头部，保持排序顺序
        for (int i = requestTeamList.Count - 1; i >= 0; i--)
        {
            uint teamID = requestTeamList[i];
            teamTypeList.Insert(0, teamID);
        }

        return teamTypeList;
    }
    public List<uint> GetTeamSortList(List<uint> list)
    {
        int sortType = FunctionTeamSetConfig.Get((int)FuncMapID).SortType;
        int sortReverse = FunctionTeamSetConfig.Get((int)FuncMapID).SortReverse;
        //按队员总战力排序 倒序
        if (sortType == 1 && sortReverse == 1)
        {
            list.Sort(CmpTeamByPower);
        }
        //按队员总战力排序 正序
        else if (sortType == 1 && sortReverse == 0)
        {
            list.Sort(CmpTeamByPower);
            list.Reverse();
        }
        //按队伍创建顺序排序 倒序
        else if (sortType == 0 && sortReverse == 1)
        {
            list.Sort(CmpTeamByCreateTime);
        }
        //按队伍创建顺序排序 正序
        else
        {
            list.Sort(CmpTeamByCreateTime);
            list.Reverse();
        }
        return list;
    }
    int CmpTeamByPower(uint a, uint b)
    {
        ulong fightPower1;
        ulong fightPower2;
        TryGetTeamInfo(a, out AssortTeamInfo teamInfo1);
        TryGetTeamInfo(b, out AssortTeamInfo teamInfo2);
        fightPower1 = GetTeamTotalPower(teamInfo1);
        fightPower2 = GetTeamTotalPower(teamInfo2);
        if (fightPower1 > fightPower2)
        {
            return -1;
        }
        else if (fightPower1 < fightPower2)
        {
            return 1;
        }
        else
        {
            return 0;
        }

    }

    int CmpTeamByCreateTime(uint a, uint b)
    {
        uint createTime1;
        uint createTime2;
        TryGetTeamInfo(a, out AssortTeamInfo teamInfo1);
        TryGetTeamInfo(b, out AssortTeamInfo teamInfo2);
        createTime1 = teamInfo1.CreateTime;
        createTime2 = teamInfo2.CreateTime;
        if (createTime1 > createTime2)
        {
            return -1;
        }
        else if (createTime1 < createTime2)
        {
            return 1;
        }
        else
        {
            return 0;
        }

    }
    public bool TryGetPlayerRequestTeam(out List<uint> teamInfoList)
    {
        teamInfoList = new List<uint>();
        if (!TryGetTeamInfoDict(out var teamInfoDict))
            return false;
        var keyArray = teamInfoDict.Keys.ToArray();
        for (int i = 0; i < keyArray.Length; i++)
        {
            uint teamID = keyArray[i];
            var team = teamInfoDict[teamID];
            uint captainID = team.CaptainID;
            var applyIDList = team.ApplyIDList;
            if (!applyIDList.IsNullOrEmpty() && applyIDList.Contains(PlayerDatas.Instance.baseData.PlayerID))
            {
                teamInfoList.Add(teamID);
            }
        }
        return false;
    }

    //获取玩家所有正在申请中的队伍ID
    public List<uint> GetPlayerRequestTeam()
    {
        List<uint> result = new List<uint>();
        if (TryGetTeamInfoDict(out var teamInfoDict))
        {
            var keyArray = teamInfoDict.Keys.ToArray();
            for (int i = 0; i < keyArray.Length; i++)
            {
                uint teamID = keyArray[i];
                var team = teamInfoDict[teamID];
                var applyIDList = team.ApplyIDList;
                if (!applyIDList.IsNullOrEmpty() && applyIDList.Contains(PlayerDatas.Instance.baseData.PlayerID))
                {
                    result.Add(teamID);
                }
            }
        }
        return result;
    }

    //这个队伍是否在申请中
    public bool IsRequest(uint teamID)
    {
        if (TryGetTeamInfoDict(out var teamInfoDict))
        {
            var keyArray = teamInfoDict.Keys.ToArray();
            for (int i = 0; i < keyArray.Length; i++)
            {
                uint nowTeamID = keyArray[i];
                if (teamID == nowTeamID)
                {
                    var team = teamInfoDict[teamID];
                    var applyIDList = team.ApplyIDList;
                    if (!applyIDList.IsNullOrEmpty() && applyIDList.Contains(PlayerDatas.Instance.baseData.PlayerID))
                    {
                        return true;
                    }
                }

            }
        }
        return false;
    }

    // 发送B920 创建功能队伍包
    public void SendCreateFuncTeam(uint funcMapID, uint funcMapEx, string teamName, ushort minLV, uint minFightPower, uint minFightPowerEx, byte serverOnly, byte needCheck)
    {
        var pack = new CB920_tagCGCreateFuncTeam();
        pack.FuncMapID = funcMapID;
        pack.FuncMapEx = funcMapEx;
        pack.TeamName = teamName;
        pack.NameLen = (byte)teamName.Length;
        pack.MinLV = minLV;
        pack.MinFightPower = minFightPower;
        pack.MinFightPowerEx = minFightPowerEx;
        pack.ServerOnly = serverOnly;
        pack.NeedCheck = needCheck;
        GameNetSystem.Instance.SendInfo(pack);
    }

    // 发送B921 修改功能队伍包
    public void SendChangeFuncTeam(uint teamID, uint funcMapID, ushort minLV, uint minFightPower, uint minFightPowerEx, byte serverOnly, byte needCheck)
    {
        var pack = new CB921_tagCGChangeFuncTeam();
        pack.TeamID = teamID;
        pack.FuncMapID = funcMapID;
        pack.MinLV = minLV;
        pack.MinFightPower = minFightPower;
        pack.MinFightPowerEx = minFightPowerEx;
        pack.ServerOnly = serverOnly;
        pack.NeedCheck = needCheck;
        GameNetSystem.Instance.SendInfo(pack);
    }

    // 发送B922 功能队伍成员操作
    public void SendFuncTeamMemOP(uint teamID, uint funcMapID, byte oPType, uint oPData = 0)
    {
        var pack = new CB922_tagCGFuncTeamMemOP();
        pack.TeamID = teamID;
        pack.FuncMapID = funcMapID;
        pack.OPType = oPType;
        pack.OPData = oPData;
        GameNetSystem.Instance.SendInfo(pack);
    }

    // 发送B923 查找功能队伍列表
    public void SendQueryFuncTeam(uint funcMapID, uint funcMapEx, uint startIndex, byte queryCnt, byte haveSpace, byte iDLimitType, string searchMsg = "")
    {

        var pack = new CB923_tagCGQueryFuncTeam();
        pack.FuncMapID = funcMapID;
        pack.FuncMapEx = funcMapEx;
        pack.StartIndex = startIndex;
        pack.QueryCnt = queryCnt;
        pack.HaveSpace = haveSpace;
        pack.IDLimitType = iDLimitType;
        pack.SearchMsg = searchMsg;
        pack.SearchLen = (byte)searchMsg.Length;
        GameNetSystem.Instance.SendInfo(pack);
    }

    // 发送B924 查找玩家功能队伍
    public void SendQueryPlayerFuncTeam(uint funcMapID)
    {
        var pack = new CB924_tagCGQueryPlayerFuncTeam();
        pack.FuncMapID = funcMapID;
        GameNetSystem.Instance.SendInfo(pack);
    }

    public void UpdateFuncTeamRefreshInfo(HB920_tagGCFuncTeamRefresh pack)
    {
        uint index = pack.FuncMapID * 1000 + pack.FuncMapEx;

        if (!assortTeamInfoDict.TryGetValue(index, out var assortTeamInfo))
        {
            assortTeamInfo = new Dictionary<uint, AssortTeamInfo>();
            assortTeamInfoDict[index] = assortTeamInfo;
        }

        if (!assortTeamInfo.TryGetValue(pack.TeamID, out var teamInfo))
        {
            teamInfo = new AssortTeamInfo();
            assortTeamInfo[pack.TeamID] = teamInfo;
        }

        // 更新队伍基本信息
        teamInfo.TeamID = pack.TeamID;
        teamInfo.CreateTime = pack.CreateTime;
        teamInfo.FuncMapID = pack.FuncMapID;
        teamInfo.FuncMapEx = pack.FuncMapEx;
        teamInfo.TeamName = pack.TeamName;
        teamInfo.CaptainID = pack.CaptainID;
        teamInfo.MinLV = pack.MinLV;
        teamInfo.MinFightPower = ((ulong)pack.MinFightPowerEx * 100000000) + pack.MinFightPower;
        teamInfo.ServerOnly = pack.ServerOnly;
        teamInfo.NeedCheck = pack.NeedCheck;
        teamInfo.Value1 = pack.Value1;
        teamInfo.Value2 = pack.Value2;

        // 更新成员信息
        if (teamInfo.MemberDict == null)
        {
            teamInfo.MemberDict = new Dictionary<uint, AssortMemberInfo>();
        }
        else
        {
            teamInfo.MemberDict.Clear();
        }

        for (int i = 0; i < pack.MemberList.Length; i++)
        {
            var member = pack.MemberList[i];
            AssortMemberInfo memberInfo = new AssortMemberInfo
            {
                ServerID = member.ServerID,
                PlayerID = member.PlayerID,
                Name = member.Name,
                LV = member.LV,
                Job = member.Job,
                Face = member.Face,
                FacePic = member.FacePic,
                RealmLV = member.RealmLV,
                FightPower = ((ulong)member.FightPowerEx * 100000000) + member.FightPower,
                OfflineValue = member.OfflineValue,
                Value1 = member.Value1,
                Value2 = member.Value2,
            };
            teamInfo.MemberDict[member.PlayerID] = memberInfo;
            UpdateUpdatePlayerOnlineStateInfoDict(member.PlayerID, member.OfflineValue);
        }

        // 更新申请者信息
        if (teamInfo.ApplyIDList == null)
        {
            teamInfo.ApplyIDList = new List<uint>();
        }
        else
        {
            teamInfo.ApplyIDList.Clear();
        }

        for (int i = 0; i < pack.ApplyIDList.Length; i++)
        {
            teamInfo.ApplyIDList.Add(pack.ApplyIDList[i]);
        }

        if (teamInfo.ApplicantDict == null)
        {
            teamInfo.ApplicantDict = new Dictionary<uint, AssortMemberInfo>();
        }
        else
        {
            teamInfo.ApplicantDict.Clear();
        }

        for (int i = 0; i < pack.ApplyInfoList.Length; i++)
        {
            var apply = pack.ApplyInfoList[i];
            AssortMemberInfo applyInfo = new AssortMemberInfo
            {
                ServerID = apply.ServerID,
                PlayerID = apply.PlayerID,
                Name = apply.Name,
                LV = apply.LV,
                Job = apply.Job,
                Face = apply.Face,
                FacePic = apply.FacePic,
                RealmLV = apply.RealmLV,
                FightPower = ((ulong)apply.FightPowerEx * 100000000) + apply.FightPower,
            };
            teamInfo.ApplicantDict[apply.PlayerID] = applyInfo;
        }
        // 触发更新事件
        UpdateTeamInfoEvent?.Invoke();
        UpdateRedPoint();
    }

    public void UpdateQueryPlayerFuncTeamRetInfo(HB921_tagGCQueryPlayerFuncTeamRet pack)
    {
        //public uint FuncMapID;    // 功能地图ID或自定义的活动功能ID
        //public uint TeamID;       // 玩家所属队伍ID，目前只同步0的情况，如果玩家有队伍统一B920封包同步处理
        if (FuncMapID == pack.FuncMapID && pack.TeamID == 0)
        {
            UpdateQueryPlayerFuncTeamRetInfoEvent?.Invoke();
        }
        UpdateRedPoint();
    }
    public void UpdateFindFuncTeamListInfo(HB922_tagGCFuncTeamList pack)
    {
        this.StartIndex = pack.StartIndex;
        this.QueryCnt = pack.QueryCnt;
        this.SearchLen = pack.SearchLen;
        this.SearchMsg = pack.SearchMsg;
        this.LoopIndex = pack.LoopIndex;
        this.TeamCount = pack.TeamCount;

        uint index = pack.FuncMapID * 1000 + pack.FuncMapEx;
        uint type = (uint)pack.HaveSpace * 1000 + pack.IDLimitType;

        if (!assortTeamInfoDict.TryGetValue(index, out var assortTeamInfo))
        {
            assortTeamInfo = new Dictionary<uint, AssortTeamInfo>();
            assortTeamInfoDict[index] = assortTeamInfo;
        }
        if (!assortFindTypeTeamIdDict.TryGetValue(index, out var teamIdListDict))
        {
            teamIdListDict = new Dictionary<uint, List<uint>>();
            assortFindTypeTeamIdDict[index] = teamIdListDict;
        }
        if (!teamIdListDict.TryGetValue(type, out var teamIdList))
        {
            teamIdList = new List<uint>();
            teamIdListDict[type] = teamIdList;
        }
        if (pack.StartIndex == 0)
        {
            teamIdList.Clear();
        }

        for (int i = 0; i < pack.TeamList.Length; i++)
        {
            var key = pack.TeamList[i];
            uint teamID = key.TeamID;

            if (!assortTeamInfo.TryGetValue(teamID, out var teamInfo))
            {
                teamInfo = new AssortTeamInfo();
                assortTeamInfo[teamID] = teamInfo;
            }

            if (!teamIdList.Contains(teamID))
            {
                teamIdList.Add(teamID);
            }

            // 更新 teamInfo 的内容
            teamInfo.CreateTime = key.CreateTime;
            teamInfo.FuncMapEx = key.FuncMapEx;
            teamInfo.TeamName = key.TeamName;
            teamInfo.CaptainID = key.CaptainID;
            teamInfo.MinLV = key.MinLV;
            teamInfo.MinFightPower = ((ulong)key.MinFightPowerEx * 100000000) + key.MinFightPower;
            teamInfo.ServerOnly = key.ServerOnly;
            teamInfo.NeedCheck = key.NeedCheck;
            teamInfo.Value1 = key.Value1;
            teamInfo.Value2 = key.Value2;

            // 更新 ApplyIDList
            if (teamInfo.ApplyIDList == null)
            {
                teamInfo.ApplyIDList = new List<uint>();
            }
            else
            {
                teamInfo.ApplyIDList.Clear();
            }
            for (int j = 0; j < key.ApplyIDList.Length; j++)
            {
                var applyID = key.ApplyIDList[j];
                teamInfo.ApplyIDList.Add(applyID);
            }

            // 更新 MemberDict
            if (teamInfo.MemberDict == null)
            {
                teamInfo.MemberDict = new Dictionary<uint, AssortMemberInfo>();
            }
            else
            {
                teamInfo.MemberDict.Clear();
            }

            for (int j = 0; j < key.MemberList.Length; j++)
            {
                var member = key.MemberList[j];
                AssortMemberInfo memberInfo = new AssortMemberInfo();
                memberInfo.ServerID = member.ServerID;
                memberInfo.PlayerID = member.PlayerID;
                memberInfo.Name = member.Name;
                memberInfo.LV = member.LV;
                memberInfo.Job = member.Job;
                memberInfo.Face = member.Face;
                memberInfo.FacePic = member.FacePic;
                memberInfo.RealmLV = member.RealmLV;
                memberInfo.FightPower = ((ulong)member.FightPowerEx * Constants.ExpPointValue) + member.FightPower;
                memberInfo.Value1 = member.Value1;
                memberInfo.Value2 = member.Value2;
                teamInfo.MemberDict[member.PlayerID] = memberInfo;
            }
        }

        // 触发更新事件
        if (StartIndex == 0)
        {
            UpdateFindInfoEvent?.Invoke();
        }
        else
        {
            AddScrollerEvent?.Invoke();
        }
    }

    public void UpdateFuncTeamDissolveInfo(HB923_tagGCFuncTeamDissolve pack)
    {
        bool isHaveTeam = TryGetPlayerTeamInfo(out bool isCaptain, out uint nowTeamID, out AssortTeamInfo teamInfo);
        if (isHaveTeam && isCaptain)
        {
            isAutoJoin = false;
            nowPowerNum = 0;
            SavePowerNum();
            LocalSave.SetBool(StringUtility.Contact("gszczd_toggle1_", PlayerDatas.Instance.baseData.PlayerID), isAutoJoin);
        }

        uint teamID = pack.TeamID;
        if (TryGetTeamTypeDict(out Dictionary<uint, List<uint>> teamTypeDict))
        {
            var list = teamTypeDict.Keys.ToList();
            for (int i = 0; i < list.Count; i++)
            {
                uint type = list[i];
                var typeList = teamTypeDict[type];
                if (typeList.Contains(teamID))
                {
                    typeList.Remove(teamID);
                }
            }
        }
        if (TryGetTeamInfoDict(out var teamInfoDict) && teamInfoDict.ContainsKey(teamID))
        {
            teamInfoDict.Remove(teamID);
        }
        UpdateTeamDissolveEvent?.Invoke();
        UpdateRedPoint();
    }

    void DailyQuestProgressUpdateEvent(int obj)
    {
        UpdateRedPoint();
    }

    void OnSelectUpdate()
    {
        UpdateRedPoint();
    }

    void UpdatePlayerBillboardEvent(int obj)
    {
        UpdateRedPoint();
    }

    public void UpdateRedPoint()
    {
        entranceRedPoint.state = RedPointState.None;
        manageRedPoint.state = RedPointState.None;

        if (TimeUtility.OpenDay < GeneralDefine.crossServerBattleFieldOpenDay)
        {
            return;
        }

        bool isHaveTeam = TryGetPlayerTeamInfo(out bool isCaptain, out uint teamID, out AssortTeamInfo teamInfo);
        //活动处于开启状况
        if (IsOpenAction())
            return;
        //玩家有队伍 
        if (isHaveTeam)
        {
            //玩家是队长 且 申请列表中有成员
            if (isCaptain && teamInfo.ApplicantDict.Count > 0)
            {
                manageRedPoint.state = RedPointState.Simple;
            }
        }
        //玩家没队伍
        else
        {
            if (isDisplayRedPoint)
            {
                entranceRedPoint.state = RedPointState.Simple;
            }
        }
    }

    public int GetWorldChannelCoolDownEndTime()
    {
        if (lastWorldChannelTime == 0)
            return 0;
        var overTime = TimeUtility.GetTime((uint)(lastWorldChannelTime + worldChannelTimeCD));
        if (TimeUtility.ServerNow > overTime)
            return 0;
        return (int)(overTime - TimeUtility.ServerNow).TotalSeconds;
    }

    public int GetCrossServiceChannelCoolDownEndTime()
    {
        if (lastCrossServiceChannelTime == 0)
            return 0;
        var overTime = TimeUtility.GetTime((uint)(lastCrossServiceChannelTime + crossServiceChannelTimeCD));
        if (TimeUtility.ServerNow > overTime)
            return 0;
        return (int)(overTime - TimeUtility.ServerNow).TotalSeconds;
    }

    public void SetWorldChannelTime()
    {
        lastWorldChannelTime = TimeUtility.AllSeconds;
    }

    public void SetCrossServiceChannelTime()
    {
        lastCrossServiceChannelTime = TimeUtility.AllSeconds;
    }

    public void SaveAllTime()
    {
        int[] arr = new int[2];
        arr[0] = lastWorldChannelTime;
        arr[1] = lastCrossServiceChannelTime;
        LocalSave.SetIntArray(StringUtility.Contact("gszczd_", PlayerDatas.Instance.baseData.PlayerID), arr);
    }

    public void LoadAllTime()
    {
        int[] arr = LocalSave.GetIntArray(StringUtility.Contact("gszczd_", PlayerDatas.Instance.baseData.PlayerID));
        if (arr != null && arr.Length == 2)
        {
            lastWorldChannelTime = arr[0];
            lastCrossServiceChannelTime = arr[1];
        }
        else
        {
            lastWorldChannelTime = 0;
            lastCrossServiceChannelTime = 0;
        }
    }

    public void SavePowerNum()
    {
        int[] arr = new int[2];
        arr[0] = (int)(nowPowerNum / 100000000);
        arr[1] = (int)(nowPowerNum % 100000000);
        LocalSave.SetIntArray(StringUtility.Contact("gszczd_powernum", PlayerDatas.Instance.baseData.PlayerID), arr);
    }

    public void LoadPowerNum()
    {
        int[] arr = LocalSave.GetIntArray(StringUtility.Contact("gszczd_powernum", PlayerDatas.Instance.baseData.PlayerID));
        if (arr != null && arr.Length == 2)
        {
            nowPowerNum = (long)arr[0] * 100000000 + (long)arr[1];
        }
        else
        {
            nowPowerNum = 0;
        }
    }

    public bool IsNoTeamName()
    {
        return FunctionTeamSetConfig.Get((int)FuncMapID).NeedName == 0;
    }

    public bool IsOpenAction()
    {
        if (FunctionTeamSetConfig.Get((int)FuncMapID).OPLimitInAct == 0)
        {
            return false;
        }
        int index = Math.Max(ILCrossServerModel.Instance.selectIndex, 0);
        var int3Config = ILCrossServerModel.Instance.crossBattleFieldOpenTimes[index];
        var state = ILCrossServerModel.Instance.GetActionState(index);
        if (state == 1)
            return true;
        return false;
    }

    public void UpdatePlayerOnlineStateInfo(HB315_tagGCRelatedPlayerOnlineState vNetData)
    {
        UpdateUpdatePlayerOnlineStateInfoDict(vNetData.PlayerID, vNetData.OfflineValue, vNetData.IsCross);
    }

    void UpdateUpdatePlayerOnlineStateInfoDict(uint playerId, uint offlineValue = 1, byte isCross = 0)
    {
        if (!playerOnlineStateInfoDict.TryGetValue(playerId, out var playerOnlineStateInfo))
        {
            playerOnlineStateInfo = new PlayerOnlineStateInfo();
            playerOnlineStateInfoDict[playerId] = playerOnlineStateInfo;
        }
        playerOnlineStateInfo.IsOnline = offlineValue == 0;
        playerOnlineStateInfo.IsCross = isCross == 1;
        playerOnlineStateInfo.OfflineValue = offlineValue >= 1 ? offlineValue : 0;
        UpdatePlayerOnlineStateInfoEvent?.Invoke();
    }
    public bool IsPlayerOnline(uint playerId)
    {
        //没有这个玩家的信息默认视为离线
        if (!playerOnlineStateInfoDict.TryGetValue(playerId, out var playerOnlineStateInfo))
            return false;
        return playerOnlineStateInfo.IsOnline;
    }
}


public class AssortTeamInfo
{
    public uint TeamID;
    public uint CreateTime;         //创建队伍时间戳
    public uint FuncMapID;          // 功能地图ID或自定义的活动功能ID
    public uint FuncMapEx;          // 功能地图扩展，如不同的层级
    public string TeamName;         // 队伍名称
    public uint CaptainID;          //队长ID，队伍ServerID直接取队长的ServerID
    public ushort MinLV;            //最低等级限制
    public ulong MinFightPower;     //最低战力限制
    public byte ServerOnly;         //是否仅本服玩家可加入，0-否，1-是
    public byte NeedCheck;          //是否需要审核
    public uint Value1;             //值1
    public uint Value2;             //值2
    public Dictionary<uint, AssortMemberInfo> MemberDict = new Dictionary<uint, AssortMemberInfo>();       //成员详细信息
    public List<uint> ApplyIDList = new List<uint>();                                                           //申请者PlayerID
    public Dictionary<uint, AssortMemberInfo> ApplicantDict = new Dictionary<uint, AssortMemberInfo>();   //申请者详细信息
}

public class AssortMemberInfo
{
    public uint ServerID;
    public uint PlayerID;
    public string Name;
    public ushort LV;
    public byte Job;
    public uint Face;        //基本脸型
    public uint FacePic;        //头像框
    public ushort RealmLV;
    public ulong FightPower;
    public uint OfflineValue;
    public uint Value1;
    public uint Value2;
}
public class PlayerOnlineStateInfo
{
    public bool IsOnline;           // 是否在线
    public bool IsCross;            // 是否跨服同步的，如果是跨服则离线时间计算时要取跨服服务器时间
    public uint OfflineValue;       // 上次离线时间戳
}