package event

import (
	"context"
	"database/sql"
	"io"
	"io/fs"
	"log/slog"
	"reflect"
	"testing"

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

// 孤儿流水的统一口径：计分引擎产出的成绩分与破纪录加分，但 event_id 已被置空。
const orphanLedgerCond = `voided = 0 AND event_id IS NULL AND source_type IN ('result', 'record_bonus')`

// 0022 一次性清理升级前留下的孤儿流水：删掉「只有名次、没有报名项」的小项时，
// score_ledger.event_id 被 ON DELETE SET NULL 置空而 voided 仍是 0，分数留在榜上、
// 之后任何按 event_id 的重算都打不到这些行。写侧（deleteEvent）已补上作废，这条迁移管历史那批。
//
// 三条底线：
//   - 只清 result / record_bonus。人工调整合法地就是 event_id 为 NULL，一刀切会吞掉合法调整分；
//   - 作废而不是删除，留 voided_at + void_reason 当审计痕迹，且不能覆盖已有的作废理由与时间；
//   - 幂等：连跑两次，榜与每一行都必须一模一样。
func TestMigration0022VoidsHistoricalOrphanLedger(t *testing.T) {
	db := openEventDB(t)
	applyBefore(t, db, "0022") // 回到「升级前」：库结构到 0021 为止，0022 还没跑过

	// 造现场：E1 是还在的小项；E2 是那种「只有团体名次、没有报名项」的小项，被删掉过。
	stmts := []string{
		`INSERT INTO teams(code, name) VALUES ('T1', '第一分公司')`,
		`INSERT INTO sports(code, name) VALUES ('SP1', '田径')`,
		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
		 VALUES (1, 'E1', '100米跑', 'individual', 'auto', 'time', 'asc', 'published')`,
		`INSERT INTO events(sport_id, code, name, event_type, result_mode, result_type, compare, status)
		 VALUES (1, 'E2', '篮球', 'team', 'manual', 'none', 'none', 'published')`,
		// 行 1：健康流水，挂在还在的 E1 上。
		`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
		 VALUES (1, 1, 'result', 1, 10)`,
		// 行 2、3：升级前的孤儿——删 E2 时 event_id 被置空、voided 还是 0（这条迁移要清的就是它们）。
		`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
		 VALUES (1, 2, 'result', 2, 4)`,
		`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points)
		 VALUES (1, 2, 'record_bonus', 2, 2)`,
		// 行 4：合法的人工调整，event_id 本来就允许为空，必须原样保留（防误伤的关键一条）。
		`INSERT INTO score_ledger(team_id, source_type, source_id, points)
		 VALUES (1, 'adjustment', 9, 7)`,
		// 行 5：升级前已经被正确作废过的孤儿，理由/时间都不能被这次清理改写。
		`INSERT INTO score_ledger(team_id, event_id, source_type, source_id, points, voided, voided_at, void_reason)
		 VALUES (1, 2, 'result', 3, 1, 1, '2026-09-01 08:00:00', '小项删除，本小项积分流水一并作废')`,
	}
	for _, s := range stmts {
		if _, err := db.Exec(s); err != nil {
			t.Fatalf("造升级前数据 %q: %v", s, err)
		}
	}
	// 旧删除路径：老 deleteEvent 只删小项本身（子表先删），流水只被外键置空。
	if _, err := db.Exec(`DELETE FROM events WHERE id = 2`); err != nil {
		t.Fatalf("按旧路径删除小项 E2: %v", err)
	}

	// 升级前：两条孤儿还活着，且分真的挂在榜上（这就是现场看到的错榜）。
	if got := queryInt(t, db, `SELECT count(*) FROM score_ledger WHERE `+orphanLedgerCond); got != 2 {
		t.Fatalf("升级前应有 2 条孤儿流水，得到 %d", got)
	}
	if got := boardPoints(t, db, 1); got != 23 {
		t.Fatalf("升级前孤儿分应还在榜上（10+4+2+7=23），得到 %v", got)
	}

	// 走真实升级路径（main.go 打开旧库后补跑的就是它），跑两次验幂等。
	if err := store.MigrateEvent(db); err != nil {
		t.Fatalf("第 1 次迁移: %v", err)
	}
	afterFirst := dumpLedger(t, db)
	if err := store.MigrateEvent(db); err != nil {
		t.Fatalf("第 2 次迁移: %v", err)
	}
	if got := dumpLedger(t, db); !reflect.DeepEqual(got, afterFirst) {
		t.Errorf("重复迁移改动了流水：\n第一次 %+v\n第二次 %+v", afterFirst, got)
	}
	if got, want := countRows(t, db, "schema_migrations"), migrationCount(t); got != want {
		t.Errorf("迁移登记数 = %d，期望 %d", got, want)
	}
	// 幂等还要经得起「迁移被重放」：store.migrate 的注释写明，schema_migrations 少一行
	// （手工删行 / 从别处拷来的库）就会把跑过的迁移再跑一遍。这里直接重放这条 SQL 的正文，
	// 结果必须与第一次一致——不改动分值，也不重写已作废流水的作废时间。
	if _, err := db.Exec(readMigration(t, "0022")); err != nil {
		t.Fatalf("重放 0022: %v", err)
	}
	if got := dumpLedger(t, db); !reflect.DeepEqual(got, afterFirst) {
		t.Errorf("重放 0022 改动了流水：\n重放前 %+v\n重放后 %+v", afterFirst, got)
	}

	// 作废是作废、不是删除：五行流水一行不少。
	if got := countRows(t, db, "score_ledger"); got != 5 {
		t.Fatalf("升级后流水行数 = %d，期望 5（作废要留审计痕迹，不能删行）", got)
	}
	if got := queryInt(t, db, `SELECT count(*) FROM score_ledger WHERE `+orphanLedgerCond); got != 0 {
		t.Errorf("升级后仍剩 %d 条存活孤儿流水", got)
	}

	// 工单①：行 2、3 两条孤儿被作废，且写明时间与原因；voided_by 留空表示「不是人做的，是升级清理」。
	for _, id := range []int64{2, 3} {
		var (
			voided     int
			voidedBy   sql.NullInt64
			voidedAt   sql.NullString
			voidReason sql.NullString
		)
		if err := db.QueryRow(`SELECT voided, voided_by, voided_at, void_reason FROM score_ledger WHERE id = ?`, id).
			Scan(&voided, &voidedBy, &voidedAt, &voidReason); err != nil {
			t.Fatalf("读流水 %d: %v", id, err)
		}
		if voided != 1 {
			t.Errorf("孤儿流水 %d 应被作废，voided = %d", id, voided)
		}
		if !voidedAt.Valid || voidedAt.String == "" {
			t.Errorf("孤儿流水 %d 缺少作废时间: %+v", id, voidedAt)
		}
		if !voidReason.Valid || voidReason.String != "event_id 已失效（历史孤儿）" {
			t.Errorf("孤儿流水 %d 的作废原因不对: %+v", id, voidReason)
		}
		if voidedBy.Valid {
			t.Errorf("孤儿流水 %d 的 voided_by 应留空（没有操作人），得到 %d", id, voidedBy.Int64)
		}
	}

	// 工单②：合法调整分原样保留——没被作废、没有理由、分值不变。
	var (
		points     float64
		voided     int
		voidedAt   sql.NullString
		voidReason sql.NullString
	)
	if err := db.QueryRow(`SELECT points, voided, voided_at, void_reason FROM score_ledger WHERE id = 4`).
		Scan(&points, &voided, &voidedAt, &voidReason); err != nil {
		t.Fatalf("读调整流水: %v", err)
	}
	if points != 7 || voided != 0 || voidedAt.Valid || voidReason.Valid {
		t.Errorf("人工调整被误伤: points=%v voided=%d voided_at=%+v void_reason=%+v", points, voided, voidedAt, voidReason)
	}
	// 行 1：健康流水（小项还在）不受影响。
	if got := queryInt(t, db, `SELECT voided FROM score_ledger WHERE id = 1`); got != 0 {
		t.Errorf("挂在还活着的小项上的流水被误作废: voided = %d", got)
	}
	// 行 5：早已作废的那条保留自己的理由与时间，不被这次清理重写。
	var (
		oldAt     sql.NullString
		oldReason sql.NullString
	)
	if err := db.QueryRow(`SELECT voided_at, void_reason FROM score_ledger WHERE id = 5`).Scan(&oldAt, &oldReason); err != nil {
		t.Fatalf("读老作废流水: %v", err)
	}
	if !oldAt.Valid || oldAt.String != "2026-09-01 08:00:00" ||
		!oldReason.Valid || oldReason.String != "小项删除，本小项积分流水一并作废" {
		t.Errorf("老作废痕迹被改写: voided_at=%+v void_reason=%+v", oldAt, oldReason)
	}

	// 榜单：孤儿分（4 与 2）消失，只留下健康分 10 与合法调整 7。连跑两次后仍是 17。
	if got := boardPoints(t, db, 1); got != 17 {
		t.Errorf("升级后单位总分应只剩 10+7=17，得到 %v", got)
	}

	fkRows, err := db.Query(`PRAGMA foreign_key_check`)
	if err != nil {
		t.Fatalf("外键检查: %v", err)
	}
	defer func() { _ = fkRows.Close() }()
	if fkRows.Next() {
		t.Error("清理后存在外键悬挂")
	}
}

// readMigration 取出嵌入的赛事库迁移正文（按文件名前缀找），
// 用于在测试里直接重放某一条迁移，验证 SQL 自身的幂等。
func readMigration(t *testing.T, prefix string) string {
	t.Helper()

	fsys, err := fs.Sub(migrations.EventFS, "event")
	if err != nil {
		t.Fatalf("定位迁移目录: %v", err)
	}
	names, err := fs.Glob(fsys, prefix+"*.sql")
	if err != nil {
		t.Fatalf("列出迁移: %v", err)
	}
	if len(names) != 1 {
		t.Fatalf("迁移 %s*.sql 命中 %d 个文件: %v", prefix, len(names), names)
	}
	body, err := fs.ReadFile(fsys, names[0])
	if err != nil {
		t.Fatalf("读取迁移 %s: %v", names[0], err)
	}
	return string(body)
}

// boardPoints 走真实的大屏读路径（实时快照）取某单位的总分：
// 「孤儿分是否还挂在榜上」要按大屏看到的口径判定，而不是数 score_ledger 的行数。
func boardPoints(t *testing.T, db *sql.DB, teamID int64) float64 {
	t.Helper()

	hub := realtime.NewHub(db, slog.New(slog.NewTextHandler(io.Discard, nil)))
	defer func() { _ = hub.Close() }()
	snap, err := hub.Snapshot(context.Background())
	if err != nil {
		t.Fatalf("取榜单快照: %v", err)
	}
	for _, row := range snap.Standings {
		if row.TeamID == teamID {
			return row.TotalPoints
		}
	}
	t.Fatalf("榜单里没有单位 %d: %+v", teamID, snap.Standings)
	return 0
}

// ledgerRow 是流水行的完整快照，用于比对「连跑两次」有没有改动任何一格。
type ledgerRow struct {
	id         int64
	points     float64
	voided     int
	voidedBy   sql.NullInt64
	voidedAt   sql.NullString
	voidReason sql.NullString
}

func dumpLedger(t *testing.T, db *sql.DB) []ledgerRow {
	t.Helper()

	rows, err := db.Query(`SELECT id, points, voided, voided_by, voided_at, void_reason
	                       FROM score_ledger ORDER BY id`)
	if err != nil {
		t.Fatalf("读流水: %v", err)
	}
	defer func() { _ = rows.Close() }()

	var out []ledgerRow
	for rows.Next() {
		var r ledgerRow
		if err := rows.Scan(&r.id, &r.points, &r.voided, &r.voidedBy, &r.voidedAt, &r.voidReason); err != nil {
			t.Fatalf("解析流水: %v", err)
		}
		out = append(out, r)
	}
	if err := rows.Err(); err != nil {
		t.Fatalf("遍历流水: %v", err)
	}
	return out
}

func queryInt(t *testing.T, db *sql.DB, query string, args ...any) int {
	t.Helper()

	var n int
	if err := db.QueryRow(query, args...).Scan(&n); err != nil {
		t.Fatalf("查询 %q: %v", query, err)
	}
	return n
}