entry

type Coder interface {
	// Encode encodes current object to a byte array
	Encode() ([]byte, error)
	// Decode decodes a byte array to current object
	Decode(data []byte) error
}

type Factory interface {
	CreateRoom(mgr *Mgrs, base *RoomBase) (Room, error)
	CreatePlayer(mgr *Mgrs, base *PlayerBase, pInfo *pto.PlayerInfo) (Player, error)
	CreateTeam(mgr *Mgrs, base *TeamBase) (Team, error)
	CreateGroup(mgr *Mgrs, base *GroupBase) (Group, error)
}

type Group interface {
	Coder
	Jsoner

	// ID returns the unique group id.
	ID() int64

	// Base returns the base information of the group.
	// Here we define a concrete struct `GroupBase`
	// to hold the common fields to avoid lots getter and setter method.
	Base() *GroupBase

	// IsFull checks if the group is full.
	IsFull() bool

	// SetCaptain sets the captain of the group.
	SetCaptain(string)

	// GetCaptain returns the captain in the group.
	GetCaptain() string

	// CanPlayTogether checks if the player can play with the group's players.
	CanPlayTogether(*pto.PlayerInfo) error

	// GetPlayerInfos returns the player infos of the group.
	// This method usually used for sync group info to client.
	GetGroupInfo() *pto.GroupInfo

	// CanStartMatch checks if the group can start to match.
	// Maybe some game mode need to check if the group is full or not.
	// Maybe some game mode need all players to be ready.
	// If you have some special logics, please override this method.
	CanStartMatch() error

	// GetStartMatchTimeSec returns the start match time of the group.
	GetStartMatchTimeSec() int64

	// SetStartMatchTimeSec sets the start match time of the group.
	SetStartMatchTimeSec(sec int64)

	// Json returns the json string of the group.
	// You may need to lock when marshal it to avoid data race,
	// even if in print log.
	//
	// Note: it should be implemented by the specific game mode entry.
	// TODO: any other greater way?
	Json() string
}

type GroupBase struct {
	// ReentrantLock is a reentrant L support multiple locks in the same goroutine.
	// Use it to help avoid deadlock.
	L *concurrent.ReentrantLock

	// GroupID is the unique id of the group.
	GroupID int64

	// IsAI indicates if the group is an AI group.
	IsAI bool

	// GameMode is the game mode of the group.
	GameMode constant.GameMode

	// ModeVersion is the version of the game mode of the group.
	// Only the same version of the players can be played together.
	ModeVersion int64

	// MatchStrategy is the current match strategy of the group.
	MatchStrategy constant.MatchStrategy

	// SupportMatchStrategies is the supported match strategies of the group.
	SupportMatchStrategies []constant.MatchStrategy

	// State is the current State of the group.
	State GroupState

	// Players holds the Players'ids in the group.
	Players []string

	// MatchID is a unique id to identify each match action.
	MatchID string

	// StartMatchTimeSec is the start match time of the group.
	StartMatchTimeSec int64

	// Roles holds the Roles of the players in the group.
	Roles map[string]GroupRole

	Configs GroupConfig

	// ReadyPlayer holds the unready players in the group.
	// In the project, we assume that the default does not
	// require all players to prepare to start matching,
	// so the map will be empty by default,
	// and you will need to re-initialize this field in the game mode that requires preparation
	UnReadyPlayer map[string]struct{}

	// InviteRecords holds the invite records of the group.
	// key: uid
	// value: expire time (s)
	InviteRecords map[string]int64

	// Settings holds the settings of the group.
	Settings GroupSettings
}

type GroupConfig struct {
	PlayerLimit     int
	InviteExpireSec int64
}

type GroupMgr struct {
	*collection.Manager[int64, Group]
	// contains filtered or unexported fields
}

type GroupRole int8

type GroupSettings struct {
	// NearbyJoinAllowed indicates whether nearby players can join the group.
	NearbyJoinAllowed bool

	// RecentJoinAllowed indicates whether recent players can join the group.
	RecentJoinAllowed bool
}

type GroupState int8

type Jsoner interface {
	Lock()
	Unlock()
}

type Mgrs struct {
	PlayerMgr *PlayerMgr
	GroupMgr  *GroupMgr
	TeamMgr   *TeamMgr
	RoomMgr   *RoomMgr
}

type Player interface {
	Coder
	Base() *PlayerBase
	UID() string
	GetPlayerInfo() *pto.PlayerInfo
	SetAttr(attr *pto.UploadPlayerAttr) error
}

type PlayerBase struct {
	// ReentrantLock is a reentrant L support multiple locks in the same goroutine
	// Use it to help avoid deadlock.
	L             *concurrent.ReentrantLock
	IsAI          bool
	GroupID       int64
	MatchStrategy constant.MatchStrategy

	OnlineState PlayerOnlineState
	VoiceState  PlayerVoiceState

	// TODO: other common attributes
	pto.PlayerInfo
	pto.Attribute
}

type PlayerMgr struct {
	*collection.Manager[string, Player]
}

type PlayerOnlineState int8

type PlayerVoiceState int8

type Room interface {
	Coder
	Base() *RoomBase
	ID() int64
	NeedAI() bool
	GetMatchInfo() *pto.MatchInfo
}

type RoomBase struct {
	RoomID    int64
	Teams     map[int64]struct{}
	TeamLimit int

	GameMode       constant.GameMode
	MatchStrategy  constant.MatchStrategy
	ModeVersion    int64
	FinishMatchSec int64

	EscapePlayer []string

	GameServerInfo pto.GameServerInfo
	// contains filtered or unexported fields
}

type RoomMgr struct {
	*collection.Manager[int64, Room]
	// contains filtered or unexported fields
}

type Team interface {
	Coder
	Base() *TeamBase
	ID() int64
}

type TeamBase struct {
	UniqueID      int64 // UniqueID is the global unique team id.
	TeamID        int   // TeamID is the unique team id in one room, start from 1.
	IsAI          bool
	Groups        map[int64]struct{}
	GameMode      constant.GameMode
	MatchStrategy constant.MatchStrategy
	ModeVersion   int64
	// contains filtered or unexported fields
}

type TeamMgr struct {
	*collection.Manager[int64, Team]
	// contains filtered or unexported fields
}