local Team_Model = {}
local private = {}
local EventSystem = require('Event/EventSystem')

local team_operate_pb = require 'Proto.team_operate_pb'
local team_base_pb = require 'Proto.team_base_pb'
local team_match_pb = require 'Proto.team_match_pb'
local team_enum_pb = require 'Proto.team_enum_pb'
local stranger_pb = require 'Proto.stranger_pb'
local other_info_pb = require 'Proto.other_info_pb'

local TeamListMax = DataSheetManager.ConstData:GetDataByID("TeamListMax").IntValue
local TeamShowPerNum = DataSheetManager.ConstData:GetDataByID("TeamShowPerNum").IntValue
local TeamShowMax = DataSheetManager.ConstData:GetDataByID("TeamShowMax").IntValue
local ApplyTeamLeaderTime = DataSheetManager.ConstData:GetDataByID("ApplyTeamLeaderTime").IntValue

Team_Model.StrangerType = {
    All = stranger_pb.All,
    Team = stranger_pb.Team,
    TeamWar = stranger_pb.TeamWar,
    PetBreedChat = stranger_pb.PetBreedChat,
}

Team_Model.ContinuousLineType = 9999 --一条龙队伍特殊目标，与无目标类似

---队伍和队员相关状态枚举
Team_Model.TeamState = {
    Default = team_enum_pb.TSDefault,           --创建完成后进入默认状态
    MatchUpload = team_enum_pb.TSMatchUpload,   --队员上传自己的数据状态。
    Matching = team_enum_pb.TSMatching,         --匹配中。
    Confirm = team_enum_pb.TSConfirm,           --匹配确认阶段。
    InBattle = team_enum_pb.TSInBattle,         --战斗中。
    InActive = team_enum_pb.TSInActive,         --不活跃状态。
}

Team_Model.TeamType = {
    Normal = team_enum_pb.TTNormal,
    Temporary = team_enum_pb.TTTemporary,
}

Team_Model.MemberState = {
    Idle = team_enum_pb.MSIdle,
    Following = team_enum_pb.MSFollowing,
    Leave = team_enum_pb.MSLeave,
}

Team_Model.MemberType = {
    Leader = team_enum_pb.MTLeader,
    Member = team_enum_pb.MTMember,
    CrossMember = team_enum_pb.MTCrossMember,
}

Team_Model.InvitedType = {
    Team = 1,
    Room = 2,
}

--组队玩法排序：权重>id
local function SortTeam(a_ActivityCfg, b_ActivityCfg)
    if a_ActivityCfg.Sort == b_ActivityCfg.Sort then
        return a_ActivityCfg.ID < b_ActivityCfg.ID
    else
        return a_ActivityCfg.Sort > b_ActivityCfg.Sort
    end
end

function Team_Model.OnStartup()
    EventSystem.Regist(EventID.FunctionUnlockUpdate, private.SetTeamPlayList)
    EventSystem.Regist(EventID.GetOtherPeopleInfo, private.OnGetOtherPeopleInfo)

    EventSystem.Regist(EventID.TeamActivityChange, private.CheckTeamPlayList)
    ---push相关协议
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushKickOut, private.KickOutPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamLeaderChange, private.LeaderChangePush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushJoinTeam, private.JoinTeamPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushLeaveTeam, private.LeaveTeamPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushInvited, private.BeInvitedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushDeleteInvited, private.G2CPushDeleteInvited)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushApplicantInfo, private.ApplicantInfoPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushDeleteApplicantInfo, private.G2CPushDeleteApplicantInfo)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushRefusedApply, private.ApplyRefusedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamInfo, private.TeamInfoPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamMemberInfoChanged, private.TeamMemberInfoChangedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamCallMemberFollow, private.CallMemberFollowPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamStateChanged, private.TeamStateChangedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushMemberStateChanged, private.MemberStateChangedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamTargetChanged, private.TeamTargetChangedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CPushTeamLeaderPosChanged, private.TeamLeaderPosChangedPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CTeamMemberApplyTeamLeaderPush, private.TeamMemberApplyTeamLeaderPush)
    NetManager.RegisterMsgCB(MessageEnums.MessageG2CTeamMemberApplyTeamLeaderVotePush, private.TeamMemberApplyTeamLeaderVotePush)
    ---resp相关协议
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamCreate, private.TeamCreateResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamKickOutMember, private.TeamKickOutMemberResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamLeaderChange, private.TeamLeaderChangeResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamApply, private.TeamApplyResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamApplyHandle, private.TeamApplyHandleResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamLeave, private.TeamLeaveResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamInvite, private.TeamInviteResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamInviteHandle, private.TeamInviteHandleResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamRecommendList, private.TeamRecommendListResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamChangeTarget, private.TeamChangeTargetResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamFollow, private.TeamFollowResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamCallMember, private.TeamCallMemberResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageStrangerList, private.StrangerListResp)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamMemberConveyToLeader, nil)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamMemberApplyTeamLeader, nil)
    NetManager.RegisterMsgCB(MessageEnums.MessageTeamMemberApplyTeamLeaderVote, nil)

    ---公有变量
    Team_Model.IsAutoAccept = false
    Team_Model.IsAutoFollow = false
    Team_Model.IsAutoInvited = false
    Team_Model.IsAutoMatch = false
    ---私有变量
    private.teamInfo = {}
    private.teamMemberInfo = {}
    private.applyTeamList = {}
    private.inviteList = {} -- JWS2-30641 切磋模式新增一种邀请类型，使用原被邀请列表队列。info外层增加一个类型标识 {{type = MDL.Team.InvitedType, data = msg}}
    private.recommendTeamList = {}
    private.originServerRecommendTeamNum = 0
    private.differentServerRecommendTeamNum = 0
    private.recommendTeamTarget = {}
    private.strangerList = {}
    private.strangerTimeDict = {}
    private.acid2FollowIndexInfoDic = {} --包含所有玩家的followIndex信息， key是acid，value是一个table，包含火车跟随的index和teamLeaderId。teamLeaderId是acid
    private.teamLeaderPos = FP.newV2(0,0)

    private.SetTeamPlayList()

    private.IsReceiveCall = false

    private.TeamFollowMaxDistanceC = FP.newV1(DataSheetManager.ConstData:GetDataByID("TeamFollowMaxDistanceC").IntValue)
end

--region -- **************** 通用方法 ******************* --
function private.SetTeamPlayList()
    private.TeamPlayList = {}
    for i, v in DataSheetManager.ActivityData:GetEnumerator() do
        if v.ShowInTeamUI then
            if MDL.Unlock.IsUnlock(v.FuctionUnlockID) and private.CanAddTeamPlayList(v.ID) then
                table.insert(private.TeamPlayList, v)
            end
        end
    end

    table.sort(private.TeamPlayList, SortTeam)
    EventSystem.Dispatch(EventID.UI_Team_UpdateFoldView)
end

function private.CanAddTeamPlayList(activityId)
    if activityId == LuaConst.ActivityType.SyncFourCountryWar then
        return  MDL.SyncFourCountryWar.IsBattle()
    end
    return true
end

function private.CheckTeamPlayList(activityId)
    local isAdd = private.CanAddTeamPlayList(activityId)
    local activityData = DataSheetManager.ActivityData:GetDataByID(activityId)
    if isAdd then
        if (table.containValue(private.TeamPlayList, activityData) == false) then
            table.insert(private.TeamPlayList, activityData)
            table.sort(private.TeamPlayList, SortTeam)
            EventSystem.Dispatch(EventID.UI_Team_UpdateFoldView)
        end
    else
        table.removebyvalue(private.TeamPlayList, activityData)
    end
end

function Team_Model.GetTeamPlayList()
    return private.TeamPlayList
end

function Team_Model.GetTeamPlayIndexByActivityId(id)
    local teamTargetList = Team_Model.GetTeamPlayListData()
    for i, v in ipairs(teamTargetList) do
        if v.ID == id then
            return i - 1
        end
    end
    return 0
end

---获取包含二级菜单的总数据
function Team_Model.GetTeamPlayListData()
    local mainData = {}
    table.insert(mainData, { MainTitle = UIUtils.GetLocalizedTxt(CTL.Team.GetSpecifiedTargetTitle(Team_Model.ContinuousLineType)), Menu = CTL.Rank.MenuLevel.Single, ID = Team_Model.ContinuousLineType })
    table.insert(mainData, { MainTitle = UIUtils.GetLocalizedTxt(CTL.Team.GetSpecifiedTargetTitle(0)), Menu = CTL.Rank.MenuLevel.Single, ID = 0 })
    for i, v in ipairs(private.TeamPlayList) do
        local data = {MainTitle = UIUtils.GetLocalizedTxt(Const_IDS[v.Activity]), Menu = CTL.Rank.MenuLevel.Single, ID = v.ID}
        if table.containValue(MDL.MultiplayerDungeon.SubActivityId, v.ID) then
            data.subData = MDL.MultiplayerDungeon.GetMultiplayerDungeonSubDataById(v.ID)
            data.Menu = CTL.Rank.MenuLevel.Double
        end
        table.insert(mainData, data)
    end
    return mainData
end

function Team_Model.SetTeamInfo(teamInfo)
    private.teamInfo = {}
    private.teamMemberInfo = {}
    if IsServerDataNotNil(teamInfo) then
        private.teamInfo = teamInfo
        for i, v in ipairs(teamInfo.members) do
            Team_Model.AddTeamMember(v)
        end
        Team_Model.SortMemberOrder()
        private.inviteList = {}
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.CreateTeam, teamInfo.teamId)
    else
        --这里直接 Clear 是有问题的，会导致所有的跟随信息全都被清空，别人的组队跟随也会失效， 但是没什么好办法，因为服务器传过来的信息量有限 --2022年3月8日
        Team_Model.ClearFollow()
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.LeaveTeam)
    end
end

function Team_Model.RawsetTeamLeaderPos(x,z)
    private.teamLeaderPos:Rawset(x,z)
end

function Team_Model.SortMemberOrder()
    for i, v in ipairs(private.teamMemberInfo) do
        if v.type == Team_Model.MemberType.Leader then
            local leader = table.remove(private.teamMemberInfo, i)
            table.insert(private.teamMemberInfo, 1, leader)
        end
    end
end

function Team_Model.GetTeamInfo()
    return private.teamInfo
end

--主玩家是否在组队跟随中
function Team_Model.IsFollowing()
    local isFollowing = false
    if BattleDataGetter.IsTownLevel() then
        --只有主城才可以跟随
        local selfMemberInfo = Team_Model.GetSelfMemberInfo()
        if selfMemberInfo then
            isFollowing = selfMemberInfo.state == Team_Model.MemberState.Following
        end
    end
    return isFollowing
end

--主玩家是否进入了火车跟随
function Team_Model.IsTrainFollowing(entity)
    return Team_Model.IsEntityHasFollowIndex(entity)
end

-- 这个方法要跟LevelPlayerManager.IsTeamId一致
function Team_Model.IsTeamId(teamId)
    return type(teamId) == "string"
end

--传入的entity是否是主玩家的队友
function Team_Model.IsEntityTeammate(entity)
    local entityID = nil
    for i, v in ipairs(Team_Model.GetAllMembersInfo()) do
        entityID = SyncMoveManager.GetEntityIDByAcid(v.memberId)
        if entityID == entity.EntityID then
            return true
        end
    end
    return false
end
--传入的entity是否处于组队跟随的开火车阶段
function Team_Model.IsEntityHasFollowIndex(entity)
    local followIndex = Team_Model.GetFollowIndexOfEntity(entity)
    return followIndex ~= nil and followIndex > 0
end
--返回传入的entity的开火车的序号，只有进入开火车阶段的队友才会返回非nil
function Team_Model.GetFollowIndexOfEntity(entity)
    local acid = SyncMoveManager.GetAcIdOfEntity(entity)
    if acid then
        return Team_Model.GetFollowIndexByAcid(acid)
    end
end
function Team_Model.GetEntityByFollowIndex(followIndex, teamLeaderId)
    local acid = Team_Model.GetTeammateAcidByFollowIndex(followIndex, teamLeaderId)
    if acid then
        return SyncMoveManager.GetEntityByAcid(acid)
    end
end
--返回火车跟随的目标位置，必须传入followIndex(车厢号)
--可能返回nil
--followTargetPos不为nil时，targetEntity也可能为nil
function Team_Model.GetTrainFollowTargetPos(followIndex, teamLeaderId)
    local followTargetPos = nil
    local targetEntity = nil
    if followIndex == 1 then
        followTargetPos = Team_Model.GetTeamLeaderPos(teamLeaderId)
        targetEntity = SyncMoveManager.GetEntityByAcid(teamLeaderId)
    else
        local chasingTeammateAcid = Team_Model.GetTeammateAcidByFollowIndex(followIndex - 1, teamLeaderId)
        if chasingTeammateAcid then
            targetEntity = SyncMoveManager.GetEntityByAcid(chasingTeammateAcid)
            if targetEntity then
                followTargetPos = targetEntity:GetLogicPos()
            end
        end
    end
    followTargetPos = followTargetPos or Team_Model.GetTeamLeaderPos(teamLeaderId)
    return followTargetPos, targetEntity
end

function Team_Model.GetTeamLeaderEntityByAcID(entityID)
    local teamLeaderId = Team_Model.GetFollowTeamLeaderId(entityID)
    if teamLeaderId == BattleDataGetter.GetAcID() then
        --如果自己是队长，private.teamLeaderPos不会更新，直接返回LogicUpdateManager._curEntity的位置
        return LogicUpdateManager._curEntity
    else
        return SyncMoveManager.GetEntityByAcid(teamLeaderId)
    end
end

function Team_Model.GetTeamLeaderPos(teamLeaderId)
    if teamLeaderId == BattleDataGetter.GetAcID() then
        --如果自己是队长，private.teamLeaderPos不会更新，直接返回LogicUpdateManager._curEntity的位置
        return LogicUpdateManager._curEntity:GetLogicPos()
    else
        local pos = nil
        local entity = SyncMoveManager.GetEntityByAcid(teamLeaderId)
        if entity then
            pos = entity:GetLogicPos()
        end

        if not pos then
            if teamLeaderId == CTL.Team.GetTeamLeaderId() then
                if private.teamLeaderPos ~= FP.Const.Vector2_Zero then
                    pos = private.teamLeaderPos
                else
                    pos = nil
                end
            else
                pos = nil
            end
        end
        
        return pos
    end
end

function Team_Model.GetTeamMemberEntityList()
    local entityList = {}
    for i,memberInfo in ipairs(private.teamMemberInfo) do
        for k,v in pairs(BattleDataGetter.GetEntityDic()) do
            if v._logicInitData.Name == memberInfo.playerShowInfo.name then
                table.insert(entityList, v)
                break
            end
        end
    end
    --有个奇怪的特性，自己的_logicInitData.Name是""，所以上面的代码没办法把自己加进list，下面的代码是临时补救措施，之后需要从根本上处理，解决自己的_logicInitData.Name是""的问题
    local isContainSelf = false
    for i,v in ipairs(entityList) do
        if v == BattleDataGetter.GetCurEntity() then
            isContainSelf = true
            break
        end
    end
    if not isContainSelf then
        table.insert(entityList, BattleDataGetter.GetCurEntity())
    end
    return entityList
end
--返回FP
function Team_Model.GetTeamFollowMaxDistanceC()
    return private.TeamFollowMaxDistanceC
end

function Team_Model.GetMyTeamId()
    return private.teamInfo.teamId
end

function Team_Model.GetMyTeamState()
    return private.teamInfo.state
end

function Team_Model.GetTeamMemberNumbers()
    return #private.teamMemberInfo or 0
end

--获取自己的成员信息
function Team_Model.GetSelfMemberInfo()
    return Team_Model.GetMemberInfoById(BattleDataGetter.GetAcID())
end

function Team_Model.GetApplyTeamList()
    return private.applyTeamList
end

function Team_Model.GetApplyListIndexById(id)
    for i, v in ipairs(private.applyTeamList) do
        if v.applyPlayerId == id then
            return i - 1
        end
    end
    logging.warn(LTAG.WARN, "没有在申请列表中找到Id为：", id, " 的玩家")
    return nil
end

function Team_Model.GetInviteListIndexById(id)
    for i, v in ipairs(private.inviteList) do
        if v.type == Team_Model.InvitedType.Team and v.info.teamInfo.teamId == id then
            return i - 1
        end
    end
    logging.warn(LTAG.WARN, "没有在邀请列表中找到Id为：", id, " 的队伍")
    return nil
end

-- 包含房间邀请和队伍邀请的所有请求
function Team_Model.GetInviteList()
    return private.inviteList
end

function Team_Model.GetInvitedMsgCount()
    local count = 0
    for _, v in ipairs(private.inviteList) do
        if v.type == Team_Model.InvitedType.Team then
            count = count + 1
        end
    end
    return count
end

--通过跟随序号获取acid  --这个方法得传入teamLeaderId，否则无法定位，因为acid2FollowIndexInfoDic存的是所有玩家的信息，followIndex可能重复。只有teamLeaderId跟followIndex都匹配，才能定位acid
function Team_Model.GetTeammateAcidByFollowIndex(followIndex, teamLeaderId)
    for acid,v in pairs(private.acid2FollowIndexInfoDic) do
        if v.followIndex == followIndex and v.teamLeaderId == teamLeaderId then
            return acid
        end
    end
    --正常情况。 如果3个人开火车，队长直接杀进程，就会走一次这里，应该是时序的问题，无害
    --logging.error(LTAG.ERROR, "HYW : (测试可忽略) GetTeammateAcidByFollowIndex失败！  followIndex : " , followIndex, "     teamLeaderId : ", teamLeaderId)
    return  CTL.Team.GetTeamLeaderId()
end

--通过acid获取跟随序号，可能返回nil
function Team_Model.GetFollowIndexByAcid(acid)
    return private.acid2FollowIndexInfoDic[acid] and private.acid2FollowIndexInfoDic[acid].followIndex
end

--这个东西不能随便清理,因为里面存了场景里所有人的组队跟随开火车信息
function Team_Model.ClearFollow()
    table.clear(private.acid2FollowIndexInfoDic)
end

function Team_Model.ClearTeamInfo()
    private.teamInfo = {}
    --private.teamMemberInfo = {}
    --清空数据前，先派发事件通知entity修改字色
    for i = #private.teamMemberInfo, 1, -1 do
        local acid = private.teamMemberInfo[i].memberId
        private.teamMemberInfo[i] = nil
        if acid ~= BattleDataGetter.GetAcID() then
            EventSystem.Dispatch(EventID.TeamMemberChanged, acid)
        end
    end
    -- JWS2-30641
    private.ClearInvitedInfo()
    
    private.applyTeamList = {}
    Team_Model.ClearRecommendTeamList()
    Team_Model.SetFollowIndex(BattleDataGetter.GetAcID(), -1, nil)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.LeaveTeam)
    --Team_Model.ClearFollow()
end

function private.ClearInvitedInfo()
    -- 保留队列中非team类型的邀请信息
    local tb = {}
    for i, v in ipairs(private.inviteList) do
        if v.type ~= Team_Model.InvitedType.Team then
            table.insert(tb, v)
        end
    end
    private.inviteList = tb
end

function Team_Model.ClearApplyTeamList()
    for i, v in ipairs(private.applyTeamList) do
        Team_Model.TeamApplyHandleReq(v.applyPlayerId, false)
    end
end

function Team_Model.ClearInviteList()
    for i, v in ipairs(private.inviteList) do
        if v.type == Team_Model.InvitedType.Team then
            Team_Model.TeamInviteHandleReq(v.info.teamInfo.teamId, false)
        elseif v.type == Team_Model.InvitedType.Room then
            MDL.CustomRoom.RefuseCustomRoomInviteReq(v.info.BriefInfo.ActivityID, v.info.BriefInfo.RoomID)
        end
    end
end

function Team_Model.GetMemberNameById(memberId)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            if private.teamInfo.crossTeam then
                return v.playerShowInfo.name .. CTL.CrossServer.GetServerShowStr(v.playerShowInfo.ShowServerId, CTL.CrossServer.IsSameServer(v.playerShowInfo.MergeServerId))
            else
                return v.playerShowInfo.name
            end
        end
    end
end

function Team_Model.GetMemberInfoById(memberId)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            return v
        end
    end
end

function Team_Model.GetMemberIndexById(memberId)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            return i
        end
    end
    return 1
end

function Team_Model.GetAllMembersInfo()
    return private.teamMemberInfo
end

function Team_Model.AddTeamMember(memberInfo)
    table.insert(private.teamMemberInfo, memberInfo)
end

function Team_Model.RemoveTeamMemberById(memberId)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            table.remove(private.teamMemberInfo, i)
            break
        end
    end
end

function Team_Model.ChangeMemberInfo(newInfo)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == newInfo.memberId then
            private.teamMemberInfo[i] = newInfo
            return true
        end
    end
    logging.warn(LTAG.WARN, "替换成员信息失败，没有找到该memberId：", newInfo.memberId)
    return false
end

function Team_Model.ChangeMemberType(memberId, type)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            v.type = type
            return true
        end
    end
    logging.warn(LTAG.WARN, "替换成员信息失败，没有找到该memberId：", memberId)
    return false
end

function Team_Model.ChangeMemberState(memberId, state)
    local finded = false
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == memberId then
            v.state = state
            finded = true
        end
    end
    
    if not finded then
        logging.warn(LTAG.WARN, "替换成员信息失败，没有找到该memberId：", memberId)
    end
    return finded
end

function Team_Model.ChangeToLeader(leaderId)
    Team_Model.ChangeMemberType(leaderId, Team_Model.MemberType.Leader)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId ~= leaderId then
            Team_Model.ChangeMemberType(v.memberId, Team_Model.MemberType.Member)
        end
    end
    Team_Model.SortMemberOrder()

    --Team_Model.TeamFollowReq(false)
end

function Team_Model.CheckRecommendTeamTargetChange(mainTarget, subTarget)
    if private.recommendTeamTarget.mainTarget and private.recommendTeamTarget.subTarget then
        if private.recommendTeamTarget.mainTarget ~= mainTarget or private.recommendTeamTarget.subTarget ~= subTarget then
            Team_Model.ClearRecommendTeamList()
            private.recommendTeamTarget.mainTarget = mainTarget or 0
            private.recommendTeamTarget.subTarget = subTarget or 0
        end
    else
        private.recommendTeamTarget.mainTarget = mainTarget
        private.recommendTeamTarget.subTarget = subTarget
    end
end

function Team_Model.UpdateRecommendTeamList(mainTarget, subTarget, teamList)
    Team_Model.CheckRecommendTeamTargetChange(mainTarget, subTarget)
    for i, v in ipairs(teamList) do
        if i > TeamShowMax then
            return
        end
        --增加去重，防止重复增加
        local isExist = false
        for i, info in ipairs(private.recommendTeamList) do
            if v.teamId == info.teamId then
                isExist = true
                break
            end
        end
        if isExist == false then
            table.insert(private.recommendTeamList, v)
        end
    end
end

function Team_Model.GetRecommendTeamList()
    return private.recommendTeamList
end

function Team_Model.ClearRecommendTeamList()
    private.recommendTeamList = {}
    private.originServerRecommendTeamNum = 0
    private.differentServerRecommendTeamNum = 0
end

function Team_Model.ChangeTeamTarget(target, limit)
    private.teamInfo.target.mainTarget = target.mainTarget or 0
    private.teamInfo.target.subTarget = target.subTarget
    if limit then
        private.teamInfo.limit.level = limit.level
        private.teamInfo.limit.rank = limit.rank
        private.teamInfo.limit.power = limit.power
    end
    local ids = UIUtils.GetLocalizedTxt(Const_IDS.IDS_TeamUI_Myteam_ChangeTarget)
    local name
    if CTL.Team.IsSpecifiedTarget(target.mainTarget) then
        name = UIUtils.GetLocalizedTxt(CTL.Team.GetSpecifiedTargetTitle(target.mainTarget))
    else
        name = Team_Model.GetTeamTargetName(target.mainTarget, target.subTarget)
    end
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.TeamTargetChange, target.mainTarget or 0, target.subTarget)
    CTL.Tips.AddTipsMsg(ids, name)
end

function Team_Model.GetTeamTarget()
    return  private.teamInfo.target.mainTarget, private.teamInfo.target.subTarget
end

function Team_Model.GetTeamTargetInfo(mainTarget, subTarget)
    local activityData = DataSheetManager.ActivityData:GetDataByID(mainTarget)
    if subTarget and subTarget > 0 then
        if table.containValue(MDL.MultiplayerDungeon.SubActivityId, mainTarget) then
            local sheetData = MDL.MultiplayerDungeon.GetMultiplayerDungeonDataByType_Difficult(mainTarget, subTarget)
            local difficult = string.FormatByIdsKey("IDS_ActivityName_Difficulty", UIUtils.GetLocalizedTxt(Const_IDS["IDS_Number_Written_"..sheetData.Difficulty]))
            local mainName = UIUtils.GetLocalizedTxt(Const_IDS[activityData.Activity])
            local subName = difficult
            local FuctionUnlockID = nil
            local SheetShowConditionIDS = nil
            local UnlockCondition = nil
            local UnlockConditionParam = nil
            ---原来有一个潜规则，即多人副本难度一的StageUnlockValue参数表示功能解锁ID
            ---意图是要统一功能和难度一的解锁条件，并显示开启等级
            ---由于解锁条件变成主线关卡解锁了，所以先注释了统一改成等级判断。
            --if sheetData.Difficulty == 1 then
                --FuctionUnlockID = sheetData.StageUnlockValue
                --SheetShowConditionIDS = "IDS_Activity_Condition_01"
            --else
                UnlockCondition = sheetData.StageUnlockType
                UnlockConditionParam = sheetData.StageUnlockValue
            --end

            local data =
            {
                ID = mainTarget,
                ActivityName = mainName,
                ActivitySub = subName,
                FuctionUnlockID = FuctionUnlockID,
                SheetShowConditionIDS = SheetShowConditionIDS,
                UnlockCondition = UnlockCondition,
                UnlockConditionParam = UnlockConditionParam,
                UnlockDes = "IDS_Activity_Condition_01",
                TimeDes = activityData.TimeDes,
                Time_Table = activityData.Time_Table,
                RewardShow = sheetData.StageUnlockReward,
            }
            return data
        end
    end
    return activityData
end

function Team_Model.GetTeamTargetName(mainTarget, subTarget)
    local targetInfo = Team_Model.GetTeamTargetInfo(mainTarget, subTarget)
    local teamTargetName = targetInfo.Activity and UIUtils.GetLocalizedTxt(Const_IDS[targetInfo.Activity]) or string.Concat(targetInfo.ActivityName, targetInfo.ActivitySub)
    return teamTargetName
end

function Team_Model.GetTeamTargetUnlockInfo(mainTarget, subTarget)
    local targetInfo = Team_Model.GetTeamTargetInfo(mainTarget, subTarget)
    if targetInfo.FuctionUnlockID then
        local unlockInfo = DataSheetManager.FuctionUnlock:GetDataByFucID(targetInfo.FuctionUnlockID).Unlock_Table
        return tonumber(unlockInfo[1].UnlockConditionParam), MDL.Unlock.GetUnlockContent(targetInfo.FuctionUnlockID, targetInfo.SheetShowConditionIDS)
    else
        local isUnlock, unlockDes = MDL.Unlock.IsComplete(targetInfo.UnlockCondition, targetInfo.UnlockConditionParam, targetInfo.UnlockDes)
        return tonumber(targetInfo.UnlockConditionParam), unlockDes
    end
end

function Team_Model.ReloadApplicantsInfo(applicantsInfo)
    for i, v in ipairs(applicantsInfo) do
        table.insert(private.applyTeamList, v)
    end
end

--endregion

--region -- **************** 陌生人相关方法 ******************* --

function private.SortStrangerByTime(stranger_a, stranger_b)
    local time_a = Team_Model.GetStrangerTime(stranger_a.acid)
    local time_b = Team_Model.GetStrangerTime(stranger_b.acid)
    return time_a > time_b
end

function Team_Model.GetStrangerList(isTimeSort)
    if isTimeSort then
        table.sort(private.strangerList, private.SortStrangerByTime)
    end
    return private.strangerList
end

function Team_Model.UpdateStrangerList(strangers, acid2time)
    private.strangerList = {}
    for i, v in ipairs(strangers) do
        if i > TeamListMax then
            return
        end
        private.strangerList[i] = v
    end

    for i, v in ipairs(acid2time) do
        private.strangerTimeDict[v.acid] = v.timeStamp
    end
end

function Team_Model.GetStrangerTime(acid)
    return  private.strangerTimeDict[acid] or 0
end

function Team_Model.StrangerListReq(strangerType)
    local msg = stranger_pb.StrangerListReq()
    msg.strangerType = strangerType
    NetManager.SendMessage(MessageEnums.MessageStrangerList, msg)
end

function private.StrangerListResp(msgResp)
    if msgResp.Resp.Code == 0 then
        Team_Model.UpdateStrangerList(msgResp.strangers, msgResp.acid2time)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.StrangerListRefresh)
    end
end
--endregion

--region -- **************** 其他人相关方法（在打开我的队伍界面时请求刷新组员信息） ******************* --
function Team_Model.TeamOtherPeopleInfoReq()
    local target = {}
    for i, v in ipairs(private.teamMemberInfo) do
        table.insert(target, v.memberId)
    end
    MDL.Player.CommonGetOtherPeopleInfoReq(target, MDL.Unlock.FunctionType.Team)
end

function private.OnGetOtherPeopleInfo(funcId, infos)
    if funcId == MDL.Unlock.FunctionType.Team then
        for i, v in ipairs(infos) do
            private.UpdateTeamMemberInfo(v)
        end
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
    end
end

function private.UpdateTeamMemberInfo(info)
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId == info.acid then
            v.playerShowInfo.name = info.name
            v.playerShowInfo.level = info.level
            v.playerShowInfo.vipLv = info.vipLv
            v.playerShowInfo.teamRankID = info.nobility
            v.playerShowInfo.gsSum = info.power
            v.playerShowInfo.mainHeroId = info.mainHeroId
            v.playerShowInfo.HeroID = info.mainHeroId
            v.playerShowInfo.HeroAppearanceID = info.appearanceId
            v.playerShowInfo.IsActiveMagicWeapon = info.isActiveMagicWeapon
            v.playerShowInfo.WeaponAppearanceID = info.WeaponAppearanceID
            v.playerShowInfo.MagicWeaponBreak = info.weaponBreak
            if IsProtoDataNotNil(info.weaponSoul) then
                NetManager.ChangeProtoMapData(v.playerShowInfo.weaponSoul, info.weaponSoul)
            end

            v.detailInfo.mainHeroId = info.mainHeroId
            v.detailInfo.appearanceId = info.appearanceId
            v.detailInfo.isActiveMagicWeapon = info.isActiveMagicWeapon
            v.detailInfo.heroBreakNums = info.heroBreakNums
            v.detailInfo.weaponBreak = info.weaponBreak
            v.detailInfo.weaponAppearanceId = info.WeaponAppearanceID
        end
    end
end
--endregion

--region -- **************** 跟随、召集相关方法 ******************* --
function Team_Model.TeamFollowReq(isFollow)
    if CTL.Team.IsSelfLeader() then
        logging.log(LTAG.LOG, "自己是队长，不可使用跟随命令。")
        return
    end
    if CTL.Team.IfCanFollow() then
        local msg = team_operate_pb.TeamFollowReq()
        msg.isFollow = isFollow
        NetManager.SendMessage(MessageEnums.MessageTeamFollow, msg)
        CTL.TeamDungeon.StopTreasure()
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamCS_TeamCSMemberCanNotFollow"])
    end
end

function private.TeamFollowResp(msgResp)
    logging.log(LTAG.LOG, "TeamFollowResp", msgResp)
    private.IsReceiveCall = false
    if msgResp.Resp.Code == 0 then
        ---请求跟随队长逻辑处理
        ---msgResp.isFollow 是否跟随
        ---msgResp.followedInfo 跟随者信息
        if msgResp.isFollow then
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_MemberFollowSuccess"])
            Team_Model.RawsetTeamLeaderPos(msgResp.followInfo.pos.X , msgResp.followInfo.pos.Z)
            NotSyncBattleSetter.StartFollowTeamLeader()
            CTL.TeamDungeon.StopTreasure()
        else
            NotSyncBattleSetter.ChangeAI(LuaConst.FindPathByLevelItemAIID)
            NotSyncBattleSetter.StopAutoFightPathInTown()
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_MemberCancelFollow"])
        end
        -- 主动变更跟随状态
        EventSystem.Dispatch(EventID.UI_Auto_Tips, LuaConst.AutoType.AutoFollow)
    end
end

function Team_Model.TeamCallMemberReq()
    if not CTL.Team.IsSelfLeader() then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_MemberNoPermission"])
        return
    end
    if CTL.Team.IfCanCallMembers() then
        if Team_Model.GetTeamMemberNumbers() > 1 then
            local msg = team_operate_pb.TeamCallMemberReq()
            NetManager.SendMessage(MessageEnums.MessageTeamCallMember, msg)
        else
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_NoMemberToBeCalled"])
        end
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamCS_CaptainCanNotCall"])
    end
end

function private.TeamCallMemberResp(msgResp)
    if msgResp.Resp.Code == 0 then
        ---召集队员跟随逻辑处理
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_SendCallMessage"])
    end
end

function private.CallMemberFollowPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushTeamCallMemberFollow", msg)
    --当前处于分包下载，不提示召集
    if LoginProxy.Get_IfAllDownload() == false and UIManager.IsViewOpened(Const_UI_Lua.UIEnum.UIStagePackage) then
        return
    end

    -- 当前处于押镖状态，不提示召集
    if CTL.GuildEscort.IsTransport() then
        return
    end

    ---队长召集队员跟随的Push，弹框确认
    ---functionFollow为开始跟随的方法
    if not private.IsReceiveCall and Team_Model.GetSelfMemberInfo().state ~= Team_Model.MemberState.Following then
        if Team_Model.IsAutoFollow and not CTL.Team.IsSelfLeader() then
            Team_Model.TeamFollowReq(true)
        else
            UTL.MessageBox.ShowOKCancelNoCloseBox(nil, UIUtils.GetLocalizedTxt(Const_IDS["IDS_TeamUI_TeamCallFollow"]),
                    function() Team_Model.TeamFollowReq(true) end, function() Team_Model.TeamFollowReq(false) end)
            private.IsReceiveCall = true
        end
    end
end

--开始火车式跟随
function Team_Model.SendC2GTeamMemberFollowIndex()
    NetManager.SendMessage(MessageEnums.MessageC2GTeamMemberFollowIndex, team_operate_pb.C2GTeamMemberFollowIndex())
end

--acid就是memberId
function Team_Model.SetFollowIndex(acid, pFollowIndex, pTeamLeaderId)
    --logging.error(LTAG.ERROR, "HYW : SetFollowIndex ", pFollowIndex, acid, "teamLeaderId : ", pTeamLeaderId)
    local info = private.acid2FollowIndexInfoDic[acid]
    if info then
        info.followIndex = pFollowIndex
        info.teamLeaderId = pTeamLeaderId
    else
        private.acid2FollowIndexInfoDic[acid] = {followIndex = pFollowIndex, teamLeaderId = pTeamLeaderId}
    end
    NotSyncBattleSetter.DisableFollowIndexCacheByAcid(acid)
end
--从组队跟随火车信息列表里找TeamLeaderId, 只有进入火车跟随的单位才能用这个方法找到TeamLeaderId
--可能返回nil
function Team_Model.GetFollowTeamLeaderId(acid)
    if acid then
        local info = private.acid2FollowIndexInfoDic[acid]
        if info then
            return info.teamLeaderId
        end
    end
end

function Team_Model.SendTeamMemberConveyToLeaderReq()
    NetManager.SendMessage(MessageEnums.MessageTeamMemberConveyToLeader, team_operate_pb.TeamMemberConveyToLeaderReq())
end

function private.TeamLeaderPosChangedPush(msgResp)
    Team_Model.RawsetTeamLeaderPos(msgResp.followInfo.pos.X , msgResp.followInfo.pos.Z )
end
--endregion

--region -- **************** req/resp相关方法 ******************* --
function Team_Model.TeamCreateReq(mainTarget, subTarget, limitTable)
    if not CTL.Team.IfCanCreateTeam() then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamCS_CanNotCreat"])
        return
    end
    if CTL.GuildEscort.IsTransport() then
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_Escort_EscortingTeam1)
        return
    end
    local msg = team_operate_pb.TeamCreateReq()
    msg.target.mainTarget = mainTarget or 0
    msg.target.subTarget = subTarget
    if limitTable then
        msg.limit.level = limitTable.level
        msg.limit.rank = limitTable.rank or 0
        msg.limit.power = limitTable.power
    end
    NetManager.SendMessage(MessageEnums.MessageTeamCreate, msg)
end

function private.TeamCreateResp(msgResp)
    if msgResp.Resp.Code == 0 then
        Team_Model.SetTeamInfo(msgResp.teamInfo)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_CreateSuccess"])
        CTL.Sound.PlayGameSound("UI_joinarmy")
        CTL.Team.ShutTeamRecruitMsg(true)
    end
end

function Team_Model.TeamKickOutMemberReq(memberId)
    if CTL.Team.IsSelfLeader() then
        local msg = team_operate_pb.TeamKickOutMemberReq()
        msg.memberId = memberId
        NetManager.SendMessage(MessageEnums.MessageTeamKickOutMember, msg)
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_MemberNoPermission"])
    end
end

function private.TeamKickOutMemberResp(msgResp)
    if msgResp.Resp.Code == 0 then
        local name = Team_Model.GetMemberNameById(msgResp.memberId)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_KickMemberSuccess"], name)
        Team_Model.RemoveTeamMemberById(msgResp.memberId)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
    end
end

function Team_Model.TeamLeaderChangeReq(memberId)
    if CTL.Team.IsSelfLeader() then
        local msg = team_operate_pb.TeamLeaderChangeReq()
        msg.memberId = memberId
        NetManager.SendMessage(MessageEnums.MessageTeamLeaderChange, msg)
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_MemberNoPermission"])
    end
end

function private.TeamLeaderChangeResp(msgResp)
    logging.log(LTAG.LOG, "TeamLeaderChangeResp", msgResp.memberId)
    if msgResp.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_ChangeCaptainSuccess"])
        Team_Model.ChangeToLeader(msgResp.memberId)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
    end
end

function Team_Model.TeamApplyReq(teamId)
    if not CTL.Team.IfCanSendApply() then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamCS_PlayerCanNotApply"])
        return
    end
    if CTL.GuildEscort.IsTransport() then
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_Escort_EscortingTeam2)
        return
    end
    local msg = team_operate_pb.TeamApplyReq()
    msg.teamId = teamId
    NetManager.SendMessage(MessageEnums.MessageTeamApply, msg)
end

function private.TeamApplyResp(msgResp)
    if msgResp.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_ApplySend"])
    end
end

function Team_Model.TeamApplyHandleReq(playerId, isAgree)
    if CTL.Team.IsMemberInTeam(playerId) then
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.ApplyInfoHandle, false, playerId)
        local removeIndex = Team_Model.GetApplyListIndexById(playerId)
        table.remove(private.applyTeamList, removeIndex + 1)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_InOneTeam"])
        return
    end
    if CTL.GuildEscort.IsTransport() then
        CTL.Tips.AddTipsMsg(Const_IDS.IDS_Escort_EscortingTeam4)
        return
    end
    local msg = team_operate_pb.TeamApplyHandleReq()
    msg.playerId = playerId
    msg.isAgree = isAgree
    NetManager.SendMessage(MessageEnums.MessageTeamApplyHandle, msg)
end

function private.TeamApplyHandleResp(msgResp)
    private.RemoveApplyTeamInfoByPlayerID(msgResp.playerId)
end

function Team_Model.TeamLeaveReq()
    CTL.GuildEscort.GuildEscortQuit(function()
        local msg = team_operate_pb.TeamLeaveReq()
        NetManager.SendMessage(MessageEnums.MessageTeamLeave, msg)
    end)
end

function private.TeamLeaveResp(msgResp)
    if msgResp.Resp.Code == 0 then
        local matchingActivity = CTL.TeamMatch.IsInMatching()
        if Team_Model.IsFollowing() then
            NotSyncBattleSetter.StopAutoFightPathInTown()
        end
        if matchingActivity then
            CTL.TeamMatch.CancelAllMatch()
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamMatchCancel_QuitTeam"])
        else
            CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_ExitTeam"])
        end
        Team_Model.ClearTeamInfo()
        CTL.Team.OnLeaveApplyReq()
    end
end

function private.OnMyTeamMemberChanged()
    for i, v in ipairs(private.teamMemberInfo) do
        if v.memberId ~= BattleDataGetter.GetAcID() then
            EventSystem.Dispatch(EventID.TeamMemberChanged, v.memberId)
        end
    end
end

function Team_Model.TeamInviteReq(invitedId)
    if CTL.Team.IfCanInvite() then
        local msg = team_operate_pb.TeamInviteReq()
        msg.invitedId = invitedId
        NetManager.SendMessage(MessageEnums.MessageTeamInvite, msg)
    else
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamCS_CanNotInviteOthers"])
    end
end

function private.TeamInviteResp(msgResp)
    if msgResp.Resp.Code == 0 then
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_TeamUI_ActiveInvitation_HaveBeenInvited"])
    end
end

function Team_Model.TeamInviteHandleReq(teamId, isAgree)
    local msg = team_operate_pb.TeamInviteHandleReq()
    msg.teamId = teamId
    msg.isAgree = isAgree
    NetManager.SendMessage(MessageEnums.MessageTeamInviteHandle, msg)
end

function private.TeamInviteHandleResp(msgResp)
    private.RemoveInviteTeamInfoByTeamID(msgResp.teamId)
end

function Team_Model.TeamRecommendListAutoReq(mainTarget, subTarget)
    private.isReqRecommend = true
    private.TeamRecommendListReq(mainTarget, subTarget, true)
end

function private.TeamRecommendListReq(mainTarget, subTarget, isCrossServer, reqNum)
    local msg = team_operate_pb.TeamRecommendListReq()
    msg.target.mainTarget = mainTarget
    msg.target.subTarget = subTarget
    Team_Model.CheckRecommendTeamTargetChange(mainTarget, subTarget)
    local nowLength = isCrossServer and private.differentServerRecommendTeamNum or private.originServerRecommendTeamNum
    msg.beginIndex = nowLength
    msg.endIndex = nowLength + (reqNum or TeamShowPerNum)
    msg.isCross = isCrossServer
    NetManager.SendMessage(MessageEnums.MessageTeamRecommendList, msg)
end

function private.TeamRecommendListResp(msgResp)
    if msgResp.Resp.Code == 0 then
        Team_Model.UpdateRecommendTeamList(msgResp.target.mainTarget, msgResp.target.subTarget, msgResp.teamList)
        local updateListNum = #msgResp.teamList
        if msgResp.isCross then
            private.differentServerRecommendTeamNum = private.differentServerRecommendTeamNum + updateListNum
        else
            private.originServerRecommendTeamNum = private.originServerRecommendTeamNum + updateListNum
        end
        if private.isReqRecommend then
            private.isReqRecommend = false
            if updateListNum < TeamShowPerNum then
                private.TeamRecommendListReq(msgResp.target.mainTarget, msgResp.target.subTarget, false, TeamShowPerNum - updateListNum)
            else
                CTL.Team.TeamEchoManager(CTL.Team.EchoType.RecommendTeamListChange, msgResp.target.mainTarget, msgResp.target.subTarget, msgResp.beginIndex)
            end
        else
            CTL.Team.TeamEchoManager(CTL.Team.EchoType.RecommendTeamListChange, msgResp.target.mainTarget, msgResp.target.subTarget, msgResp.beginIndex)
        end
    end
end

function Team_Model.TeamChangeTargetReq(mainTarget, subTarget, limitTable)
    local msg = team_operate_pb.TeamChangeTargetReq()
    msg.target.mainTarget = mainTarget or 0
    msg.target.subTarget = subTarget
    if limitTable then
        msg.limit.level = limitTable.level
        msg.limit.rank = limitTable.rank or 0
        msg.limit.power = limitTable.power
    end
    NetManager.SendMessage(MessageEnums.MessageTeamChangeTarget, msg)
end

function private.TeamChangeTargetResp(msgResp)
    logging.log(LTAG.LOG, "TeamChangeTargetResp", msgResp.target, msgResp.limit)
    if msgResp.Resp.Code == 0 then
        Team_Model.ChangeTeamTarget(msgResp.target, msgResp.limit)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.TeamInfoChange)
    end
end

function Team_Model.TeamMemberApplyTeamLeaderReq()
    local msg = team_operate_pb.TeamMemberApplyTeamLeaderReq()
    NetManager.SendMessage(MessageEnums.MessageTeamMemberApplyTeamLeader, msg)
end

function Team_Model.TeamMemberApplyTeamLeaderVoteReq(agree)
    local msg = team_operate_pb.TeamMemberApplyTeamLeaderVoteReq()
    msg.Agree = agree
    NetManager.SendMessage(MessageEnums.MessageTeamMemberApplyTeamLeaderVote, msg)
end
--endregion

--region -- **************** push相关方法 ******************* --
--加入推送
function private.JoinTeamPush(msg)
    local name = msg.memberInfo.playerShowInfo.name
    Team_Model.AddTeamMember(msg.memberInfo)
    CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_IntoTeamSuccessTeamSee"], name)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
    EventSystem.Dispatch(EventID.TeamMemberChanged, msg.memberInfo.memberId)
end

function private.LeaderChangePush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushTeamLeaderChange", msg.memberId)
    Team_Model.ChangeToLeader(msg.memberId)
    local leaderName = Team_Model.GetMemberNameById(msg.memberId)
    CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_ChangeCaptainToMember"], leaderName)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
end

--踢出推送
function private.KickOutPush(msg)
    if msg.memberId == BattleDataGetter.GetAcID() then
        Team_Model.ClearTeamInfo()
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_SomeoneKicked"])
    else
        local name = Team_Model.GetMemberNameById(msg.memberId)
        Team_Model.RemoveTeamMemberById(msg.memberId)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_KickMemberSuccess"], name)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
        EventSystem.Dispatch(EventID.TeamMemberChanged, msg.memberId)
    end
end

--离队推送
function private.LeaveTeamPush(msg)
    if msg.memberId == BattleDataGetter.GetAcID() then
        Team_Model.ClearTeamInfo()
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_ExitTeam"])
    else
        local name = Team_Model.GetMemberNameById(msg.memberId)
        Team_Model.RemoveTeamMemberById(msg.memberId)
        CTL.Tips.AddTipsMsg(Const_IDS["IDS_Team_SomeoneLeaveTeam"], name)
        CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
        EventSystem.Dispatch(EventID.TeamMemberChanged, msg.memberId)
    end
end

--被邀请推送
function private.BeInvitedPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushInvited", msg.inviteInfo)
    if #private.inviteList >= TeamListMax then
        return
    end
    local invitedInfo = {type = Team_Model.InvitedType.Team, info = msg.inviteInfo}
    table.insert(private.inviteList, invitedInfo)
    if Team_Model.IsAutoInvited then
        Team_Model.TeamInviteHandleReq(msg.inviteInfo.teamInfo.teamId, true)
    else
        CTL.Team.OperateTeamInvitedPanel(true, invitedInfo)
    end
end

function private.G2CPushDeleteInvited(msgResp)
    logging.log(LTAG.LOG, "G2CPushDeleteInvited", msgResp.teamId)
    private.RemoveInviteTeamInfoByTeamID(msgResp.teamId)
end

-- 申请人信息推送
function private.ApplicantInfoPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushApplicantInfo", msg.applyInfo)
    if #private.applyTeamList >= TeamListMax then
        return
    end
    table.insert(private.applyTeamList, msg.applyInfo)
    if Team_Model.IsAutoAccept then
        Team_Model.TeamApplyHandleReq(msg.applyInfo.applyPlayerId, true)
    end
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.ApplyInfoHandle, true, msg.applyInfo)
end

-- 被删除申请人信息
function private.G2CPushDeleteApplicantInfo(msgResp)
    logging.log(LTAG.LOG, "MessageG2CPushDeleteApplicantInfo", msgResp.targetAcid)
    private.RemoveApplyTeamInfoByPlayerID(msgResp.targetAcid)
end

--申请被拒绝推送
function private.ApplyRefusedPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushRefusedApply", msg)
end

--成员信息变更推送（不需要提示）
function private.TeamMemberInfoChangedPush(msg)
    for i, v in ipairs(msg.memberInfo) do
        Team_Model.ChangeMemberInfo(v)
    end
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
end

--给加入的成员推送队伍信息
function private.TeamInfoPush(msg)
    Team_Model.SetTeamInfo(msg.info)
    private.OnMyTeamMemberChanged()
    if not CTL.Team.IsSelfLeader() and CTL.Team.IfCanFollow() then
        local leaderName = Team_Model.GetMemberNameById(CTL.Team.GetTeamLeaderId())
        local hintText = string.FormatByIdsKey("IDS_TeamUI_ApplyTeamAutomaticFollow", leaderName)
        UTL.MessageBox.ShowOKCancelBox(UIUtils.GetLocalizedTxt(Const_IDS["IDS_TeamUI_ApplyTeamSuccessTip"]), hintText,
                function() Team_Model.TeamFollowReq(true) end)
    end

    --个人进入队伍跟随队伍匹配时，需要将时间也同步组队的已匹配时间
    if msg.info.matchStartStamp and msg.info.matchStartStamp ~= 0 then
        MDL.TeamMatch.SetStartMatchingTime(msg.info.matchStartStamp)
    end
    CTL.TeamMatch.CancelAllMatch()
    --如果散人进一个正在匹配的队伍需要同时置成匹配状态，如果不满足条件会走TeamStateChangedPush进行取消操作
    CTL.TeamMatch.DealWithTeamStatePush(msg.info.state, msg.info.target.mainTarget)
end

--推送队伍状态变更
function private.TeamStateChangedPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushTeamStateChanged", msg.state)
    private.teamInfo.state = msg.state
    --所有的取消匹配都会走这个push
    CTL.TeamMatch.DealWithTeamStatePush(msg.state, msg.ActivityID, msg.ReasonEnum, msg.ReasonName)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.TeamInfoChange)
end

--推送队员状态变更
function private.MemberStateChangedPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushTeamStateChanged", msg.memberId, msg.state)
    Team_Model.ChangeMemberState(msg.memberId, msg.state)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.MemberInfoChange)
end

function private.TeamTargetChangedPush(msg)
    logging.log(LTAG.LOG, "MessageG2CPushTeamTargetChanged", msg.target, msg.limit)
    Team_Model.ChangeTeamTarget(msg.target, msg.limit)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.TeamInfoChange)
end

function private.TeamMemberApplyTeamLeaderPush(msg)
    if not string.isNilOrEmpty(msg.ApplyMember) then
        UIManager.OpenView(Const_UI_Lua.UIEnum.UIMessageBoxApplyTeamLeader, {content = string.FormatByIdsKey("IDS_ZoneTown_BecomeLeader", msg.ApplyMember)}, "MessageBox/UIMessageBoxTimeBarView")
        --加一个计时器防止接收不到投票结束的push导致缓存没有清空
        private.applyTeamLeaderHandle = TimerUtil.Interval(private.TeamMemberApplyTeamLeaderVotePush, ApplyTeamLeaderTime, 1)
    end
end

function private.TeamMemberApplyTeamLeaderVotePush(msg)
    if not msg or msg.Voter == BattleDataGetter.GetAcID() then
        if private.applyTeamLeaderHandle then
            TimerUtil.Remove(private.applyTeamLeaderHandle)
        end
        private.applyTeamLeaderHandle = nil
        UIManager.CloseView(Const_UI_Lua.UIEnum.UIMessageBoxApplyTeamLeader)
    end
end
--endregion

-- 移除组队申请中的指定玩家数据
function private.RemoveApplyTeamInfoByPlayerID(playerID)
    CTL.Team.TeamEchoManager(CTL.Team.EchoType.ApplyInfoHandle, false, playerID)
    local removeIndex = Team_Model.GetApplyListIndexById(playerID)
    --GetApplyListIndexById可能会返回控制，这里需要判断一下
    if removeIndex then
        table.remove(private.applyTeamList, removeIndex + 1)
    end
end

-- 移除受邀列表中的指定队伍信息
function private.RemoveInviteTeamInfoByTeamID(teamID)
    CTL.Team.OperateTeamInvitedPanel(false, { type = Team_Model.InvitedType.Team, teamId = teamID })
    local removeIndex = Team_Model.GetInviteListIndexById(teamID)
    if removeIndex then --gws 不知道为啥是nil ，临时先这样搞了
        table.remove(private.inviteList, removeIndex + 1)
    else
        logging.warn(LTAG.WARN, "TeamInviteHandleResp 发现要移除不存在的人！ ")
    end
end

function Team_Model.GetDefaultTarget()
    return Team_Model.ContinuousLineType
end


return Team_Model