game2006go/server/imserver/guildmgr.go

package main

import (
	"cs"
	"f5"
	"fmt"
	"math/rand"
	"q5"
)

const (
	LoadGuildFlag = iota
	LoadGuildMemberFlag
	LoadGuildReqFlag
	LoadGuildLogFlag
)

type GuildMgr struct {
	cs.MsgHandlerImpl
	guildIds    []int64               // 公会列表 guild ids
	guilds      map[int64]*Guild      // 公会ID -> 公会
	guildLogs   map[int64][]*GuildLog // 公会ID -> []公会日志列表
	userGuilds  map[string]int64      //  accountId -> 公会ID
	loadedFlags int64
}

func NewGuildMgr() *GuildMgr {
	return &GuildMgr{
		guilds:     make(map[int64]*Guild),
		guildLogs:  make(map[int64][]*GuildLog),
		userGuilds: make(map[string]int64),
	}
}

func (gm *GuildMgr) init() {
	gm.loadFromDB()
}

func (gm *GuildMgr) loadFromDB() {
	q5.SetBitFlag(&gm.loadedFlags, LoadGuildFlag)
	q5.SetBitFlag(&gm.loadedFlags, LoadGuildMemberFlag)
	q5.SetBitFlag(&gm.loadedFlags, LoadGuildReqFlag)
	q5.SetBitFlag(&gm.loadedFlags, LoadGuildLogFlag)

	// 加载公会
	gm.loadGuildFromDB()
	// 加载公会成员
	gm.loadGuildMemberFromDB()
	// 加载公会申请者列表
	gm.loadPendingReqsFromDB()
	// 加载公会日志
	gm.loadGuildLogsFromDB()
	// 加载公会ids
	gm.loadGuildIds()
	//for gm.loadedFlags != 0 {
	//	time.Sleep(time.Millisecond * 1000)
	//}
}

// CreateGuild 创建公会
func (gm *GuildMgr) CreateGuild(name string, leaderId string,
	cb func(errCode int32, errMsg string, guildId int64)) {
	if !gm.CheckJoinGuild(leaderId) {
		cb(ERR_CODE_JOINED_GUILD, "Joined  guild", 0)
		return
	}

	guildId := f5.GetApp().NewUuid()
	if gm.ExistsGuild(guildId) {
		cb(ERR_CODE_CREATE_GUILD_FAIL, "create error ", 0)
		return
	}

	fields := [][]string{
		{"guild_id", q5.ToString(guildId)},
		{"name", name},
		{"leader_account_id", leaderId},
		{"max_members", q5.ToString(MaxMembers)},
	}
	f5.GetJsStyleDb().Insert(
		FRIEND_DB,
		"t_guild",
		fields,
		func(err error, id int64, affectedRows int64) {
			if err != nil {
				cb(ERR_CODE_CREATE_GUILD_DB_FAIL, "create guild db error ", 0)
				return
			}
			newMember := &GuildMember{AccountId: leaderId, Level: GuildMemberLevelLeader}
			gm.upsertGuildMember(guildId, newMember,
				func(err error) {
					if err != nil {
						cb(ERR_CODE_CREATE_GUILD_MEMBER_DB_FAIL, "create guild member db error", 0)
						return
					}
					guild := &Guild{
						AutoId:     id,
						GuildId:    guildId,
						Name:       name,
						LeaderId:   leaderId,
						MaxMembers: MaxMembers,
					}
					guild.Members = append(guild.Members, newMember)
					gm.AddGuild(guildId, guild)
					// Add event
					prop := make(map[string]string)
					prop["auto_id"] = q5.ToString(id)
					prop["guild_id"] = q5.ToString(guildId)
					prop["guild_name"] = name
					f5.GetTgLog().AddTrackLog(
						GAME_ID,
						leaderId,
						"127.0.0.1",
						EVENT_CREATE,
						prop,
					)
					cb(ERR_CODE_OK, "Create OK", guildId)
				})
		})
}

// ApplyToGuild 申请加入公会
func (gm *GuildMgr) ApplyToGuild(guildId int64, applicantAccountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuild(guildId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "ApplyToGuild guild no exists")
		return
	}
	// 是否加入其他公会
	if !gm.CheckJoinGuild(applicantAccountId) {
		cb(ERR_CODE_JOINED_GUILD, "ApplyToGuild joined guild")
		return
	}

	if guild.IsFull() {
		cb(ERR_CODE_GUILD_MEMBER_FULL, "ApplyToGuild guild member full")
		return
	}
	// 可直接加入
	if guild.JoinCond == JoinCondFree {
		gm.JoinGuild(guild, applicantAccountId)
		cb(ERR_CODE_OK, "ApplyToGuild OK")
		return
	}

	if guild.JoinCond == JoinCondStar {
		var userStar int32 = 200
		if userStar >= guild.JoinCondValue {
			gm.JoinGuild(guild, applicantAccountId)
			cb(ERR_CODE_OK, "ApplyToGuild OK")
			return
		}
	}

	// IF exists, then replace it fields `isJoinGuild` is 0
	where := [][]string{
		{"guild_id", q5.ToString(guildId)},
		{"account_id", applicantAccountId},
	}
	insertKv := [][]string{
		{"guild_id", q5.ToString(guildId)},
		{"account_id", applicantAccountId},
		{"is_join_guild", q5.ToString(PendingReqIsJoinGuildStatusDefault)},
	}
	updateKv := [][]string{
		{"is_join_guild", q5.ToString(PendingReqIsJoinGuildStatusDefault)},
	}
	f5.GetJsStyleDb().Upsert(
		FRIEND_DB,
		"t_guild_pending_request",
		where,
		updateKv,
		insertKv,
		func(err error, lastInsertId int64, rowsAffected int64) {
			if err != nil || rowsAffected <= 0 {
				cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "ApplyToGuild guild pending request db error")
				return
			}

			pendingReq := &PendingReq{
				applicantAccountId,
				PendingReqIsJoinGuildStatusDefault,
			}
			guild.AddPendingReq(pendingReq)

			// Add event
			prop := make(map[string]string)
			prop["guild_id"] = q5.ToString(guildId)
			prop["join_cond"] = q5.ToString(guild.JoinCond)
			f5.GetTgLog().AddTrackLog(
				GAME_ID,
				applicantAccountId,
				"127.0.0.1",
				EVENT_APPLY,
				prop,
			)

			cb(ERR_CODE_OK, "ApplyToGuild ok")
		})
}

// Approve 同意申请者加入公会
func (gm *GuildMgr) Approve(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "Approve guild no exists")
		return
	}

	// 默认为审核加入
	if guild.JoinCond != JoinCondDefault {
		cb(ERR_CODE_JOINED_GUILD, "Approve joined guild")
		return
	}

	// 公会干部及以上仅可操作
	operatorMember := guild.GetMember(operatorAccountId)
	err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
	if err != nil {
		cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "Approve operator member no perm")
		return
	}

	// 是否加入其他公会
	if !gm.CheckJoinGuild(accountId) {
		cb(ERR_CODE_JOINED_GUILD, "Approve joined guild")
		return
	}

	guildId := guild.GuildId
	// 是否在申请队列中
	pendingReqStatus := guild.GetPendingReqStatus(accountId)
	if pendingReqStatus < 0 {
		cb(ERR_CODE_GUILD_PENDING_REQUEST_NO_EXISTS, "Approve pending request no exists")
		return
	}

	if guild.IsFull() {
		cb(ERR_CODE_GUILD_MEMBER_FULL, "Approve guild member full")
		return
	}
	newMember := &GuildMember{AccountId: accountId, Level: GuildMemberLevelDefault}
	gm.upsertGuildMember(guildId, newMember, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, "Approve update guild member db error")
			return
		}
		guild.AddMember(newMember)
		gm.AddUserGuild(accountId, guildId)
		gm.updatePendingReqs(guildId, accountId, PendingReqIsJoinGuildStatusJoined, func(err error) {
			if err != nil {
				cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "Approve db error")
				return
			}

			logContent := fmt.Sprintf("Approve[operator:%s]", operatorAccountId)
			gm.WriteLog(guildId, accountId, LogTypeApprove, logContent)
			guild.RemovePendingReq(accountId)
			// Add event
			prop := make(map[string]string)
			prop["guild_id"] = q5.ToString(guildId)
			prop["applicant_account_id"] = q5.ToString(accountId)
			prop["members_count"] = q5.ToString(guild.GetMembersCount())
			f5.GetTgLog().AddTrackLog(
				GAME_ID,
				operatorAccountId,
				"127.0.0.1",
				EVENT_APPROVE,
				prop,
			)

			cb(ERR_CODE_OK, "Approve ok")
		})
	})
}

// Reject 拒绝申请者加入公会
func (gm *GuildMgr) Reject(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "Reject guild no exists")
		return
	}
	// 通常默认为审核加入
	if guild.JoinCond != JoinCondDefault {
		cb(ERR_CODE_JOINED_GUILD, "Reject joined guild")
		return
	}

	// 公会干部及以上仅可操作
	operatorMember := guild.GetMember(operatorAccountId)
	err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
	if err != nil {
		cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "Reject operator member no perm")
		return
	}
	// 是否加入其他公会
	if !gm.CheckJoinGuild(accountId) {
		cb(ERR_CODE_JOINED_GUILD, "Reject joined guild")
		return
	}
	// 是否在申请队列中
	pendingReqStatus := guild.GetPendingReqStatus(accountId)
	if pendingReqStatus < 0 {
		cb(ERR_CODE_GUILD_PENDING_REQUEST_NO_EXISTS, "Reject pending request no exists")
		return
	}

	gm.updatePendingReqs(guild.GuildId, accountId, PendingReqIsJoinGuildStatusReject, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, "Reject db error")
			return
		}

		guild.RemovePendingReq(accountId)
		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["reject_account_id"] = q5.ToString(accountId)
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_REJECT,
			prop,
		)

		cb(ERR_CODE_OK, "Reject ok")
	})
}

// JoinGuild 直接加入公会
func (gm *GuildMgr) JoinGuild(guild *Guild, accountId string) {
	newMember := GuildMember{AccountId: accountId, Level: GuildMemberLevelDefault}
	guildId := guild.GuildId
	gm.upsertGuildMember(guildId, &newMember,
		func(err error) {
			if err != nil {
				guild.AddMember(&newMember)
				gm.AddUserGuild(accountId, guildId)

				// Add event
				prop := make(map[string]string)
				prop["guild_id"] = q5.ToString(guild.GuildId)
				prop["members_count"] = q5.ToString(guild.GetMembersCount())
				f5.GetTgLog().AddTrackLog(
					GAME_ID,
					accountId,
					"127.0.0.1",
					EVENT_JOIN,
					prop,
				)
			}
		})
}

// LeaveGuild 离开公会
func (gm *GuildMgr) LeaveGuild(accountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(accountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "LeaveGuild guild no exists")
		return
	}
	if guild.LeaderId == accountId {
		cb(ERR_CODE_GUILD_BLOCKED_LEADER, "LeaveGuild Blocked leader")
		return
	}
	member := guild.GetMember(accountId)
	if member == nil {
		cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists")
		return
	}

	fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
	gm.updateGuildMember(guild, member.AccountId, fields,
		func(err error) {
			if err != nil {
				cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
				return
			}

			guild.RemoveMember(accountId)
			gm.RemoveUserGuild(accountId)
			// Add logs
			logContent := fmt.Sprintf("LeaveGuild[%d-%s]", guild.GuildId, accountId)
			gm.WriteLog(guild.GuildId, accountId, LogTypeLeave, logContent)

			// Add event
			prop := make(map[string]string)
			prop["guild_id"] = q5.ToString(guild.GuildId)
			prop["members_count"] = q5.ToString(guild.GetMembersCount())
			f5.GetTgLog().AddTrackLog(
				GAME_ID,
				accountId,
				"127.0.0.1",
				EVENT_LEAVE,
				prop,
			)

			cb(ERR_CODE_OK, "LeaveGuild OK")
		})
}

// DismissMember 开除成员 踢出
func (gm *GuildMgr) DismissMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "DismissMember guild no exists")
		return
	}

	if accountId == guild.LeaderId || accountId == operatorAccountId {
		cb(ERR_CODE_GUILD_BLOCKED_LEADER, "DismissMember Blocked leader")
		return
	}

	// 公会干部及以上仅可操作
	operatorMember := guild.GetMember(operatorAccountId)
	err := gm.CheckOperatorPerm(operatorMember, GuildMemberLevelViceLeader)
	if err != nil {
		cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "DismissMember operator member no perm")
		return
	}

	dismissMember := guild.GetMember(accountId)
	if dismissMember == nil {
		cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists")
		return
	}

	if dismissMember.Level <= operatorMember.Level {
		cb(ERR_CODE_GUILD_DISMISS_MEMBER_NO_PERM, "Approve dismiss member no perm")
		return
	}

	fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
	gm.updateGuildMember(guild, dismissMember.AccountId, fields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
			return
		}

		guild.RemoveMember(accountId)
		gm.RemoveUserGuild(accountId)
		// Add logs
		logContent := fmt.Sprintf("DismissMember[%d-%s-%s]", guild.GuildId, operatorAccountId, accountId)
		gm.WriteLog(guild.GuildId, accountId, LogTypeDismiss, logContent)

		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["accountId"] = q5.ToString(accountId)
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_DISMISS_MEMBER,
			prop,
		)

		cb(ERR_CODE_OK, "DismissMember OK")
	})
}

// SetMemberLevel 设置公会成员等级
func (gm *GuildMgr) SetMemberLevel(operatorAccountId, accountId string, level int32, cb func(errCode int32, errMsg string)) {
	// 干部, 精英, 副会长
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "PromoteMember guild no exists")
		return
	}

	if accountId == guild.LeaderId || accountId == operatorAccountId {
		cb(ERR_CODE_GUILD_BLOCKED_LEADER, "PromoteMember Blocked leader")
		return
	}

	// 仅会长操作
	member := guild.GetMember(accountId)
	if member == nil {
		cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists")
		return
	}

	beforeLevel := member.Level
	if member.Level == level {
		cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "LeaveGuild error")
		return
	}

	fields := [][]string{{"level", q5.ToString(level)}}
	gm.updateGuildMember(guild, member.AccountId, fields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
			return
		}

		member.Level = level
		logContent := fmt.Sprintf("SetMemberLevel[%d-%s-%s-%d-%d]", guild.GuildId, operatorAccountId, accountId, beforeLevel, level)
		gm.WriteLog(guild.GuildId, accountId, LogTypePromote, logContent)

		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["accountId"] = q5.ToString(accountId)
		prop["beforeMemberLevel"] = q5.ToString(beforeLevel)
		prop["afterMemberLevel"] = q5.ToString(level)
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_PROMOTE_MEMBER,
			prop,
		)

		cb(ERR_CODE_OK, "SetMemberLevel OK")
	})
}

// PromoteMember 提升成员为干部
func (gm *GuildMgr) PromoteMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
	// 干部, 精英, 副会长
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "PromoteMember guild no exists")
		return
	}

	if accountId == guild.LeaderId || accountId == operatorAccountId {
		cb(ERR_CODE_GUILD_BLOCKED_LEADER, "PromoteMember Blocked leader")
		return
	}

	// 仅会长操作
	if operatorAccountId != guild.LeaderId {
		cb(ERR_CODE_GUILD_NO_LEADER_PERM, "PromoteMember only leader perm")
		return
	}

	member := guild.GetMember(accountId)
	if member == nil {
		cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "LeaveGuild member no exists")
		return
	}

	if member.Level == GuildMemberLevelViceLeader {
		cb(ERR_CODE_GUILD_OPERATOR_MEMBER_NO_PERM, "LeaveGuild error")
		return
	}

	fields := [][]string{{"level", q5.ToString(GuildMemberLevelViceLeader)}}
	gm.updateGuildMember(guild, member.AccountId, fields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
			return
		}

		member.Level = GuildMemberLevelViceLeader
		logContent := fmt.Sprintf("PromoteMember[%d-%s-%s]", guild.GuildId, operatorAccountId, accountId)
		gm.WriteLog(guild.GuildId, accountId, LogTypePromote, logContent)

		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["accountId"] = q5.ToString(accountId)
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_PROMOTE_MEMBER,
			prop,
		)

		cb(ERR_CODE_OK, "PromoteMember OK")
	})
}

// DemoteMember 解除成员干部身份
func (gm *GuildMgr) DemoteMember(operatorAccountId, accountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "DemoteMember guild no exists")
		return
	}

	if accountId == guild.LeaderId || accountId == operatorAccountId {
		cb(ERR_CODE_GUILD_BLOCKED_LEADER, "DemoteMember Blocked leader")
		return
	}

	// 仅会长可操作
	if operatorAccountId != guild.LeaderId {
		cb(ERR_CODE_GUILD_NO_LEADER_PERM, "DemoteMember only leader perm")
		return
	}

	member := guild.GetMember(accountId)
	if member == nil {
		cb(ERR_CODE_GUILD_MEMBER_NO_EXISTS, "DemoteMember member no exists")
		return
	}

	if member.Level == GuildMemberLevelDefault {
		cb(ERR_CODE_GUILD_DEMOTE_MEMBER_OK, "DemoteMember member ok")
		return
	}

	fields := [][]string{{"level", q5.ToString(GuildMemberLevelDefault)}}
	gm.updateGuildMember(guild, member.AccountId, fields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
			return
		}

		member.Level = GuildMemberLevelDefault
		logContent := fmt.Sprintf("DemoteMember[%d-%s-%s]", guild.GuildId, operatorAccountId, accountId)
		gm.WriteLog(guild.GuildId, accountId, LogTypeDemote, logContent)

		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["accountId"] = q5.ToString(accountId)
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_DEMOTE_MEMBER,
			prop,
		)

		cb(ERR_CODE_OK, "DemoteMember OK")
	})
}

// Disband 解散公会
func (gm *GuildMgr) Disband(operatorAccountId string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "Disband guild no exists")
		return
	}

	// 仅会长可操作
	if operatorAccountId != guild.LeaderId {
		cb(ERR_CODE_GUILD_NO_LEADER_PERM, "PromoteMember only leader perm")
		return
	}
	guildId := guild.GuildId
	guildName := guild.Name

	// 解散公会
	updateFields := [][]string{
		{"is_deleted", q5.ToString(1)},
	}
	gm.updateGuild(guild, updateFields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
			return
		}
		fields := [][]string{{"is_leave_guild", q5.ToString(1)}}
		gm.updateGuildMembers(guildId, fields, func(err error) {
			if err != nil {
				cb(ERR_CODE_UPDATE_GUILD_MEMBER_DB_FAIL, err.Error())
				return
			}
			gm.updateAllPendingReqs(guildId, PendingReqIsJoinGuildStatusDisband, func(err error) {
				if err != nil {
					cb(ERR_CODE_UPDATE_GUILD_PENDING_REQUEST_DB_FAIL, err.Error())
					return
				}
				logContent := fmt.Sprintf("GuildDisbanded[%d-%s]", guildId, guildName)
				gm.WriteLog(guildId, operatorAccountId, LogTypeDisband, logContent)

				// delete user guilds
				for _, member := range guild.Members {
					delete(gm.userGuilds, member.AccountId)
				}
				guild.Members = nil
				delete(gm.guilds, guildId)
				delete(gm.guildLogs, guildId)
				gm.RemoveGuild(guildId)

				// Add event
				prop := make(map[string]string)
				prop["guild_id"] = q5.ToString(guild.GuildId)
				f5.GetTgLog().AddTrackLog(
					GAME_ID,
					operatorAccountId,
					"127.0.0.1",
					EVENT_DISBAND,
					prop,
				)

				cb(ERR_CODE_OK, "Disband ok")
			})
		})
	})
}

// SetNotice 设置公告
func (gm *GuildMgr) SetNotice(operatorAccountId string, notice *string, cb func(errCode int32, errMsg string)) {
	guild := gm.GetGuildByAccountId(operatorAccountId)
	if guild == nil {
		cb(ERR_CODE_GUILD_NO_EXISTS, "SetNotice guild no exists")
		return
	}

	// 仅会长可操作
	if operatorAccountId != guild.LeaderId {
		cb(ERR_CODE_GUILD_NO_LEADER_PERM, "SetNotice only leader perm")
		return
	}

	updateFields := [][]string{
		{"notice", *notice},
	}
	gm.updateGuild(guild, updateFields, func(err error) {
		if err != nil {
			cb(ERR_CODE_UPDATE_GUILD_DB_FAIL, err.Error())
			return
		}
		beforeNotice := &guild.Notice
		guild.SetNotice(notice)

		// Add event
		prop := make(map[string]string)
		prop["guild_id"] = q5.ToString(guild.GuildId)
		prop["before_notice"] = *beforeNotice
		prop["after_notice"] = *notice
		prop["members_count"] = q5.ToString(guild.GetMembersCount())
		f5.GetTgLog().AddTrackLog(
			GAME_ID,
			operatorAccountId,
			"127.0.0.1",
			EVENT_SET_NOTICE,
			prop,
		)

		cb(ERR_CODE_OK, "SetNotice OK")
	})
}

// WriteLog 记录公会日志
func (gm *GuildMgr) WriteLog(guildId int64, accountId string, logType int32, content string) {
	guild := gm.GetGuild(guildId)
	if guild == nil {
		return
	}

	_, exists := gm.guildLogs[guildId]
	if !exists {
		gm.guildLogs[guildId] = make([]*GuildLog, DefaultLogs)
	}
	log := &GuildLog{
		GuildId:   guildId,
		AccountId: accountId,
		LogType:   logType,
		Content:   content,
	}
	gm.guildLogs[guildId] = append(gm.guildLogs[guildId], log)
	gm.insertGuildLog(log)
}

func (gm *GuildMgr) GetLogs(guildID int64) []*GuildLog {
	return gm.guildLogs[guildID]
}

// SearchGuilds 根据关键字搜索公会
func (gm *GuildMgr) SearchGuilds(keyword string) []*Guild {
	var results []*Guild
	for _, guild := range gm.guilds {
		if containsSubstring(guild.Name, keyword) {
			results = append(results, guild)
		}
	}
	return results
}

// RandomGuilds 随机10个公会
func (gm *GuildMgr) RandomGuilds() []*Guild {
	count := len(gm.guilds)

	var results []*Guild
	if count <= RandomGuildCount {
		for _, guildId := range gm.guildIds {
			results = append(results, gm.guilds[guildId])
		}
		return results
	}

	for i := 0; i < RandomGuildCount; i++ {
		j := rand.Intn(len(gm.guildIds))
		gm.guildIds[i], gm.guildIds[j] = gm.guildIds[j], gm.guildIds[i]
	}
	for i := 0; i < RandomGuildCount; i++ {
		randGuildId := gm.guildIds[i]
		results = append(results, gm.guilds[randGuildId])
	}
	return results
}

func (gm *GuildMgr) CheckOperatorPerm(operatorMember *GuildMember, level int32) error {
	if operatorMember == nil || operatorMember.Level > level {
		return fmt.Errorf("CheckOperatorPerm: no permission[%s-%d]", operatorMember.AccountId, operatorMember.Level)
	}
	return nil
}

func (gm *GuildMgr) ExistsGuild(guildId int64) bool {
	_, ok := gm.guilds[guildId]
	return ok
}

func (gm *GuildMgr) AddUserGuild(accountId string, guildId int64) {
	gm.userGuilds[accountId] = guildId
}

func (gm *GuildMgr) RemoveUserGuild(accountId string) {
	delete(gm.userGuilds, accountId)
}

func (gm *GuildMgr) AddGuild(guildId int64, guild *Guild) {
	if _, exists := gm.guilds[guildId]; !exists {
		gm.guilds[guildId] = guild
		gm.guildIds = append(gm.guildIds, guildId)
	}
}

func (gm *GuildMgr) GetGuild(guildId int64) *Guild {
	if guild, exists := gm.guilds[guildId]; exists {
		return guild
	}
	return nil
}

func (gm *GuildMgr) GetGuildByAccountId(accountId string) *Guild {
	if guildId, exists := gm.userGuilds[accountId]; exists {
		if guild, exists2 := gm.guilds[guildId]; exists2 {
			return guild
		}
	}
	return nil
}

func (gm *GuildMgr) GetGuildIdByAccountId(accountId string) int64 {
	if guildId, exists := gm.userGuilds[accountId]; exists {
		return guildId
	}
	return -1
}

func (gm *GuildMgr) CheckJoinGuild(accountId string) bool {
	_, exists := gm.userGuilds[accountId]
	return exists
}

func (gm *GuildMgr) loadGuildIds() {
	gm.guildIds = make([]int64, 0, len(gm.guilds))
	for guildId := range gm.guilds {
		gm.guildIds = append(gm.guildIds, guildId)
	}
}

func (gm *GuildMgr) RemoveGuild(guildId int64) {
	guildIndex := -1
	for i, gId := range gm.guildIds {
		if gId == guildId {
			guildIndex = i
		}
	}
	if guildIndex < 0 {
		return
	}
	copy(gm.guildIds[guildIndex:], gm.guildIds[guildIndex+1:])
	gm.guildIds[len(gm.guildIds)-1] = 0
	gm.guildIds = gm.guildIds[:len(gm.guildIds)-1]
}

func (gm *GuildMgr) GetGuildLogs(guildId int64) []*GuildLog {
	if logs, exists := gm.guildLogs[guildId]; exists {
		return logs
	}
	return nil
}

func containsSubstring(s, substr string) bool {
	return len(s) >= len(substr) && s[len(s)-len(substr):] == substr
}