package domain

import "sort"

// 榜单排序键，取值与规则包 standings.tieBreak 一致。
// 定义在 domain 是为了让 rules 包复用同一套键名，避免两边各写一份常量。
const (
	TieBreakPoints   = "points"
	TieBreakGold     = "gold"
	TieBreakSilver   = "silver"
	TieBreakBronze   = "bronze"
	TieBreakTeamCode = "teamCode"
	TieBreakName     = "name"
)

// TieBreak 未配置时的口径，与 devdocs 02 §5.2 一致。
var (
	defaultTeamTieBreak    = []string{TieBreakPoints, TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakTeamCode}
	defaultAthleteTieBreak = []string{TieBreakPoints, TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakName}
)

// 单位奖牌榜的排序口径（主人 2026-09-13 拍板）：金牌 → 银牌 → 铜牌 → 单位编码。
//
// 它**故意不读** StandingsInput.TieBreak：那套键是给总积分榜与个人榜的，
// 规则包里写的 `points,gold,...` 一进来，奖牌榜就又变回"总分优先"，
// 会出现"金牌 6 枚的单位排在金牌 2 枚的后面"（06 报告 P1④）。
var defaultMedalTieBreak = []string{TieBreakGold, TieBreakSilver, TieBreakBronze, TieBreakTeamCode}

// StandingsInput 是排名聚合的输入：流水 + 名次明细 + 单位/运动员基础信息。
type StandingsInput struct {
	Teams    []Team
	Athletes []Athlete
	Ledger   []LedgerEntry
	Ranked   []RankedResult
	// TieBreak 是排序键顺序（如 points/gold/silver/bronze/teamCode/name）；
	// 空表示用默认口径。配置里的键优先，其余按默认顺序补齐，保证结果全序。
	// **只作用于总积分榜与个人榜**：单位奖牌榜固定按金→银→铜→单位编码排（defaultMedalTieBreak）。
	TieBreak []string
	// IndividualToTeamWeight 个人积分折算进单位总分的系数；<=0 时按 1 处理。
	IndividualToTeamWeight float64
	// ExcludeTeamEventMedals 为 true 时单位奖牌榜不计团体项目奖牌；默认计入。
	ExcludeTeamEventMedals bool
}

type medalTally struct {
	gold, silver, bronze int
}

// rankMedal 把名次映射成奖牌：1 金 / 2 银 / 3 铜，其余无名次。
func rankMedal(rank int) int {
	switch rank {
	case 1:
		return 1
	case 2:
		return 2
	case 3:
		return 3
	default:
		return 0
	}
}

// medalEligible 是奖牌入选判据（devdocs 17 §4.5）：小项结算奖牌、通道是奖牌通道、
// 名次在前三，三者同时成立才计入。三个开关随 RankedResult 携带，榜单不必回查库。
func medalEligible(rr RankedResult) bool {
	return rr.AwardMedals && rr.CountToMedals && rankMedal(rr.Rank) != 0
}

// BuildTeamStandings 生成总积分榜。
// 总分 = Σ(仅记单位的流水) + 系数 × Σ(记到个人的流水)；排序按 in.TieBreak，缺省为总分 → 金 → 银 → 铜 → 单位编码。
func BuildTeamStandings(in StandingsInput) []StandingsRow {
	rows := buildTeamRows(in)
	sort.SliceStable(rows, func(i, j int) bool { return lessTeamRow(rows[i], rows[j], in.TieBreak) })
	for i := range rows {
		rows[i].Rank = i + 1
	}
	return rows
}

// buildTeamRows 汇总出「每个单位一行」的原始数据（含兜底补行），不排序、不填名次。
//
// 单位总分榜与单位奖牌榜的行集合必须完全一致（同一批单位、同样兜底），
// 差别只在排序与名次；两条路都从这里出行，避免哪天只给一个榜补了兜底行。
func buildTeamRows(in StandingsInput) []StandingsRow {
	weight := effectiveWeight(in.IndividualToTeamWeight)
	sums := SumByTeam(in.Ledger, weight)
	medals := teamMedals(in)

	rows := make([]StandingsRow, 0, len(in.Teams))
	seen := make(map[int64]bool, len(in.Teams))
	for _, t := range in.Teams {
		if seen[t.ID] {
			continue
		}
		seen[t.ID] = true
		rows = append(rows, buildTeamRow(t, sums[t.ID], medals[t.ID]))
	}
	// 兜底：流水/奖牌里出现但单位表没提供的单位也要上榜，否则分数会被静默吞掉。
	for id := range sums {
		if !seen[id] {
			seen[id] = true
			rows = append(rows, buildTeamRow(Team{ID: id}, sums[id], medals[id]))
		}
	}
	for id, m := range medals {
		if !seen[id] {
			seen[id] = true
			rows = append(rows, buildTeamRow(Team{ID: id}, sums[id], m))
		}
	}
	return rows
}

// BuildMedalStandings 生成单位奖牌榜。
//
// 行集合与总积分榜相同（同一份输入、同一套兜底），但**名次与顺序自成一套**：
// 金 → 银 → 铜 → 单位编码，与总分无关（主人 2026-09-13 拍板）。
// 因此绝不能复用总积分榜的 Rank——那正是「金牌多的排在金牌少的后面」的来源。
func BuildMedalStandings(in StandingsInput) []MedalRow {
	teamRows := buildTeamRows(in)
	out := make([]MedalRow, 0, len(teamRows))
	for _, r := range teamRows {
		out = append(out, MedalRow{
			TeamID:    r.TeamID,
			Code:      r.Code,
			Name:      r.Name,
			ShortName: r.ShortName,
			Points:    r.Points,
			Gold:      r.Gold,
			Silver:    r.Silver,
			Bronze:    r.Bronze,
			Total:     r.Gold + r.Silver + r.Bronze,
		})
	}
	sort.SliceStable(out, func(i, j int) bool { return lessMedalRow(out[i], out[j]) })
	for i := range out {
		out[i].Rank = i + 1
	}
	return out
}

// lessMedalRow 是单位奖牌榜的排序：金 DESC → 银 DESC → 铜 DESC → 单位编码 ASC。
// 只用 defaultMedalTieBreak 这几个键（不掺 StandingsInput.TieBreak），最后用单位 ID 兜底，
// 保证任意两行都有确定先后（结果全序）。
func lessMedalRow(a, b MedalRow) bool {
	for _, key := range defaultMedalTieBreak {
		switch key {
		case TieBreakGold:
			if a.Gold != b.Gold {
				return a.Gold > b.Gold
			}
		case TieBreakSilver:
			if a.Silver != b.Silver {
				return a.Silver > b.Silver
			}
		case TieBreakBronze:
			if a.Bronze != b.Bronze {
				return a.Bronze > b.Bronze
			}
		case TieBreakTeamCode:
			if a.Code != b.Code {
				return a.Code < b.Code
			}
		}
	}
	return a.TeamID < b.TeamID
}

// BuildAthleteStandings 生成个人积分奖牌榜。
// 排序按 in.TieBreak，缺省为总分 → 金 → 银 → 铜 → 姓名；个人榜的奖牌只统计个人项目（团体项目奖牌归团体榜）。
func BuildAthleteStandings(in StandingsInput) []AthleteStandingsRow {
	points := SumByAthlete(in.Ledger)
	medals := athleteMedals(in)

	names := make(map[int64]string, len(in.Athletes))
	teams := make(map[int64]int64, len(in.Athletes))
	for _, a := range in.Athletes {
		names[a.ID] = a.Name
		teams[a.ID] = a.TeamID
	}
	for _, rr := range in.Ranked {
		if rr.AthleteID == 0 {
			continue
		}
		if names[rr.AthleteID] == "" {
			names[rr.AthleteID] = rr.AthleteName
		}
		if _, ok := teams[rr.AthleteID]; !ok {
			teams[rr.AthleteID] = rr.TeamID
		}
	}

	teamByID := make(map[int64]Team, len(in.Teams))
	for _, t := range in.Teams {
		teamByID[t.ID] = t
	}

	seen := make(map[int64]bool, len(points)+len(medals))
	ids := make([]int64, 0, len(points)+len(medals))
	add := func(id int64) {
		if id == 0 || seen[id] {
			return
		}
		seen[id] = true
		ids = append(ids, id)
	}
	for id := range points {
		add(id)
	}
	for id := range medals {
		add(id)
	}

	rows := make([]AthleteStandingsRow, 0, len(ids))
	for _, id := range ids {
		t := teamByID[teams[id]]
		m := medals[id]
		rows = append(rows, AthleteStandingsRow{
			AthleteID: id,
			Name:      names[id],
			TeamID:    teams[id],
			TeamCode:  t.Code,
			TeamName:  t.Name,
			Points:    points[id],
			Gold:      m.gold,
			Silver:    m.silver,
			Bronze:    m.bronze,
			Medals:    m.gold + m.silver + m.bronze,
		})
	}

	sort.SliceStable(rows, func(i, j int) bool { return lessAthleteRow(rows[i], rows[j], in.TieBreak) })
	for i := range rows {
		rows[i].Rank = i + 1
	}
	return rows
}

func effectiveWeight(weight float64) float64 {
	if weight <= 0 {
		return 1
	}
	return weight
}

func buildTeamRow(t Team, p TeamPoints, m medalTally) StandingsRow {
	return StandingsRow{
		TeamID:           t.ID,
		Code:             t.Code,
		Name:             t.Name,
		ShortName:        t.ShortName,
		Points:           p.Total,
		TeamOnlyPoints:   p.TeamOnly,
		IndividualPoints: p.Individual,
		Gold:             m.gold,
		Silver:           m.silver,
		Bronze:           m.bronze,
		Medals:           m.gold + m.silver + m.bronze,
	}
}

// channelBefore 是计分通道的优先级比较（口径固定，必须确定性）：
// 个人通道优先于团体通道；同为个人/团体时取通道 id 小者。
// 奖牌去重与破纪录口径共用这套优先级，保证同一份输入每次选出同一个通道。
func channelBefore(scopeA Scope, idA int64, scopeB Scope, idB int64) bool {
	if scopeA != scopeB {
		return scopeA == ScopeAthlete
	}
	return idA < idB
}

// medalKey 是奖牌去重键：同一报名项在同一小项、同一组别只记一枚奖牌。
// 聚合通道不对应单条报名项（EntryID=0），改用名次主体（个人/单位）去重。
type medalKey struct {
	eventID    int64
	categoryID int64
	entryID    int64
	scope      Scope
	subject    int64
	unique     int // 退化数据（EntryID 与主体都为空）没有可识别身份，按输入顺序各占一个键
}

// medalKeyOf 计算一条名次明细的去重键；index 用于给无法识别主体的退化数据兜底。
func medalKeyOf(rr RankedResult, index int) medalKey {
	k := medalKey{eventID: rr.EventID, categoryID: rr.CategoryID, entryID: rr.EntryID}
	if k.entryID != 0 {
		return k
	}
	k.scope = rr.Scope
	if rr.Scope == ScopeAthlete {
		k.subject = rr.AthleteID
	} else {
		k.subject = rr.TeamID
	}
	if k.subject == 0 {
		k.unique = index + 1
	}
	return k
}

// pickMedalChannels 先按奖牌入选判据过滤，再把按通道展开的名次明细去重成「每个主体一条」：
// 只保留优先级最高的通道名次（个人通道优先），否则双通道项目一条成绩会拿两枚奖牌。
func pickMedalChannels(ranked []RankedResult, excludeTeam bool) []RankedResult {
	best := make(map[medalKey]RankedResult, len(ranked))
	order := make([]medalKey, 0, len(ranked))
	for i, rr := range ranked {
		if !medalEligible(rr) {
			continue
		}
		if excludeTeam && rr.Scope == ScopeTeam {
			continue
		}
		k := medalKeyOf(rr, i)
		cur, ok := best[k]
		if !ok {
			best[k] = rr
			order = append(order, k)
			continue
		}
		if channelBefore(rr.Scope, rr.ChannelID, cur.Scope, cur.ChannelID) {
			best[k] = rr
		}
	}
	out := make([]RankedResult, 0, len(order))
	for _, k := range order {
		out = append(out, best[k])
	}
	return out
}

// teamMedals 统计单位奖牌榜。按 Shares 逐份额记牌：当前只有「主单位独占 100%」一种口径，
// 将来若支持联队拆分，每个成员单位都会各记一枚。
//
// 两层开关（devdocs 17 §4.5）：
//   - 粗粒度总闸 StandingsInput.ExcludeTeamEventMedals：为 true 时团体项目的奖牌一律不进单位榜；
//   - 通道开关 count_to_team_medals：scope=athlete 的通道置 false 时，它的个人奖牌不进单位榜。
//
// 两者是「与」的关系；scope=team 的奖牌本来就记在单位头上，不受通道开关影响。
func teamMedals(in StandingsInput) map[int64]medalTally {
	out := make(map[int64]medalTally)
	for _, rr := range pickMedalChannels(in.Ranked, in.ExcludeTeamEventMedals) {
		if rr.Scope != ScopeTeam && !rr.CountToTeamMedals {
			continue
		}
		medal := rankMedal(rr.Rank)
		if medal == 0 {
			continue
		}
		for _, s := range rr.Shares {
			t := out[s.TeamID]
			switch medal {
			case 1:
				t.gold++
			case 2:
				t.silver++
			case 3:
				t.bronze++
			}
			out[s.TeamID] = t
		}
	}
	return out
}

// athleteMedals 只统计个人项目（scope=athlete）的奖牌；
// 通道的 count_to_team_medals 与个人榜无关，只决定这枚奖牌算不算进单位榜。
func athleteMedals(in StandingsInput) map[int64]medalTally {
	out := make(map[int64]medalTally)
	for _, rr := range pickMedalChannels(in.Ranked, false) {
		if rr.Scope != ScopeAthlete || rr.AthleteID == 0 {
			continue
		}
		medal := rankMedal(rr.Rank)
		if medal == 0 {
			continue
		}
		t := out[rr.AthleteID]
		switch medal {
		case 1:
			t.gold++
		case 2:
			t.silver++
		case 3:
			t.bronze++
		}
		out[rr.AthleteID] = t
	}
	return out
}

// tieBreakKeys 把配置的排序键展开成实际比较顺序：配置优先，缺失的默认键补在后面，
// 保证两行在所有键上都相等时仍能由调用方的 ID 兜底分出先后。
func tieBreakKeys(cfg, def []string) []string {
	if len(cfg) == 0 {
		return def
	}
	out := make([]string, 0, len(cfg)+len(def))
	seen := make(map[string]bool, len(cfg)+len(def))
	for _, key := range cfg {
		if seen[key] {
			continue
		}
		seen[key] = true
		out = append(out, key)
	}
	for _, key := range def {
		if seen[key] {
			continue
		}
		seen[key] = true
		out = append(out, key)
	}
	return out
}

func lessTeamRow(a, b StandingsRow, tieBreak []string) bool {
	for _, key := range tieBreakKeys(tieBreak, defaultTeamTieBreak) {
		switch key {
		case TieBreakPoints:
			if !nearlyEqual(a.Points, b.Points) {
				return a.Points > b.Points
			}
		case TieBreakGold:
			if a.Gold != b.Gold {
				return a.Gold > b.Gold
			}
		case TieBreakSilver:
			if a.Silver != b.Silver {
				return a.Silver > b.Silver
			}
		case TieBreakBronze:
			if a.Bronze != b.Bronze {
				return a.Bronze > b.Bronze
			}
		case TieBreakTeamCode:
			if a.Code != b.Code {
				return a.Code < b.Code
			}
		case TieBreakName:
			if a.Name != b.Name {
				return a.Name < b.Name
			}
		}
	}
	return a.TeamID < b.TeamID
}

func lessAthleteRow(a, b AthleteStandingsRow, tieBreak []string) bool {
	for _, key := range tieBreakKeys(tieBreak, defaultAthleteTieBreak) {
		switch key {
		case TieBreakPoints:
			if !nearlyEqual(a.Points, b.Points) {
				return a.Points > b.Points
			}
		case TieBreakGold:
			if a.Gold != b.Gold {
				return a.Gold > b.Gold
			}
		case TieBreakSilver:
			if a.Silver != b.Silver {
				return a.Silver > b.Silver
			}
		case TieBreakBronze:
			if a.Bronze != b.Bronze {
				return a.Bronze > b.Bronze
			}
		case TieBreakTeamCode:
			if a.TeamCode != b.TeamCode {
				return a.TeamCode < b.TeamCode
			}
		case TieBreakName:
			if a.Name != b.Name {
				return a.Name < b.Name
			}
		}
	}
	return a.AthleteID < b.AthleteID
}