Scoreboard/server/internal/export/load_test.go

package export

import (
	"context"
	"testing"

	"git.yeij.top/AskaEth/Scoreboard/server/internal/realtime"
)

// 导出与 WS 快照必须同源：同一赛事库上，总积分榜的总分、奖牌与名次不能对不上。
func TestExportStandingsMatchesSnapshot(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	wb, err := LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("导出总表: %v", err)
	}
	hub := realtime.NewHub(db, testLogger())
	defer func() { _ = hub.Close() }()
	snap, err := hub.Snapshot(context.Background())
	if err != nil {
		t.Fatalf("读取 WS 快照: %v", err)
	}

	if len(wb.Team) != len(snap.Standings) {
		t.Fatalf("单位数不一致：导出 %d，快照 %d", len(wb.Team), len(snap.Standings))
	}
	for _, s := range snap.Standings {
		idx := -1
		for i := range wb.Team {
			if wb.Team[i].TeamID == s.TeamID {
				idx = i
				break
			}
		}
		if idx < 0 {
			t.Fatalf("快照中的单位 %d 不在导出结果里", s.TeamID)
		}
		row := wb.Team[idx]
		if row.Points != s.TotalPoints || row.Gold != s.Gold || row.Silver != s.Silver ||
			row.Bronze != s.Bronze || row.Medals != s.MedalTotal || row.Rank != s.Rank {
			t.Errorf("单位 %d 口径不一致：导出 %+v，快照 %+v", s.TeamID, row, s)
		}
	}
}

// 只排名不计分（scored=0）的项目不进奖牌榜，即使它配了计分通道。
func TestLoadRankedExcludesRankOnlyEvents(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)

	stmts := []string{
		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, scored, status)
		 VALUES (1, 'E2', '飞行人员战斗体能', 'individual', 'auto', 'score', 'desc', 0, 'published')`,
		`INSERT INTO event_categories(event_id, name, sort_order) VALUES (2, '男子', 1)`,
		`INSERT INTO event_score_channels(event_id, scope, basis, profile_id)
		 SELECT 2, 'athlete', 'result', id FROM scoring_profiles WHERE code = 'individual_top6'`,
		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, bib) VALUES (2, 2, 1, 1, '201')`,
		`INSERT INTO results(event_id, entry_id, rank, result_text, result_value, state)
		 VALUES (2, 3, 1, '100', 100, 'published')`,
	}
	for _, s := range stmts {
		if _, err := db.Exec(s); err != nil {
			t.Fatalf("造数据 %q: %v", s, err)
		}
	}

	ranked, err := loadRanked(db)
	if err != nil {
		t.Fatalf("读取名次: %v", err)
	}
	for _, rr := range ranked {
		if rr.EventID == 2 {
			t.Fatalf("scored=0 的项目不应产出奖牌名次: %+v", rr)
		}
	}

	wb, err := LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("导出总表: %v", err)
	}
	for _, row := range wb.Team {
		if row.TeamID == 1 && row.Gold != 1 {
			t.Errorf("T1 金牌 = %d，期望 1（只排名项目不得计牌）", row.Gold)
		}
	}
}

// 排序口径取自 settings.standings.tie_break，不再是硬编码默认序。
func TestLoadStandingsHonoursTieBreak(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	// T1 金牌 1 但总分 5，T2 无牌但总分 10。
	for _, s := range []string{
		`UPDATE score_ledger SET points = 5 WHERE team_id = 1`,
		`UPDATE score_ledger SET points = 10 WHERE team_id = 2`,
	} {
		if _, err := db.Exec(s); err != nil {
			t.Fatalf("造数据 %q: %v", s, err)
		}
	}

	wb, err := LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("默认口径导出: %v", err)
	}
	if wb.Team[0].Code != "T2" {
		t.Fatalf("默认按总分排序，第一名 = %q，期望 T2", wb.Team[0].Code)
	}

	if _, err := db.Exec(`INSERT INTO settings(key, value) VALUES ('standings.tie_break', 'gold,points')
	                      ON CONFLICT(key) DO UPDATE SET value = excluded.value`); err != nil {
		t.Fatalf("写入 tie_break: %v", err)
	}
	wb, err = LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("金牌优先导出: %v", err)
	}
	if wb.Team[0].Code != "T1" {
		t.Errorf("tie_break=gold,points 时第一名 = %q，期望 T1", wb.Team[0].Code)
	}
}

// 停用但仍有积分的单位要显示编码/名称，不能是空行。
func TestLoadStandingsShowsInactiveTeam(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	for _, s := range []string{
		`INSERT INTO teams(code, name, short_name, sort_order, active)
		 VALUES ('T3', '第三分公司', '三公司', 3, 0)`,
		`INSERT INTO score_ledger(team_id, source_type, source_id, points)
		 VALUES (3, 'adjustment', 99, 7)`,
	} {
		if _, err := db.Exec(s); err != nil {
			t.Fatalf("造数据 %q: %v", s, err)
		}
	}

	wb, err := LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("导出总表: %v", err)
	}
	idx := -1
	for i := range wb.Team {
		if wb.Team[i].TeamID == 3 {
			idx = i
			break
		}
	}
	if idx < 0 {
		t.Fatalf("停用单位未出现在榜单：%+v", wb.Team)
	}
	row := wb.Team[idx]
	if row.Code != "T3" || row.Name != "第三分公司" || row.ShortName != "三公司" {
		t.Errorf("停用单位展示字段不完整: %+v", row)
	}
	if row.Points != 7 {
		t.Errorf("停用单位总分 = %v，期望 7", row.Points)
	}
}

// 单位积分明细的「合计」与总积分榜同口径：个人分要乘 individual_to_team_weight。
func TestTeamDetailTotalAppliesWeight(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	if _, err := db.Exec(`UPDATE settings SET value = '2' WHERE key = 'standings.individual_to_team_weight'`); err != nil {
		t.Fatalf("修改折算系数: %v", err)
	}

	wb, err := LoadTeamDetailWorkbook(db, 1, Options{})
	if err != nil {
		t.Fatalf("读取积分明细: %v", err)
	}
	if wb.IndividualToTeamWeight != 2 {
		t.Fatalf("折算系数 = %v，期望 2", wb.IndividualToTeamWeight)
	}
	rows := teamDetailRows(wb.Rows, wb.IndividualToTeamWeight)
	if len(rows) < 2 {
		t.Fatalf("明细行数 = %d，期望含合计行", len(rows))
	}
	// 与 REST 一致：个人分逐行折算，合计等于各行之和。
	if got, ok := rows[0][8].(float64); !ok || got != 20 {
		t.Errorf("明细行积分 = %v，期望 20（10 × 系数 2）", rows[0][8])
	}
	total, ok := rows[len(rows)-1][8].(float64)
	if !ok {
		t.Fatalf("合计列类型异常: %T", rows[len(rows)-1][8])
	}
	if total != 20 {
		t.Errorf("合计 = %v，期望 20（10 × 系数 2）", total)
	}
}

// 「按队内平均」（basis=aggregate）产生的流水 entry_id 为空，从 entries 取不到组别；
// 单位在本小项只参加一个组别时那个组别就是唯一答案，导出必须把它补上，不能留空。
// 运动员 / 名次 / 成绩留空是合理的：聚合分不对应单个运动员。
func TestTeamDetailAggregateRowKeepsCategory(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	// 模拟聚合通道产出的流水：entry_id 与 result_id 都为空（见 isAggregateLedger）。
	if _, err := db.Exec(`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id,
	                          source_type, source_id, points, count_to_team)
	                      VALUES (1, NULL, 1, NULL, NULL, 'result', 99, 15, 1)`); err != nil {
		t.Fatalf("写入聚合流水: %v", err)
	}

	wb, err := LoadTeamDetailWorkbook(db, 1, Options{})
	if err != nil {
		t.Fatalf("读取积分明细: %v", err)
	}
	agg, ok := findAggregateRow(wb.Rows)
	if !ok {
		t.Fatalf("聚合流水没出现在明细里: %+v", wb.Rows)
	}
	if agg.Category != "男子" {
		t.Errorf("聚合流水的组别 = %q，期望 男子", agg.Category)
	}
	if agg.AthleteName != "" || agg.Rank != 0 || agg.ResultText != "" {
		t.Errorf("聚合流水不该带单个运动员的信息: %+v", agg)
	}
}

// 单位在同一小项参加了多个组别时，库里同一 (小项, 单位) 有多条内容相同、无法区分的聚合流水，
// 回推不出组别；导出宁可留空也不猜（要修得先往 score_ledger 上落组别，属于模型改动）。
func TestTeamDetailAggregateRowAmbiguousCategoryStaysEmpty(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	stmts := []string{
		`INSERT INTO event_categories(event_id, name, sort_order) VALUES (1, '女子', 2)`,
		`INSERT INTO athletes(name, gender, team_id) VALUES ('王五', '女', 1)`,
		`INSERT INTO entries(event_id, category_id, team_id, athlete_id, bib) VALUES (1, 2, 1, 3, '103')`,
		`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id, source_type, source_id, points, count_to_team)
		 VALUES (1, NULL, 1, NULL, NULL, 'result', 99, 15, 1)`,
	}
	for _, s := range stmts {
		if _, err := db.Exec(s); err != nil {
			t.Fatalf("造数据 %q: %v", s, err)
		}
	}

	wb, err := LoadTeamDetailWorkbook(db, 1, Options{})
	if err != nil {
		t.Fatalf("读取积分明细: %v", err)
	}
	agg, ok := findAggregateRow(wb.Rows)
	if !ok {
		t.Fatalf("聚合流水没出现在明细里: %+v", wb.Rows)
	}
	if agg.Category != "" {
		t.Errorf("无法回推的聚合流水组别 = %q，期望留空", agg.Category)
	}
}

// findAggregateRow 找出那条聚合流水（测试里用 15 分做标记，种子数据只有 10 与 8 分）。
func findAggregateRow(rows []TeamDetailRow) (TeamDetailRow, bool) {
	for _, r := range rows {
		if r.Points == 15 {
			return r, true
		}
	}
	return TeamDetailRow{}, false
}

// 「个人+团体」项目的个人通道流水（count_to_team = 0）不进单位总分，
// 导出侧与 REST / WS 快照必须同口径。
func TestLoadStandingsSkipsPersonalOnlyLedger(t *testing.T) {
	db := openEventDB(t)
	seedEvent(t, db)
	// 单位 1 再加一条「只记个人」的流水：导出总分不得变化。
	if _, err := db.Exec(`INSERT INTO score_ledger(team_id, athlete_id, event_id, entry_id, result_id,
	                          source_type, source_id, points, count_to_team)
	                      VALUES (1, 1, 1, 1, 1, 'result', 1, 7, 0)`); err != nil {
		t.Fatalf("写入个人通道流水: %v", err)
	}

	wb, err := LoadStandingsWorkbook(db, Options{})
	if err != nil {
		t.Fatalf("导出总表: %v", err)
	}
	for _, row := range wb.Team {
		if row.TeamID != 1 {
			continue
		}
		if row.Points != 10 {
			t.Fatalf("单位1 总分 = %v，期望 10（不计入单位总分的流水应被跳过）", row.Points)
		}
	}
	// 个人榜照常算上这条流水：10 + 7 = 17。
	for _, row := range wb.Athlete {
		if row.AthleteID == 1 && row.Points != 17 {
			t.Fatalf("个人榜得分 = %v，期望 17", row.Points)
		}
	}
}