Scoreboard/server/internal/rules/medals_test.go

package rules

import (
	"testing"

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

// 奖牌结算三个开关（devdocs 17 §三 / §六）：
//   - Channel.countToMedals / countToTeamMedals（缺省 true）
//   - EventOverride.awardMedals（三态，nil = 不动该字段）
// 这里覆盖解析、落库、回读、差异比对四条路，保证「导出 → 导入」幂等。

const medalFlagsPackYAML = `format: scoreboard-rules
formatVersion: 1
meta: { code: demo, name: 奖牌开关 }
profiles:
  - { code: p1, name: 模板一, awardRanks: 1, tieMode: skip, rules: [ { rank: 1, points: 1 } ] }
channelTemplates:
  - match: { eventType: individual }
    channels:
      - { scope: athlete, basis: result, profile: p1, countToTeam: false, countToMedals: false, countToTeamMedals: false }
eventOverrides:
  - eventCode: EVT_IND
    awardMedals: false
    channels:
      - { scope: athlete, basis: result, profile: p1 }
  - eventCode: EVT_TEAM
    channels:
      - { scope: team, basis: manual, profile: p1 }
`

func TestParseMedalFlags(t *testing.T) {
	pack, err := Parse([]byte(medalFlagsPackYAML))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}

	ch := pack.ChannelTemplates[0].Channels[0]
	if ch.CountToMedals == nil || *ch.CountToMedals {
		t.Fatalf("countToMedals: false 应落到结构体，实际 %+v", ch.CountToMedals)
	}
	if ch.CountsToMedals() {
		t.Error("countToMedals: false 时 CountsToMedals() 应为 false")
	}
	if ch.CountToTeamMedals == nil || *ch.CountToTeamMedals {
		t.Fatalf("countToTeamMedals: false 应落到结构体，实际 %+v", ch.CountToTeamMedals)
	}
	if ch.CountsToTeamMedals() {
		t.Error("countToTeamMedals: false 时 CountsToTeamMedals() 应为 false")
	}

	ind := pack.EventOverrides[0]
	if ind.AwardMedals == nil || *ind.AwardMedals {
		t.Fatalf("awardMedals: false 应落到结构体，实际 %+v", ind.AwardMedals)
	}
	if pack.EventOverrides[1].AwardMedals != nil {
		t.Errorf("未写 awardMedals 时应保持 nil，实际 %v", *pack.EventOverrides[1].AwardMedals)
	}

	// 缺省即 true：不写三个键的通道既要保持 nil（不凭空造显式值），又要按 true 生效。
	def := pack.EventOverrides[1].Channels
	if def == nil || len(*def) != 1 {
		t.Fatalf("EVT_TEAM 通道解析错误: %+v", def)
	}
	if (*def)[0].CountToMedals != nil || (*def)[0].CountToTeamMedals != nil {
		t.Errorf("未写奖牌开关时应保持 nil，实际 %+v", (*def)[0])
	}
	if !(*def)[0].CountsToMedals() || !(*def)[0].CountsToTeamMedals() {
		t.Error("未写奖牌开关时应按缺省 true 生效")
	}

	// 序列化后再解析必须完全一致（三个键要能出现在导出文件里）。
	reparsed, err := Parse(mustMarshal(t, pack))
	if err != nil {
		t.Fatalf("重新 Parse: %v", err)
	}
	if !channelsEqual(pack.ChannelTemplates[0].Channels, reparsed.ChannelTemplates[0].Channels) {
		t.Errorf("模板通道往返不一致:\n%+v\n%+v", pack.ChannelTemplates[0].Channels, reparsed.ChannelTemplates[0].Channels)
	}
	again := reparsed.EventOverrides[0]
	if again.AwardMedals == nil || *again.AwardMedals {
		t.Errorf("awardMedals 往返不一致: %+v", again.AwardMedals)
	}
	if reparsed.EventOverrides[1].AwardMedals != nil {
		t.Errorf("未写的 awardMedals 往返后应保持 nil，实际 %v", *reparsed.EventOverrides[1].AwardMedals)
	}
}

func TestChannelToDomainCarriesMedalFlags(t *testing.T) {
	pack, err := Parse([]byte(medalFlagsPackYAML))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}

	ch := pack.ChannelTemplates[0].Channels[0].ToDomain(3, 7, 0)
	if ch.CountToMedals == nil || *ch.CountToMedals {
		t.Fatalf("ToDomain 应带上 countToMedals: false，实际 %+v", ch.CountToMedals)
	}
	if ch.CountToTeamMedals == nil || *ch.CountToTeamMedals {
		t.Fatalf("ToDomain 应带上 countToTeamMedals: false，实际 %+v", ch.CountToTeamMedals)
	}

	// 缺省的通道不落指针，与 countToTeam 同口径。
	def := (*pack.EventOverrides[1].Channels)[0].ToDomain(3, 7, 0)
	if def.CountToMedals != nil || def.CountToTeamMedals != nil {
		t.Errorf("缺省通道不应写显式值: %+v", def)
	}
}

// 库里 award_medals=0、别的都缺省的项目，导出时必须写成只带 awardMedals 的 override，
// 否则「导出 → 导入」会把关闭的奖牌开关丢掉。
func TestLoadExportsAwardMedalsOnlyOverride(t *testing.T) {
	db := openEventDB(t)
	seedEvents(t, db)
	if _, err := db.Exec(`UPDATE events SET award_medals = 0 WHERE code = 'EVT_IND'`); err != nil {
		t.Fatalf("预置奖牌开关: %v", err)
	}

	snap, err := Load(db)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	var ov *EventOverride
	for i := range snap.Pack.EventOverrides {
		if snap.Pack.EventOverrides[i].EventCode == "EVT_IND" {
			ov = &snap.Pack.EventOverrides[i]
		}
	}
	if ov == nil {
		t.Fatalf("导出应包含 EVT_IND 的 override: %+v", snap.Pack.EventOverrides)
	}
	if ov.AwardMedals == nil || *ov.AwardMedals {
		t.Fatalf("EVT_IND 应导出 awardMedals: false，实际 %+v", ov.AwardMedals)
	}
	if ov.Scored != nil || ov.Multiplier != nil || ov.Channels != nil {
		t.Errorf("其余字段保持缺省，不该被一起写出来: %+v", ov)
	}

	// 导出结果重新导入必须无差异。
	exported, err := Export(db, Meta{Code: "demo", Name: "导出"})
	if err != nil {
		t.Fatalf("Export: %v", err)
	}
	reparsed, err := Parse(mustMarshal(t, exported))
	if err != nil {
		t.Fatalf("重新 Parse: %v", err)
	}
	cur, err := Load(db)
	if err != nil {
		t.Fatalf("再次 Load: %v", err)
	}
	cs, err := Diff(cur, reparsed)
	if err != nil {
		t.Fatalf("Diff: %v", err)
	}
	if !cs.Empty() {
		t.Fatalf("导出再导入不应有差异: %+v", cs)
	}
}

// 落库 → 直接查列 → Load 回读，断言与输入一致，并且导出再导入无差异。
func TestApplyMedalFlagsThenLoadRoundTrip(t *testing.T) {
	db := openEventDB(t)
	seedEvents(t, db)

	const packYAML = `format: scoreboard-rules
formatVersion: 1
meta: { code: demo, name: 奖牌开关 }
standings:
  individualToTeamWeight: 1
  tieBreak: [points, gold]
profiles:
  - code: individual_top6
    name: 个人项目前六名
    awardRanks: 1
    tieMode: skip
    rules:
      - { rank: 1, points: 10 }
  - code: team_top6
    name: 团体项目前六名
    awardRanks: 1
    tieMode: skip
    rules:
      - { rank: 1, points: 15 }
eventOverrides:
  - eventCode: EVT_IND
    awardMedals: false
    channels:
      - { scope: athlete, basis: result, profile: individual_top6, countToMedals: false, countToTeamMedals: false }
  - eventCode: EVT_TEAM
    channels:
      - { scope: team, basis: manual, profile: team_top6, countToMedals: false }
`
	next, err := Parse([]byte(packYAML))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	if _, err := Apply(db, &ChangeSet{Next: next}); err != nil {
		t.Fatalf("Apply: %v", err)
	}

	// 小项级开关。
	if got := queryInt(t, db, `SELECT award_medals FROM events WHERE code = 'EVT_IND'`); got != 0 {
		t.Errorf("EVT_IND award_medals = %d，期望 0", got)
	}
	if got := queryInt(t, db, `SELECT award_medals FROM events WHERE code = 'EVT_TEAM'`); got != 1 {
		t.Errorf("未写 awardMedals 的项目应保持缺省 1，实际 %d", got)
	}

	// 通道级开关：EVT_IND 的两个都关，EVT_TEAM 只关奖牌、团体奖牌并入照旧。
	wants := map[string][3]int{
		"EVT_IND":  {1, 0, 0},
		"EVT_TEAM": {1, 0, 1},
	}
	rows, err := db.Query(`SELECT e.code, c.count_to_team, c.count_to_medals, c.count_to_team_medals
		FROM event_score_channels c JOIN events e ON e.id = c.event_id ORDER BY e.code, c.sort_order, c.id`)
	if err != nil {
		t.Fatalf("查询通道: %v", err)
	}
	defer func() { _ = rows.Close() }()
	seen := map[string]int{}
	for rows.Next() {
		var code string
		var countToTeam, countToMedals, countToTeamMedals int
		if err := rows.Scan(&code, &countToTeam, &countToMedals, &countToTeamMedals); err != nil {
			t.Fatalf("扫描通道: %v", err)
		}
		want, ok := wants[code]
		if !ok {
			t.Fatalf("出现预期外的通道: %s", code)
		}
		got := [3]int{countToTeam, countToMedals, countToTeamMedals}
		if got != want {
			t.Fatalf("%s 通道开关 = %v，期望 %v", code, got, want)
		}
		seen[code]++
	}
	if err := rows.Err(); err != nil {
		t.Fatalf("遍历通道: %v", err)
	}
	if seen["EVT_IND"] != 1 || seen["EVT_TEAM"] != 1 {
		t.Fatalf("通道数异常: %v", seen)
	}

	// Load 回读：三个字段都要还原成「显式 false」而不是缺省 true。
	snap, err := Load(db)
	if err != nil {
		t.Fatalf("Load: %v", err)
	}
	ind, ok := snap.EventByCode("EVT_IND")
	if !ok {
		t.Fatal("Load 结果里缺少 EVT_IND")
	}
	if ind.AwardMedals {
		t.Error("Load 应读出 EVT_IND award_medals = 0")
	}
	if len(ind.Channels) != 1 {
		t.Fatalf("EVT_IND 通道数 = %d，期望 1", len(ind.Channels))
	}
	if ind.Channels[0].CountsToMedals() || ind.Channels[0].CountsToTeamMedals() {
		t.Errorf("EVT_IND 通道应按显式 false 读回: %+v", ind.Channels[0])
	}
	team, ok := snap.EventByCode("EVT_TEAM")
	if !ok {
		t.Fatal("Load 结果里缺少 EVT_TEAM")
	}
	if !team.AwardMedals {
		t.Error("Load 应读出 EVT_TEAM award_medals = 1")
	}
	if team.Channels[0].CountsToMedals() {
		t.Error("EVT_TEAM 通道 count_to_medals 应为 false")
	}
	if !team.Channels[0].CountsToTeamMedals() {
		t.Error("EVT_TEAM 未关闭 count_to_team_medals，应保持 true")
	}

	// 导出再导入必须无差异：显式 false 与缺省 true 不能被读串。
	exported, err := Export(db, Meta{Code: "demo", Name: "导出"})
	if err != nil {
		t.Fatalf("Export: %v", err)
	}
	reparsed, err := Parse(mustMarshal(t, exported))
	if err != nil {
		t.Fatalf("重新 Parse: %v", err)
	}
	cur, err := Load(db)
	if err != nil {
		t.Fatalf("再次 Load: %v", err)
	}
	cs, err := Diff(cur, reparsed)
	if err != nil {
		t.Fatalf("Diff: %v", err)
	}
	if !cs.Empty() {
		t.Fatalf("导出再导入不应有差异: %+v", cs)
	}
}

// 只写 awardMedals 的 EventOverride 也要生效：判空若只看 scored/multiplier，这条会被整条跳过。
func TestApplyAwardMedalsOnlyOverride(t *testing.T) {
	db := openEventDB(t)
	seedEvents(t, db)

	const packYAML = `format: scoreboard-rules
formatVersion: 1
meta: { code: demo, name: 只写奖牌开关 }
profiles:
  - { code: individual_top6, name: 个人项目前六名, awardRanks: 1, tieMode: skip, rules: [ { rank: 1, points: 10 } ] }
  - { code: team_top6, name: 团体项目前六名, awardRanks: 1, tieMode: skip, rules: [ { rank: 1, points: 15 } ] }
eventOverrides:
  - eventCode: EVT_IND
    awardMedals: false
  - eventCode: EVT_TEAM
    multiplier: 2
`
	// 先把 EVT_TEAM 的奖牌开关也关掉，验证「override 不提该字段就不动它」。
	if _, err := db.Exec(`UPDATE events SET award_medals = 0 WHERE code = 'EVT_TEAM'`); err != nil {
		t.Fatalf("预置 EVT_TEAM 开关: %v", err)
	}

	next, err := Parse([]byte(packYAML))
	if err != nil {
		t.Fatalf("Parse: %v", err)
	}
	res, err := Apply(db, &ChangeSet{Next: next})
	if err != nil {
		t.Fatalf("Apply: %v", err)
	}
	if res.EventsUpdated != 2 {
		t.Errorf("项目更新数 = %d，期望 2（只写 awardMedals 的也要落库）", res.EventsUpdated)
	}
	if res.ChannelsWritten != 0 {
		t.Errorf("没有模板/通道配置，不该重建通道，实际 %d", res.ChannelsWritten)
	}

	if got := queryInt(t, db, `SELECT award_medals FROM events WHERE code = 'EVT_IND'`); got != 0 {
		t.Errorf("EVT_IND award_medals = %d，期望 0", got)
	}
	if got := queryInt(t, db, `SELECT award_medals FROM events WHERE code = 'EVT_TEAM'`); got != 0 {
		t.Errorf("override 未写 awardMedals 时不应改动该列，实际 %d", got)
	}
	if got := queryFloat(t, db, `SELECT multiplier FROM events WHERE code = 'EVT_TEAM'`); got != 2 {
		t.Errorf("EVT_TEAM 权重 = %v，期望 2", got)
	}
	// 种子里的通道既没被删也没被改。
	if got := countRows(t, db, "event_score_channels"); got != 1 {
		t.Errorf("通道数 = %d，期望 1（未被规则包提到）", got)
	}
}

// 通道只差奖牌开关也必须报差异，否则前端预览看不到、用户以为没改动。
func TestDiffDetectsMedalFlagChanges(t *testing.T) {
	base := Channel{Scope: domain.ScopeAthlete, Basis: domain.BasisResult, Profile: "individual_top6"}

	cases := []struct {
		name string
		mut  func(Channel) Channel
	}{
		{"countToMedals", func(c Channel) Channel { c.CountToMedals = BoolPtr(false); return c }},
		{"countToTeamMedals", func(c Channel) Channel { c.CountToTeamMedals = BoolPtr(false); return c }},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			cur := currentSnapshot(t)
			pack := *cur.Pack
			pack.EventOverrides = []EventOverride{{
				EventCode: "EVT_IND",
				Channels:  ChannelListPtr([]Channel{tc.mut(base)}),
			}}
			cs, err := Diff(cur, &pack)
			if err != nil {
				t.Fatalf("Diff: %v", err)
			}
			if len(cs.Channels) != 1 || cs.Channels[0].EventCode != "EVT_IND" {
				t.Fatalf("应报出 EVT_IND 的通道变化，实际 %+v", cs.Channels)
			}
			if cs.Channels[0].Kind != ChangeModified {
				t.Errorf("变化类型 = %q，期望 modified", cs.Channels[0].Kind)
			}
		})
	}

	t.Run("缺省与显式 true 不算变化", func(t *testing.T) {
		cur := currentSnapshot(t)
		pack := *cur.Pack
		pack.EventOverrides = []EventOverride{{
			EventCode: "EVT_IND",
			Channels: ChannelListPtr([]Channel{{
				Scope: domain.ScopeAthlete, Basis: domain.BasisResult, Profile: "individual_top6",
				CountToMedals: BoolPtr(true), CountToTeamMedals: BoolPtr(true),
			}}),
		}}
		cs, err := Diff(cur, &pack)
		if err != nil {
			t.Fatalf("Diff: %v", err)
		}
		if len(cs.Channels) != 0 {
			t.Fatalf("显式 true 与缺省同义，不应报差异: %+v", cs.Channels)
		}
	})
}