s_cherry_e/sr/nodes/map/league/league_member.go

package mapLeague

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/component/redis"
	"f1-game/internal/constant"
	"f1-game/internal/data"
	"f1-game/internal/enum"
	nameActor "f1-game/internal/name/actor"
	nameLocal "f1-game/internal/name/local"
	nameRedis "f1-game/internal/name/redis"
	nameRemote "f1-game/internal/name/remote"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/nodes/map/internal/db"
	mapFacade "f1-game/nodes/map/internal/facade"
	leagueBase "f1-game/nodes/map/league/base"
	leagueMember "f1-game/nodes/map/league/member"

	cstring "github.com/cherry-game/cherry/extend/string"
	ctime "github.com/cherry-game/cherry/extend/time"
	cfacade "github.com/cherry-game/cherry/facade"
	cherryLogger "github.com/cherry-game/cherry/logger"
	cproto "github.com/cherry-game/cherry/net/proto"
)

func (p *actorLeague) initLeagueMember() {
	p.Local().Register(nameLocal.MapLeague_Members, p.leagueMembers)

	p.Local().Register(nameLocal.MapLeague_JobInfo, p.leagueJobInfo)
	p.Local().Register(nameLocal.MapLeague_JobSet, p.leagueJobSet)
	p.Local().Register(nameLocal.MapLeague_JobResigned, p.leagueJobResigned)
	p.Local().Register(nameLocal.MapLeague_PermissionSet, p.leaguePermissionSet)
	p.Local().Register(nameLocal.MapLeague_Transfer, p.leagueTransfer)
	p.Local().Register(nameLocal.MapLeague_TransferCancel, p.leagueTransferCancel)
	p.Local().Register(nameLocal.MapLeague_Quit, p.leagueQuit)
	p.Local().Register(nameLocal.MapLeague_Kick, p.leagueKick)
	p.Local().Register(nameLocal.MapLeague_LeagueImpeachInfo, p.leagueImpeachInfo)
	p.Local().Register(nameLocal.MapLeague_LeagueImpeach, p.leagueImpeach)
	p.Local().Register(nameLocal.MapLeague_LeagueImpeachVote, p.leagueImpeachVote)
	p.Local().Register(nameLocal.MapLeague_MemberRecordInfo, p.leagueMemberRecord)
	p.Local().Register(nameLocal.MapLeague_MemberRecordUpdate, p.leagueMemberRecordUpdate)

	p.Remote().Register(nameRemote.MapLeague_ManagerList, p.leagueManagerList)
}

// 获取联盟成员列表
func (p *actorLeague) leagueMembers(session *cproto.Session, _ *pb.None) {
	playerID := sessions.GetPlayerID(session)

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	if !leagueMemberTable.CheckMemberExist(playerID) {
		p.ResponseCode(session, code.LeagueNotJoin)
		return
	}

	var (
		playerIDs = []int64{}
		resp      = &pb.LeagueMembers{}
	)
	for playerID, member := range leagueMemberTable.Members {
		resp.List = append(resp.List, &pb.LeagueMember{
			PlayerID:   playerID,
			Job:        leagueMemberTable.LeagueMember.GetLeagueMemberJob(playerID),
			WeeklyFund: member.WeeklyFund,
		})

		playerIDs = append(playerIDs, playerID)
	}

	if len(playerIDs) > 0 {
		playerDataMap := redis.Game.GetPlayerDataMap(playerIDs, nameRedis.PlayerLeagueMemberFields...)
		if playerDataMap != nil {
			for _, leagueMember := range resp.List {
				playerData, found := playerDataMap[leagueMember.PlayerID]
				if found {
					leagueMember.PlayerName = playerData.PlayerName
					leagueMember.Level = playerData.LordLevel
					leagueMember.Point = &pb.Point{X: playerData.X, Y: playerData.Y}
				}
			}
		}
	}

	// 判断是否存在转让信息
	if leagueMemberTable.Transfer.PlayerID > 0 {
		resp.Transfer = &pb.LeagueTransfer{
			PlayerID:        leagueMemberTable.Transfer.PlayerID,
			PlayerName:      leagueMember.Service().GetPlayerName(leagueMemberTable.Transfer.PlayerID),
			TransferEndTime: leagueMemberTable.Transfer.EndTime,
		}
	}

	p.Response(session, resp)
}

// 获取职位信息
func (p *actorLeague) leagueJobInfo(session *cproto.Session, req *pb.None) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 获取职位的玩家ID列表
	playerList := leagueMemberTable.LeagueMember.GetJobPlayerList()

	// 获取玩家基础信息
	playerMap := redis.Game.GetPlayerDataMap(playerList, nameRedis.PlayerNameFields...)

	list := []*pb.LeagueJobInfo{}
	leagueJobs := data.LeagueJob.List()
	for _, leagueJobRow := range leagueJobs {
		var (
			jobID               = leagueJobRow.JobID
			playerName          = ""
			playerID, found     = leagueMemberTable.LeagueJob.Jobs[jobID]
			permissions, pFound = leagueMemberTable.LeagueJob.Permissions[jobID]
		)

		// 没有职位且职位没有权限
		if !found && !pFound {
			continue
		}

		if playerID > 0 {
			playerData, found := playerMap[playerID]
			if found {
				playerName = playerData.PlayerName
			}
		}

		list = append(list, &pb.LeagueJobInfo{
			JobID:       jobID,
			PlayerID:    playerID,
			PlayerName:  playerName,
			Permissions: permissions,
		})
	}

	resp := &pb.LeagueJobList{
		List: list,
	}

	p.Response(session, resp)
}

// 联盟职位设置
func (p *actorLeague) leagueJobSet(session *cproto.Session, req *pb.I64I32) {
	var (
		targetPlayerID = req.Key
		jobID          = req.Value
	)

	if targetPlayerID <= 0 || jobID <= 0 {
		p.ResponseCode(session, code.RequestParamsError)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	opPlayerID := sessions.GetPlayerID(session)
	// 只有盟主有权限设置权限
	if !leagueTable.LeagueInfo.IsLeader(opPlayerID) {
		p.ResponseCode(session, code.LeaguePermissionDenied)
		return
	}

	if opPlayerID == targetPlayerID {
		p.ResponseCode(session, code.LeagueNoCanSetSelfJob)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 判断玩家是否在联盟内
	if found = leagueMemberTable.LeagueMember.CheckMemberExist(targetPlayerID); !found {
		p.ResponseCode(session, code.LeagueMemberNotExist)
		return
	}

	// 判断职位是否存在
	leagueJobRow, found := data.LeagueJob.GetByJobID(jobID)
	if !found {
		p.ResponseCode(session, code.LeagueJobNotExist)
		return
	}

	// 不能设置为盟主
	if leagueJobRow.JobType == enum.JobType_Leader {
		p.ResponseCode(session, code.LeagueLeaderNotCanSet)
		return
	}

	// 更新的玩家列表
	var changePlayerID = []int64{
		targetPlayerID,
	}

	// 先卸任玩家之前的职位
	leagueMemberTable.Resigned(targetPlayerID)

	// 设置新职位, 返回被卸任的玩家ID
	jobOldPlayerID := leagueMemberTable.SetLeagueMemberJob(jobID, targetPlayerID)

	leagueMemberTable.Save2Queue()

	if jobOldPlayerID > 0 {
		changePlayerID = append(changePlayerID, jobOldPlayerID)
	}

	// TODO 如果有其他人更新职位加在后面
	updateLeagueInfo2Redis(leagueTable, leagueMemberTable, changePlayerID...)

	// 通知玩家职位变更
	p.PermissionChangePush(leagueMemberTable, changePlayerID...)

	resp := &pb.I64I32{
		Key:   targetPlayerID,
		Value: jobID,
	}

	p.Response(session, resp)
}

// 联盟卸任职位
func (p *actorLeague) leagueJobResigned(session *cproto.Session, req *pb.I64) {
	var (
		targetPlayerID = req.Value
		opPlayerID     = sessions.GetPlayerID(session)
	)

	if targetPlayerID <= 0 {
		p.ResponseCode(session, code.RequestParamsError)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 只有盟主有权限设置权限
	if !leagueTable.LeagueInfo.IsLeader(opPlayerID) {
		p.ResponseCode(session, code.LeaguePermissionDenied)
		return
	}

	// 不能卸任自己的职位
	if opPlayerID == targetPlayerID {
		p.ResponseCode(session, code.LeagueNotCanOpSelf)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	list := leagueMemberTable.Resigned(targetPlayerID)

	// 卸任职位
	if len(list) > 0 {
		leagueMemberTable.Save2Queue()
	}

	var (
		jobID             = cstring.ToString(list[0])
		leagueLogTable, _ = db.GetMapLeagueLogTable(p.leagueID)
		playerName        = leagueMember.Service().GetPlayerName(targetPlayerID)
	)

	// 写入日志
	leagueLogTable.AddLeagueLog(enum.Log_LeagueJobRegined, playerName, jobID)

	// 通知玩家职位变更
	p.PermissionChangePush(leagueMemberTable, targetPlayerID)

	resp := &pb.I64{
		Value: targetPlayerID,
	}

	p.Response(session, resp)
}

// 盟主转让
func (p *actorLeague) leagueTransfer(session *cproto.Session, req *pb.I64) {
	var (
		targetPlayerID = req.Value
		opPlayerID     = sessions.GetPlayerID(session)
	)

	if targetPlayerID <= 0 {
		p.ResponseCode(session, code.RequestParamsError)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 不是盟主
	if ok := leagueTable.LeagueInfo.IsLeader(opPlayerID); !ok {
		p.ResponseCode(session, code.LeagueNotLeader)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 转让玩家不是联盟成员
	if found = leagueMemberTable.LeagueMember.CheckMemberExist(targetPlayerID); !found {
		p.ResponseCode(session, code.LeagueTransferNotMember)
		return
	}

	// 判断当前是否存在转让数据
	if leagueMemberTable.LeagueMember.Transfer.PlayerID > 0 {
		p.ResponseCode(session, code.LeagueTransferExist)
		return
	}

	// 盟主正在被弹劾 无法转让
	if leagueMemberTable.Impeach.PlayerID > 0 {
		p.ResponseCode(session, code.LeagueImpeachNotTransfer)
		return
	}

	// 设置转让数据
	endTime := ctime.Now().ToSecond() + data.Const.LeagueTransferTime
	leagueMemberTable.SetLeagueTransfer(targetPlayerID, endTime)
	leagueMemberTable.Save2Queue()

	resp := &pb.LeagueTransfer{
		PlayerID:        targetPlayerID,
		PlayerName:      leagueMember.Service().GetPlayerName(targetPlayerID),
		TransferEndTime: endTime,
	}

	p.Response(session, resp)
}

// 盟主转让取消
func (p *actorLeague) leagueTransferCancel(session *cproto.Session, _ *pb.None) {
	var (
		opPlayerID = sessions.GetPlayerID(session)
	)

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 不是盟主
	if ok := leagueTable.LeagueInfo.IsLeader(opPlayerID); !ok {
		p.ResponseCode(session, code.LeagueNotLeader)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	if leagueMemberTable.LeagueMember.Transfer.PlayerID <= 0 {
		p.ResponseCode(session, code.LeagueTransferNotExist)
		return
	}

	// 取消转让
	leagueMemberTable.SetLeagueTransfer(0, 0)
	leagueMemberTable.Save2Queue()

	p.ResponseCode(session, code.OK)
}

// 获取盟主弹劾信息
func (p *actorLeague) leagueImpeachInfo(session *cproto.Session, _ *pb.None) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	resp := leagueMemberTable.LeagueMember.ToLeagueImpeachProto()

	p.Response(session, resp)
}

// 弹劾盟主
func (p *actorLeague) leagueImpeach(session *cproto.Session, _ *pb.None) {
	var (
		leagueID = p.leagueID
		playerID = sessions.GetPlayerID(session)
	)

	leagueTable, found := db.GetMapLeagueTable(leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 盟主不能弹劾自己
	if ok := leagueTable.LeagueInfo.IsLeader(playerID); ok {
		p.ResponseCode(session, code.LeagueImpeachSelf)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 检测玩家是否是同盟成员
	if found = leagueMemberTable.LeagueMember.CheckMemberExist(playerID); !found {
		p.ResponseCode(session, code.LeagueMemberNotExist)
		return
	}

	// TODO 判断当前赛季阶段是否可以执行弹劾 需要判断结束时间是否会超出弹劾的阶段时间

	// 检测是否存在其他弹劾数据
	if ok := leagueMemberTable.LeagueMember.CheckLeagueImpeachExist(); ok {
		p.ResponseCode(session, code.LeagueImpeachNotEnd)
		return
	}

	nowSecond := ctime.Now().ToSecond()
	// 判断玩家是否符合条件
	if ok := p.CheckLeagueMemberCanImpeach(leagueMemberTable, playerID, nowSecond); !ok {
		p.ResponseCode(session, code.LeagueImpeachNotEnough)
		return
	}

	// 取消当前盟主转让 推送给盟主
	leagueMemberTable.SetLeagueTransfer(0, 0)

	// 获取能发起弹劾投票的玩家数量
	voteCount := p.getLeagueImpeachVoteCount(leagueTable.LeagueInfo.LeaderID, leagueMemberTable, nowSecond)

	// 开始执行弹劾
	leagueMemberTable.HandleLeagueImpeach(playerID, voteCount, nowSecond)

	// TODO 盟主和可执行弹劾成员发送邮件

	resp := leagueMemberTable.LeagueMember.ToLeagueImpeachProto()
	p.Response(session, resp)
}

// 联盟弹劾投票
func (p *actorLeague) leagueImpeachVote(session *cproto.Session, req *pb.Bool) {
	var (
		leagueID = p.leagueID
		playerID = sessions.GetPlayerID(session)
		agree    = req.Value
	)

	leagueTable, found := db.GetMapLeagueTable(leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 盟主不能投票
	if leagueTable.LeagueInfo.IsLeader(playerID) {
		p.ResponseCode(session, code.LeagueImpeachSelf)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 检测玩家是否是同盟成员
	if found = leagueMemberTable.LeagueMember.CheckMemberExist(playerID); !found {
		p.ResponseCode(session, code.LeagueMemberNotExist)
		return
	}

	// 检测是否存在其他弹劾信息
	if ok := leagueMemberTable.LeagueMember.CheckLeagueImpeachExist(); ok {
		p.ResponseCode(session, code.LeagueImpeachNotEnd)
		return
	}

	impeachTime := leagueMemberTable.Impeach.ImpeachTime
	// 判断玩家是否符合条件
	if ok := p.CheckLeagueMemberCanImpeach(leagueMemberTable, playerID, impeachTime); !ok {
		p.ResponseCode(session, code.LeagueImpeachNotEnough)
		return
	}

	// 进行投票
	leagueMemberTable.LeagueMember.LeagueImpeachVote(playerID, agree)

	// 判断是否提前结束
	p.CheckLeagueImpeachEnd(leagueMemberTable)

	resp := leagueMemberTable.LeagueMember.ToLeagueImpeachProto()

	p.Response(session, resp)
}

// 权限设置
func (p *actorLeague) leaguePermissionSet(session *cproto.Session, req *pb.LeaguePermissionRequest) {
	var (
		opPlayerID = sessions.GetPlayerID(session)
		jobs       = req.Jobs
	)

	if len(jobs) <= 0 {
		p.ResponseCode(session, code.RequestParamsError)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 只有盟主能设置权限
	if !leagueTable.LeagueInfo.IsLeader(opPlayerID) {
		p.ResponseCode(session, code.LeaguePermissionDenied)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 检测设置权限是否合法
	for _, job := range jobs {
		var (
			jobID       = job.Job
			permissions = job.Permissions
		)

		leagueJobRow, found := data.LeagueJob.GetByJobID(jobID)
		if !found {
			p.ResponseCode(session, code.LeagueJobNotExist)
			return
		}

		for _, permID := range permissions {
			// 权限不存在
			if !enum.CheckLeaguePermissionExist(permID) {
				p.ResponseCode(session, code.LeaguePermissionNotExist)
				return
			}

			// 当前权限不能设置
			if found := leagueJobRow.JobNotSetPerm.Contains(permID); found {
				cherryLogger.Warnf("[leagueID=%d] permission not can set. job:%d, permID:%d", p.leagueID, jobID, permID)
				p.ResponseCode(session, code.LeaguePermissionNoCanSet)
				return
			}
		}
	}

	updatePlayerIDs := []int64{}
	// 设置权限
	for _, job := range jobs {
		playerID := leagueMemberTable.GetJobPlayerID(job.Job)
		if playerID > 0 {
			updatePlayerIDs = append(updatePlayerIDs, playerID)
		}

		leagueMemberTable.SetLeagueJobPermission(job.Job, job.Permissions)
	}

	leagueMemberTable.Save2Queue()

	// 通知玩家权限变更
	p.PermissionChangePush(leagueMemberTable, updatePlayerIDs...)

	p.ResponseCode(session, code.OK)
}

// 退出联盟
func (p *actorLeague) leagueQuit(session *cproto.Session, req *pb.None) {
	playerID := sessions.GetPlayerID(session)

	if playerID < 1 {
		p.ResponseCode(session, code.PlayerIDError)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return

	}

	// 判断targetPlayerID是否为会长
	if leagueTable.LeagueInfo.IsLeader(playerID) {
		p.ResponseCode(session, code.LeagueLeaderNotQuit)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	quitReq := &pb.I64{
		Value: p.leagueID,
	}
	// 通知map_player 玩家退出联盟
	targetPath := cfacade.NewChildPath(capp.NodeID(), nameActor.Map_Player, playerID)
	errCode := capp.Call(targetPath, nameRemote.MapLeague_QuitNotice, quitReq)
	if code.IsFail(errCode) {
		p.ResponseCode(session, errCode)
		return
	}

	// 玩家退出联盟
	p.doLeagueMemberQuit(leagueTable, leagueMemberTable, playerID, true)

	// 更新redis
	leagueQuitUpdateRedis(playerID)
	// 写入日志
	p.addLeagueLog(enum.Log_LeagueQuit, playerID)

	p.ResponseCode(session, code.OK)
}

// 退出联盟更新redis
func leagueQuitUpdateRedis(playerID int64) {
	fields := map[string]any{}
	fields[nameRedis.Player_LeagueID] = 0
	fields[nameRedis.Player_LeagueName] = ""
	fields[nameRedis.Player_LeagueJob] = 0
	redis.Game.SavePlayerDataFields(playerID, fields)
}

// 踢出联盟
func (p *actorLeague) leagueKick(session *cproto.Session, req *pb.I64) {
	var (
		opPlayerID     = sessions.GetPlayerID(session)
		targetPlayerID = req.Value
	)

	if targetPlayerID <= 0 {
		p.ResponseCode(session, code.IllegalArgument)
		return
	}

	if opPlayerID == targetPlayerID {
		p.ResponseCode(session, code.LeagueNotCanOpSelf)
		return
	}

	leagueTable, found := db.GetMapLeagueTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueNotExist)
		return
	}

	// 判断targetPlayerID是否为盟主
	if leagueTable.LeagueInfo.IsLeader(targetPlayerID) {
		p.ResponseCode(session, code.LeagueLeaderNotQuit)
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	// 判断踢出成员是否存在
	if ok := leagueMemberTable.LeagueMember.CheckMemberExist(targetPlayerID); !ok {
		p.ResponseCode(session, code.LeagueMemberNotExist)
		return
	}

	// targetPlayerID 被踢出 判断opPlayerID是否有权限
	if !leagueMemberTable.LeagueMember.CheckPermission(opPlayerID, enum.League_Permission_Member) {
		p.ResponseCode(session, code.LeaguePermissionDenied)
		return
	}

	// 弹劾中不能被踢出
	if leagueMemberTable.IsImpeachPlayer(targetPlayerID) {
		p.ResponseCode(session, code.LeagueImpeachNotKick)
		return
	}

	quitReq := &pb.I64{
		Value: p.leagueID,
	}

	// 通知map_player 玩家退出联盟
	targetPath := cfacade.NewChildPath(capp.NodeID(), nameActor.Map_Player, targetPlayerID)
	errCode := capp.Call(targetPath, nameRemote.MapLeague_QuitNotice, quitReq)
	if code.IsFail(errCode) {
		p.ResponseCode(session, errCode)
		return
	}

	// 踢出targetPlayerID
	p.doLeagueMemberQuit(leagueTable, leagueMemberTable, targetPlayerID, false)

	// 更新redis
	leagueQuitUpdateRedis(targetPlayerID)

	var (
		leagueLogTable, _ = db.GetMapLeagueLogTable(p.leagueID)
		opJobId           = cstring.ToString(leagueMemberTable.LeagueMember.GetLeagueMemberJob(opPlayerID))
		opPlayerName      = leagueMember.Service().GetPlayerName(opPlayerID)
		targetPlayerName  = leagueMember.Service().GetPlayerName(targetPlayerID)
	)

	// 写入日志
	leagueLogTable.AddLeagueLog(enum.Log_LeagueKick, opJobId, opPlayerName, targetPlayerName)

	p.ResponseCode(session, code.OK)
}

// 执行加入联盟
func (p *actorLeague) doLeagueMemberJoin(leagueTable *db.MapLeagueTable, leagueMemberTable *db.MapLeagueMemberTable, joinPlayerIDs ...int64) {
	if len(joinPlayerIDs) <= 0 {
		return
	}

	for _, joinPlayerID := range joinPlayerIDs {
		// 更新联盟成员列表
		leagueMemberTable.LeagueMember.LeagueJoin(joinPlayerID)

		// 写入日志
		p.addLeagueLog(enum.Log_LeagueJoin, joinPlayerID)

		session, found := sessions.GetSession(joinPlayerID)
		if !found {
			continue
		}

		// 推送通知
		mapFacade.LeagueServicePush(p.leagueTable, session)
	}

	// 更新联盟信息中的成员数量
	leagueTable.LeagueInfo.MemberCount = leagueMemberTable.GetLeagueMemberCount()

	leagueMemberTable.Save2Queue()

	// 更新玩家联盟信息
	updateLeagueInfo2Redis(leagueTable, leagueMemberTable, joinPlayerIDs...)

	leagueBase.Service().SyncLeaguePrestigeRank(p.leagueTable, leagueMemberTable)
}

// 执行退出/踢出联盟
func (p *actorLeague) doLeagueMemberQuit(leagueTable *db.MapLeagueTable, leagueMemberTable *db.MapLeagueMemberTable, targetPlayerID int64, quit bool) {
	// 成员退出/踢出
	if ok := leagueMemberTable.MemberQuitOrKick(targetPlayerID, quit); !ok {
		return
	}

	// 如果存在转让数据 清除
	if leagueMemberTable.Transfer.PlayerID == targetPlayerID {
		leagueMemberTable.SetLeagueTransfer(0, 0)
	}

	// 更新联盟当前人数
	leagueTable.LeagueInfo.MemberCount = leagueMemberTable.GetLeagueMemberCount()
	// 删除玩家入驻信息 如果存在 并通知所有成员
	if ok := leagueTable.RemoveResidence(targetPlayerID); ok {
		p.LeagueResidenceRemoveNotice(leagueMemberTable.GetLeagueMemberIDs(), targetPlayerID)
	}

	leagueTable.Save2Queue()
	leagueMemberTable.Save2Queue()

	// 同步联盟声望
	leagueBase.Service().SyncLeaguePrestigeRank(p.leagueTable, leagueMemberTable)
}

func (p *actorLeague) addLeagueLog(logID int32, playerID int64) {
	// 写入加入日志
	var (
		leagueLogTable, _ = db.GetMapLeagueLogTable(p.leagueID)
		playerName        = leagueMember.Service().GetPlayerName(playerID)
	)

	leagueLogTable.AddLeagueLog(logID, playerName)
}

// 检测弹劾是否结束
func (p *actorLeague) CheckLeagueImpeachEnd(leagueMemberTable *db.MapLeagueMemberTable) {
	var (
		agreeCount  = int32(len(leagueMemberTable.Impeach.AgreePlayerIDs))
		rejectCount = int32(len(leagueMemberTable.Impeach.RejectPlayerIDs))
		newLeaderID = leagueMemberTable.Impeach.PlayerID
		needCount   = leagueMemberTable.Impeach.Total / 2
		isEnd       = false
	)

	// 弹劾成功
	if rejectCount < agreeCount && agreeCount > needCount {
		// 盟主转换
		leagueTable, found := db.GetMapLeagueTable(p.leagueID)
		if !found {
			cherryLogger.Warnf("league impeach finish fail, league not found. leagueID:%d", p.leagueID)
			return
		}

		oldLeaderID := leagueTable.LeagueInfo.LeaderID
		leagueTable.LeagueInfo.LeaderID = newLeaderID

		// 如果弹劾玩家存在职位 需要先卸载职位
		jobIDs := leagueMemberTable.Resigned(newLeaderID)
		// 设置职位
		if len(jobIDs) > 0 {
			leagueMemberTable.SetLeagueMemberJob(jobIDs[0], newLeaderID)
		}

		leagueTable.Save2Queue()

		// 通知玩家职位变更
		p.PermissionChangePush(leagueMemberTable, oldLeaderID, newLeaderID)

		// 更新redis
		updateLeagueInfo2Redis(leagueTable, leagueMemberTable, oldLeaderID, newLeaderID)
		isEnd = true
	}

	// 弹劾失败
	if agreeCount < rejectCount && rejectCount > needCount/2 {
		isEnd = true
	}

	if isEnd {
		leagueMemberTable.LeagueImpeachClear(newLeaderID)

		leagueMemberTable.Save2Queue()
	}
}

// 判断联盟成员是否可以进行弹劾
func (p *actorLeague) CheckLeagueMemberCanImpeach(leagueMemeberTable *db.MapLeagueMemberTable, playerID int64, impeachTime int64) bool {
	leagueMember, found := leagueMemeberTable.LeagueMember.GetLeagueMember(playerID)
	if !found {
		return false
	}

	// 弹劾投票所需入盟时间
	needTime := data.Const.LeagueImpeachMemberTime * ctime.SecondsPerHour
	// 玩家加入联盟时间超出x小时
	if impeachTime-leagueMember.JoinTime < needTime {
		return false
	}

	// TODO 玩家个人声望大于xxx

	return true
}

func (p *actorLeague) getLeagueImpeachVoteCount(leaderID int64, leagueMemberTable *db.MapLeagueMemberTable, impeachTime int64) int32 {
	total := int32(0)
	// 弹劾投票所需入盟时间
	var (
		needTime = data.Const.LeagueImpeachMemberTime * ctime.SecondsPerHour
		// TODO 后续接入声望开启
		//needPrestige = data.Const.LeagueImpeachMemberPrestige
		playerIDs = []int64{}
	)

	for playerID, member := range leagueMemberTable.Members {
		// 排除盟主
		if leaderID != playerID && impeachTime-member.JoinTime >= needTime {
			playerIDs = append(playerIDs, playerID)
		}
	}

	if len(playerIDs) > 0 {
		playerDataMap := redis.Game.GetPlayerDataMap(playerIDs, nameRedis.PlayerBaseFields...)
		for _, playerID := range playerIDs {
			playerData, found := playerDataMap[playerID]
			// TODO redis获取玩家声望 判断玩家声望是否满足 现在暂时使用等级判断
			if found && playerData.LordLevel >= 0 {
				total++
			}
		}
	}

	return total
}

func (p *actorLeague) JobPush(playerID int64) {
	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		return
	}

	jobID := leagueMemberTable.LeagueMember.GetLeagueMemberJob(playerID)

	// 没有职位
	if jobID <= 0 {
		return
	}

	session, found := sessions.GetSession(playerID)
	if !found {
		p.Warn("push player job fail, Session not found. playerID:%d", playerID)
		return
	}

	permissions, _ := leagueMemberTable.GetJobPermissions(jobID)
	resp := &pb.LeagueJob{
		Job:         jobID,
		Permissions: permissions,
	}

	sessions.PushWithSession(session, nameRoute.PushLeague_JobInfo, resp)
}

func (p *actorLeague) PermissionChangePush(leagueMemberTable *db.MapLeagueMemberTable, playerIDs ...int64) {
	if len(playerIDs) <= 0 {
		return
	}

	for _, playerID := range playerIDs {
		session, found := sessions.GetSession(playerID)
		if !found {
			continue
		}

		resp := &pb.LeagueJob{
			Job: leagueMemberTable.GetLeagueMemberJob(playerID),
		}

		// 获取职位权限列表
		if resp.Job > 0 {
			permissions, _ := leagueMemberTable.GetJobPermissions(resp.Job)
			resp.Permissions = permissions
		}

		sessions.PushWithSession(session, nameRoute.PushLeague_JobChange, resp)
	}
}

// 获取联盟成员战绩信息
func (p *actorLeague) leagueMemberRecord(session *cproto.Session, req *pb.I64) {
	targetPlayerID := req.Value

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		p.ResponseCode(session, code.LeagueMembersEmpty)
		return
	}

	leagueMember, found := leagueMemberTable.GetLeagueMember(targetPlayerID)
	if !found {
		p.ResponseCode(session, code.LeagueMemberNotExist)
		return
	}

	resp := &pb.LeagueMemberRecordInfo{
		PlayerID: targetPlayerID,
	}

	playerData := redis.Game.GetPlayerData(targetPlayerID, nameRedis.PlayerBaseFields...)
	if playerData != nil {
		resp.PlayerName = playerData.PlayerName
		resp.LordLevel = playerData.LordLevel
		resp.IconID = playerData.IconID
		resp.FrameID = playerData.FrameID
		resp.Job = leagueMemberTable.GetLeagueMemberJob(targetPlayerID)
	}

	curWeek := leagueMember.GetLeagueMemberRecordWeek()
	for week, record := range leagueMember.RecordMap {
		diff := curWeek - week
		if diff < 0 {
			diff = -diff
		}

		// 过期周跳过
		if diff >= constant.LeagueMamberRecordWeekLimit {
			continue
		}

		resp.Records[diff] = record.ToMemberRecordProto()
	}

	p.Response(session, resp)
}

// 更新联盟成员战绩
func (p *actorLeague) leagueMemberRecordUpdate(req *pb.LeagueMemberRecordUpdateList) {
	list := req.List
	if len(list) <= 0 {
		return
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(p.leagueID)
	if !found {
		return
	}

	for _, playerRecord := range list {
		var (
			playerID = playerRecord.PlayerID
			records  = playerRecord.Records
		)

		leagueMember, found := leagueMemberTable.GetLeagueMember(playerID)
		if !found {
			continue
		}

		leagueMember.UpdateMemberRecords(records)
	}
}

// 获取联盟管理列表
func (p *actorLeague) leagueManagerList(req *pb.I64) (*pb.LeagueMembers, int32) {
	var (
		leagueID  = req.Value
		playerIDs = []int64{}
		resp      = &pb.LeagueMembers{
			List: []*pb.LeagueMember{},
		}
	)

	_, found := db.GetMapLeagueTable(leagueID)
	if !found {
		return nil, code.LeagueNotExist
	}

	leagueMemberTable, found := db.GetMapLeagueMemberTable(leagueID)
	if !found {
		return nil, code.LeagueMembersEmpty
	}

	jobs := leagueMemberTable.LeagueJob.Jobs
	for jobID, playerID := range jobs {
		leagueMember := &pb.LeagueMember{
			Job:      jobID,
			PlayerID: playerID,
		}
		playerIDs = append(playerIDs, playerID)
		resp.List = append(resp.List, leagueMember)
	}

	if len(playerIDs) > 0 {
		playerDataMap := redis.Game.GetPlayerDataMap(playerIDs, nameRedis.PlayerBaseFields...)
		if playerDataMap != nil {
			for _, leagueMember := range resp.List {
				playerData, found := playerDataMap[leagueMember.PlayerID]
				if found {
					leagueMember.PlayerName = playerData.PlayerName
				}
			}
		}
	}

	return resp, code.OK
}