core

type AddContestRequest struct {
	Name        string                      `json:"Name"`
	Description string                      `json:"Description"`
	GroupID     string                      `json:"GroupID"`
	Rounds      []CreateContestRequestRound `json:"Rounds"`
	Type        string                      `json:"Type"`
	StartTime   int64                       `json:"StartTime"`
	EndTime     int64                       `json:"EndTime"`
}

type AddPreScoreRequest struct {
	AddScoreRequest
	Source   string `json:"Source"`
	Recorder string `json:"Recorder"`
}

type AddScoreRequest struct {
	PlayerID  uint               `json:"PlayerID"`
	ContestID uint               `json:"ContestID"`
	Project   model.Project      `json:"Project"`
	RoundId   uint               `json:"RoundId"`
	Result    []float64          `json:"Result"`
	Penalty   model.ScorePenalty `json:"Penalty"`
}

type Bool uint

type Client struct {
	// contains filtered or unexported fields
}

type ContestCore interface {
	AddContest(AddContestRequest) error                                               // 添加比赛
	RemoveContest(contestId uint) error                                               // 删除比赛
	GetAllContestStatics() (contests []ContestStatics)                                // 所有比赛的数据统计
	GetContest(contestId uint) (contest model.Contest, err error)                     // 获取信息
	GetContests(page, size int, typ string) (int64, []model.Contest, error)           // 获取比赛列表 （分页）
	GetContestSor(contestID uint) (single, avg map[model.SorStatisticsKey][]SorScore) // 获取比赛sor排名
	GetContestScore(contestID uint) map[model.Project][]RoutesScores                  // 获取比赛成绩列表
	GetContestPodiums(contestID uint) []Podiums                                       // 获取比赛领奖台
	GetContestRecord(contestID uint) []RecordMessage                                  // 获取比赛记录列表
}

type ContestStatics struct {
	model.Contest

	PlayerNum  int `json:"PlayerNum"`
	ProjectNum int `json:"ProjectNum"`
}

type Core interface {
	BackToFile() error
	ReSetRecords() error

	ScoreCore
	PlayerCore
	PlayerUserCore
	ContestCore
	StatisticalCore
}

type CreateContestRequestRound struct {
	Project model.Project `json:"Project"`
	Number  int           `json:"Number"`
	Part    int           `json:"Part"`
	Name    string        `json:"Name"`
	IsStart bool          `json:"IsStart"`
	Final   bool          `json:"Final"`
	Upsets  []string      `json:"Upsets"`
}

type NemesisDetail struct {
	Player model.Player                  `json:"Player,omitempty"`
	Single map[model.Project]model.Score `json:"Single,omitempty"`
	Avg    map[model.Project]model.Score `json:"Avg,omitempty"`
}

type NemesisDetails []NemesisDetail

type PlayerCore interface {
	AddPlayer(player model.Player) error                                                        // 添加玩家
	UpdatePlayer(playerId uint, player model.Player) error                                      // 更新玩家信息
	RemovePlayer(playerId uint) error                                                           // 删除玩家
	GetPlayer(playerId uint) (PlayerDetail, error)                                              // 获取玩家详细信息
	GetPlayers(page, size int) (int64, []model.Player, error)                                   // 获取玩家列表 (分页)
	GetPlayerBestScore(playerId uint) (bestSingle, bestAvg map[model.Project]RankScore)         // 获取玩家
	GetPlayerPodiums(playerID uint) Podiums                                                     // 获取玩家领奖台
	GetPlayerRecord(playerID uint) []RecordMessage                                              // 获取玩家记录
	GetPlayerScore(playerID uint) (bestSingle, bestAvg []model.Score, scores []ScoresByContest) // 获取玩家所有成绩
	GetPlayerSor(playerID uint) (single, avg map[model.SorStatisticsKey]SorScore)               // 获取玩家sor信息
	GetPlayerNemesis(playerID uint) NemesisDetails                                              // 获取玩家宿敌信息
	GetPlayerRelativeSor(playerID uint) map[model.SorStatisticsKey]RelativeSor                  // 获取单个玩家的相对排位分
}

type PlayerDetail struct {
	model.Player

	ContestNumber       int `json:"ContestNumber,omitempty"`
	ValidRecoveryNumber int `json:"ValidRecoveryNumber,omitempty"`
	RecoveryNumber      int `json:"RecoveryNumber,omitempty"`
}

type PlayerUserCore interface {
	GetPlayerUser(player model.Player) model.PlayerUser                // 获取一个玩家的用户信息
	AddPlayerUser(player model.Player, user model.PlayerUser) error    // 添加一个用户信息
	UpdatePlayerUser(player model.Player, user model.PlayerUser) error // 更新一个用户信息
}

type Podiums struct {
	Player         model.Player    `json:"Player,omitempty"`
	Gold           int64           `json:"Gold,omitempty"`
	Silver         int64           `json:"Silver,omitempty"`
	Bronze         int64           `json:"Bronze,omitempty"`
	PodiumsResults []PodiumsResult `json:"PodiumsResults,omitempty"`
}

type PodiumsResult struct {
	Contest model.Contest `json:"Contest,omitempty"`
	Score   model.Score   `json:"Score,omitempty"`
}

type ProcessPreScoreRequest struct {
	Id           uint
	Processor    string
	FinishDetail string
}

type ProjectPlayer struct {
	PlayerID uint
	Project  model.Project
}

type RankScore struct {
	Rank  int         `json:"Rank,omitempty"` // 排名
	Score model.Score `json:"Score,omitempty"`
}

type RecordMessage struct {
	Record  model.Record  `json:"Record,omitempty"`
	Player  model.Player  `json:"Player,omitempty"`
	Score   model.Score   `json:"Score,omitempty"`
	Contest model.Contest `json:"Contest,omitempty"`
}

type RelativeSor struct {
	Player model.Player `json:"Player,omitempty"`
	// 个人成绩
	Sor float64 `json:"Sor,omitempty"`

	// 平均成绩会用到
	Avg  float64 `json:"Avg,omitempty"`  // 全部平均
	Top5 float64 `json:"Top5,omitempty"` // 前5平均, 大于100的取前5%
	Max  float64 `json:"Max,omitempty"`  // 最大值
}

type RoutesScores struct {
	Final  bool          `json:"final,omitempty"`
	Round  []model.Round `json:"Round,omitempty"`
	Scores []model.Score `json:"Scores,omitempty"`
}

type ScoreCore interface {
	AddScore(AddScoreRequest) error                                               // 添加一条成绩
	RemoveScore(scoreID uint) error                                               // 移除一条成绩
	EndContestScore(contestId uint) error                                         // 结束比赛并统计比赛结果
	GetScoreByPlayerContest(playerId uint, contestId uint) ([]model.Score, error) // 获取玩家在某场比赛的成绩

	AddPreScore(AddPreScoreRequest) error                                                              // 添加一个预录入的成绩
	ProcessPreScore(ProcessPreScoreRequest) error                                                      // 处理一个预录入的成绩
	GetPreScores(page, size int, final Bool) (int64, []model.PreScore, error)                          // 获取预录入的成绩列表(分页), useFinal表示是否使用final筛选字段
	GetPreScoresByPlayer(playerID uint, page, size int, final Bool) (int64, []model.PreScore, error)   // 按玩家获取(分页)
	GetPreScoresByContest(contestID uint, page, size int, final Bool) (int64, []model.PreScore, error) // 按比赛获取(分页)
}

type ScoresByContest struct {
	Contest model.Contest `json:"Contest,omitempty"`
	Scores  []model.Score `json:"Scores,omitempty"`
	Rounds  []model.Round `json:"Rounds,omitempty"`
}

type SorScore struct {
	Player         model.Player `json:"Player,omitempty"`
	SingleRank     int64        `json:"SingleRank,omitempty"`
	SingleCount    int64        `json:"SingleCount,omitempty"`
	SingleProjects int64        `json:"SingleProjects,omitempty"` // 参与项目数
	AvgRank        int64        `json:"AvgRank,omitempty"`
	AvgCount       int64        `json:"AvgCount,omitempty"`
	AvgProjects    int64        `json:"AvgProjects,omitempty"` // 参与项目数
}

type StatisticalCore interface {
	GetRecords(page, size int) (int64, []model.Record, error)                                                        // 获取所有记录（分页）
	GetBestScore() (bestSingle, bestAvg map[model.Project][]model.Score)                                             // 获取所有项目每个人的最佳成绩汇总
	GetBestScoreByTimes(startTime, endTime time.Time) (bestSingle, bestAvg map[model.Project][]model.Score)          // [Time]获取所有项目每个人的最佳成绩汇总
	GetBestScoreByProject(project model.Project) (bestSingle, bestAvg []model.Score)                                 // 获取单项目每个人最佳成绩汇总成绩
	GetAllProjectBestScores() (bestSingle, bestAvg map[model.Project]model.Score)                                    // 获取所有项目最佳成绩
	GetAllProjectBestScoresByTimes(startTime, endTime time.Time) (bestSingle, bestAvg map[model.Project]model.Score) // [Time]获取所有项目最佳成绩
	GetPodiums() []Podiums                                                                                           // 获取领奖台汇总
	GetSor() (single, avg map[model.SorStatisticsKey][]SorScore)                                                     // 获取sor排名汇总
	GetAvgRelativeSor() map[model.SorStatisticsKey]RelativeSor                                                       // 平均相对排位分
	GetRelativeSor() (allPlayerSor map[model.SorStatisticsKey][]RelativeSor)                                         // 相对排位分, 返回所有人的平均排位分,计算方式是用当前最佳成绩为标准, 计算与其差距
}