// FundService 单测（AC-04）：充值双表 / 幂等（含 20 并发）/ 消费三列组合 / 退费 BUG#2 /
// 可退金额 / 坏账 / 累计消费 / 落库金额越界负例。
//
// 测试栈（与 AC-03 仓储测试同一套手法）：
//   - 行为用例：glebarez/sqlite 文件库（真实事务、真实唯一键 uk_request_type）；
//   - SQL 顺序用例：给 GORM 挂"抓 SQL"的 logger（sqlRecorder），断言仓储**真实生成**的语句顺序；
//   - 索引纪律：academic model 多表共用 `idx_inst_campus` 等索引名，SQLite 的索引名是**库级**唯一
//     （MySQL 表级），故 migrateFundTables 逐表迁移后**只删非唯一索引**——
//     `uk_request_type` / `uk_user_activity` / `uk_user_inst_campus` 必须保留，
//     否则幂等用例会静默变成"永远不撞键"的假绿。
package service

import (
	"context"
	"errors"
	"fmt"
	"path/filepath"
	"strings"
	"sync"
	"testing"
	"time"

	gormsqlite "github.com/glebarez/sqlite"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"

	"yuansiwei/unified-backend/internal/academic/apperr"
	"yuansiwei/unified-backend/internal/academic/model"
	"yuansiwei/unified-backend/internal/academic/money"
	"yuansiwei/unified-backend/internal/academic/repository"
	infraerrors "yuansiwei/unified-backend/internal/infra/errors"
	appscope "yuansiwei/unified-backend/internal/infra/scope"
)

// ---------------------------------------------------------------- 测试基础设施

// sqlRecorder GORM logger：按执行顺序收集 SQL（不改写、不过滤）。
//
// 用途：断言"全局账户锁先于校区账户锁"这类**顺序性**红约束（顺序错 = 与并发充值交叉即成环）。
// 只实现 logger.Interface 的最小集合（Trace 收到 Explain 后的完整 SQL）。
type sqlRecorder struct {
	mu    sync.Mutex
	stmts []string
}

// Printf 收口（logger.Writer 兼容方法）。
func (r *sqlRecorder) Printf(format string, args ...any) {
	msg := strings.TrimSpace(fmt.Sprintf(format, args...))
	if msg == "" {
		return
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	r.stmts = append(r.stmts, msg)
}

// LogMode 实现 logger.Interface（不做级别过滤）。
func (r *sqlRecorder) LogMode(logger.LogLevel) logger.Interface { return r }

// Info 实现 logger.Interface（单测不需要普通日志）。
func (r *sqlRecorder) Info(context.Context, string, ...any) {}

// Warn 实现 logger.Interface。
func (r *sqlRecorder) Warn(context.Context, string, ...any) {}

// Error 实现 logger.Interface。
func (r *sqlRecorder) Error(context.Context, string, ...any) {}

// Trace 实现 logger.Interface：把本次语句追加进 stmts。
func (r *sqlRecorder) Trace(_ context.Context, _ time.Time, fc func() (string, int64), _ error) {
	sql, _ := fc()
	r.Printf("%s", sql)
}

// Snapshot 返回当前收集到的语句快照（调用方不得修改返回切片内部元素语义）。
func (r *sqlRecorder) Snapshot() []string {
	r.mu.Lock()
	defer r.mu.Unlock()
	out := make([]string, len(r.stmts))
	copy(out, r.stmts)
	return out
}

// Reset 清空收集。
func (r *sqlRecorder) Reset() {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.stmts = nil
}

// migrateFundTables 逐表 AutoMigrate，并**只删除非唯一索引**。
//
// 为什么只删非唯一：SQLite 索引名库级唯一（`idx_inst_campus` 同时出现在
// t_user_expense_school 与 t_courses_activity_signed），一次性迁移会报 already exists；
// 但 `uk_request_type` / `uk_user_activity` / `uk_user_inst_campus` 是**幂等与唯一性的实现载体**，
// 删掉会让"并发重复提交只落 1 条流水"的用例变成永远通过的假绿。
func migrateFundTables(t *testing.T, db *gorm.DB, tables ...any) {
	t.Helper()
	for _, tbl := range tables {
		if err := db.AutoMigrate(tbl); err != nil {
			t.Fatalf("AutoMigrate(%T) 失败: %v", tbl, err)
		}
		stmt := &gorm.Statement{DB: db}
		if err := stmt.Parse(tbl); err != nil {
			t.Fatalf("解析表名(%T) 失败: %v", tbl, err)
		}
		type idxRow struct {
			Name string
			SQL  *string
		}
		var rows []idxRow
		if err := db.Raw(
			"SELECT name, sql FROM sqlite_master WHERE type = 'index' AND tbl_name = ? AND name NOT LIKE 'sqlite_%'",
			stmt.Schema.Table).Scan(&rows).Error; err != nil {
			t.Fatalf("读取索引清单(%s) 失败: %v", stmt.Schema.Table, err)
		}
		for _, row := range rows {
			sqlText := ""
			if row.SQL != nil {
				sqlText = strings.ToUpper(*row.SQL)
			}
			if strings.Contains(sqlText, "UNIQUE") {
				continue // 唯一约束必须保留（幂等键/业务 UK）
			}
			if err := db.Exec("DROP INDEX IF EXISTS `" + row.Name + "`").Error; err != nil {
				t.Fatalf("删除索引(%s) 失败: %v", row.Name, err)
			}
		}
	}
}

// newFundServiceDB 余额域测试库（余额 3 表 + 活动 2 表 + 简化 t_campus）。
//
// t_campus 用原生 DDL 建（academic 侧只有 port 的只读 row struct，不参与 AutoMigrate，
// 这正是设计 §1.3「跨域只读」的落地形态：academic 不建 org 的表，只读）。
func newFundServiceDB(t *testing.T) *gorm.DB {
	t.Helper()
	db, _ := newFundServiceDBWithRecorder(t)
	return db
}

// newFundServiceDBWithRecorder 同 newFundServiceDB，并返回 SQL 记录器。
func newFundServiceDBWithRecorder(t *testing.T) (*gorm.DB, *sqlRecorder) {
	t.Helper()
	dsn := filepath.Join(t.TempDir(), "academic_fund_service_test.db")
	rec := &sqlRecorder{}
	db, err := gorm.Open(gormsqlite.Open(dsn), &gorm.Config{Logger: rec})
	if err != nil {
		t.Fatalf("gorm.Open(余额域文件库) 失败: %v", err)
	}
	sqlDB, err := db.DB()
	if err != nil {
		t.Fatalf("取 sql.DB 失败: %v", err)
	}
	// 并发用例需要"多 goroutine 抢同一库"：SQLite 写事务必须串行，
	// 单连接池即可让 20 个 goroutine 依次推进（生产 MySQL 是行锁串行，此处用连接池串行等价模拟）。
	sqlDB.SetMaxOpenConns(1)
	t.Cleanup(func() { _ = sqlDB.Close() })

	migrateFundTables(t, db,
		&model.UserExpense{}, &model.UserExpenseSchool{}, &model.UserExpenseLog{},
		&model.CoursesActivity{}, &model.CoursesActivitySigned{},
	)
	// 跨域只读表（org 域 t_campus 的最小列集；self_support 为 1=自营 / 0=加盟）
	if err := db.Exec(`CREATE TABLE t_campus (
		campus_id INTEGER PRIMARY KEY,
		institution_id INTEGER NOT NULL DEFAULT 0,
		self_support BOOLEAN NOT NULL DEFAULT 1,
		status VARCHAR(32) NOT NULL DEFAULT 'active'
	)`).Error; err != nil {
		t.Fatalf("建 t_campus 失败: %v", err)
	}
	return db, rec
}

// fundUserID 生成 26 位类 ULID 的测试用户 ID（列宽 varchar(26)）。
func fundUserID(i int) string { return fmt.Sprintf("01HUSER%019d", i) }

// fundScope 构造普通校区作用域（机构 1 / 校区 10）。
func fundScope() *appscope.Scope {
	return &appscope.Scope{InstitutionID: 1, CampusID: 10, UserID: "01HOPERATOR0000000000001", Role: "finance"}
}

// fundScopeFor 构造指定机构/校区的作用域（跨机构用例）。
func fundScopeFor(institutionID, campusID int64) *appscope.Scope {
	return &appscope.Scope{InstitutionID: institutionID, CampusID: campusID, UserID: "01HOPERATOR0000000000001", Role: "finance"}
}

// fundSuperScope 平台超管作用域（跨机构视角，用于"必须能同时看到两个机构"的用例）。
func fundSuperScope() *appscope.Scope {
	return &appscope.Scope{InstitutionID: 1, CampusID: 0, UserID: "01HSUPERADMIN0000000001", Role: "super_admin", SuperAdmin: true}
}

// mustAmount 解析金额（测试内固定字面量）。
func mustAmount(t *testing.T, s string) money.Amount {
	t.Helper()
	a, err := money.Parse(s)
	if err != nil {
		t.Fatalf("金额解析失败 %q: %v", s, err)
	}
	return a
}

// seedCampus 落一行 t_campus（self_support: true=自营 / false=加盟）。
func seedCampus(t *testing.T, db *gorm.DB, campusID, institutionID int64, selfSupport bool) {
	t.Helper()
	if err := db.Exec(
		"INSERT INTO t_campus(campus_id, institution_id, self_support, status) VALUES(?,?,?,?)",
		campusID, institutionID, selfSupport, "active").Error; err != nil {
		t.Fatalf("seed t_campus(%d) 失败: %v", campusID, err)
	}
}

// readGlobal 读全局钱包。
func readGlobal(t *testing.T, db *gorm.DB, userID string) model.UserExpense {
	t.Helper()
	var row model.UserExpense
	if err := db.Where("user_id = ?", userID).Take(&row).Error; err != nil {
		t.Fatalf("读全局账户(%s) 失败: %v", userID, err)
	}
	return row
}

// readSchool 读校区账户。
func readSchool(t *testing.T, db *gorm.DB, userID string, institutionID, campusID int64) model.UserExpenseSchool {
	t.Helper()
	var row model.UserExpenseSchool
	if err := db.Where("user_id = ? AND institution_id = ? AND campus_id = ?", userID, institutionID, campusID).
		Take(&row).Error; err != nil {
		t.Fatalf("读校区账户(%s/%d/%d) 失败: %v", userID, institutionID, campusID, err)
	}
	return row
}

// logsByType 取某用户的指定 type 流水（按 id ASC）。
func logsByType(t *testing.T, db *gorm.DB, userID string, typ int32) []model.UserExpenseLog {
	t.Helper()
	var rows []model.UserExpenseLog
	if err := db.Where("user_id = ? AND type = ?", userID, typ).Order("id ASC").Find(&rows).Error; err != nil {
		t.Fatalf("读流水(type=%d) 失败: %v", typ, err)
	}
	return rows
}

// countLogs 统计某用户指定 type 的流水条数。
func countLogsByType(t *testing.T, db *gorm.DB, userID string, typ int32) int {
	t.Helper()
	return len(logsByType(t, db, userID, typ))
}

// ---------------------------------------------------------------- 充值（SP1 / SP2）

// TestRechargeUpdatesBothTables 充值双表同事务：全局 + 校区 balance/total_income 同步，流水含 balance_after。
func TestRechargeUpdatesBothTables(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(1)

	res, err := svc.Recharge(ctx, RechargeInput{
		UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "100.00"), RequestID: "REQ-RECHARGE-1",
	})
	if err != nil {
		t.Fatalf("Recharge 失败: %v", err)
	}
	if res.Repeated {
		t.Fatalf("首次充值不应 repeated=true")
	}
	if res.LogID <= 0 {
		t.Fatalf("logId 应 > 0，实得 %d", res.LogID)
	}
	if got := cents(t, res.Balance.String()); got != 10000 {
		t.Fatalf("返回余额=%d 分，期望 10000", got)
	}

	global := readGlobal(t, db, user)
	if got := cents(t, global.Balance); got != 10000 {
		t.Fatalf("全局 balance=%d 分，期望 10000", got)
	}
	if got := cents(t, global.TotalIncome); got != 10000 {
		t.Fatalf("全局 total_income=%d 分，期望 10000", got)
	}
	school := readSchool(t, db, user, 1, 10)
	if got := cents(t, school.Balance); got != 10000 {
		t.Fatalf("校区 balance=%d 分，期望 10000", got)
	}
	if got := cents(t, school.TotalIncome); got != 10000 {
		t.Fatalf("校区 total_income=%d 分，期望 10000", got)
	}

	logs := logsByType(t, db, user, model.ExpenseLogTypeRecharge)
	if len(logs) != 1 {
		t.Fatalf("充值流水应为 1 条，实得 %d", len(logs))
	}
	if got := cents(t, logs[0].Money); got != 10000 {
		t.Fatalf("流水 money=%d 分，期望 10000（方向为正）", got)
	}
	if logs[0].RequestID == nil || *logs[0].RequestID != "REQ-RECHARGE-1" {
		t.Fatalf("流水 request_id 未落：%+v", logs[0].RequestID)
	}
	if logs[0].BalanceAfter == nil || cents(t, *logs[0].BalanceAfter) != 10000 {
		t.Fatalf("流水 balance_after 快照错误：%+v", logs[0].BalanceAfter)
	}
	if logs[0].Remark == nil || *logs[0].Remark != defaultRechargeRemark {
		t.Fatalf("流水 remark 默认文案错误：%+v", logs[0].Remark)
	}
}

// TestRechargeKindSetsSchoolRemark SP1 / SP2 的唯一差异：默认备注文案。
func TestRechargeKindSetsSchoolRemark(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(2)

	if _, err := svc.Recharge(ctx, RechargeInput{
		UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "10.00"), RequestID: "REQ-KIND-1", Kind: RechargeKindSchool,
	}); err != nil {
		t.Fatalf("Recharge(Kind=School) 失败: %v", err)
	}
	logs := logsByType(t, db, user, model.ExpenseLogTypeRecharge)
	if len(logs) != 1 || logs[0].Remark == nil || *logs[0].Remark != defaultSchoolRechargeRemark {
		t.Fatalf("SP2 默认备注应为 %q，实得 %+v", defaultSchoolRechargeRemark, logs)
	}
}

// TestRechargeIdempotentSameRequestID 同 requestId 第二次提交 → repeated=true、不重复入账。
func TestRechargeIdempotentSameRequestID(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(3)
	in := RechargeInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "50.00"), RequestID: "REQ-IDEMPOTENT-1"}

	first, err := svc.Recharge(ctx, in)
	if err != nil {
		t.Fatalf("首次充值失败: %v", err)
	}
	second, err := svc.Recharge(ctx, in)
	if err != nil {
		t.Fatalf("重复充值应返回成功（幂等），实得错误: %v", err)
	}
	if !second.Repeated {
		t.Fatalf("重复提交应 repeated=true")
	}
	if second.LogID != first.LogID {
		t.Fatalf("重复提交应回放首次 logId=%d，实得 %d", first.LogID, second.LogID)
	}
	if count := countLogsByType(t, db, user, model.ExpenseLogTypeRecharge); count != 1 {
		t.Fatalf("流水应只 1 条，实得 %d", count)
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).Balance); got != 5000 {
		t.Fatalf("余额应只变一次（5000 分），实得 %d", got)
	}
}

// TestRechargeConcurrentSameRequestID 20 goroutine 同 requestId → 1 条流水、余额只变一次。
//
// SQLite 无行锁，用单连接池把写事务串行化（等价于 MySQL 的行锁串行语义）；
// 断言点与生产一致：**流水条数**与**余额增量**（不是"是否报错"）。
func TestRechargeConcurrentSameRequestID(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(4)
	in := RechargeInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "30.00"), RequestID: "REQ-CONCURRENT-1"}

	const goroutines = 20
	var wg sync.WaitGroup
	results := make([]*RechargeResult, goroutines)
	errs := make([]error, goroutines)
	for i := 0; i < goroutines; i++ {
		wg.Add(1)
		go func(idx int) {
			defer wg.Done()
			results[idx], errs[idx] = svc.Recharge(ctx, in)
		}(i)
	}
	wg.Wait()

	for i, err := range errs {
		if err != nil {
			t.Fatalf("并发第 %d 次充值失败: %v", i, err)
		}
	}
	if count := countLogsByType(t, db, user, model.ExpenseLogTypeRecharge); count != 1 {
		t.Fatalf("并发同 requestId 应只 1 条流水，实得 %d", count)
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).Balance); got != 3000 {
		t.Fatalf("余额应只入账一次（3000 分），实得 %d", got)
	}
	repeated := 0
	for _, r := range results {
		if r != nil && r.Repeated {
			repeated++
		}
	}
	if repeated != goroutines-1 {
		t.Fatalf("应有 %d 次 repeated=true，实得 %d", goroutines-1, repeated)
	}
}

// TestRechargeValidation 入参校验：空用户 2001 / 校区缺失 3140 / 金额<=0 与超上限 2002。
func TestRechargeValidation(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()

	cases := []struct {
		name string
		in   RechargeInput
		want int
	}{
		{"空用户", RechargeInput{UserID: "", InstitutionID: 1, CampusID: 10, Money: mustAmount(t, "1.00")}, 2001},
		{"校区缺失", RechargeInput{UserID: fundUserID(5), InstitutionID: 1, CampusID: 0, Money: mustAmount(t, "1.00")}, 3140},
		{"机构缺失", RechargeInput{UserID: fundUserID(5), InstitutionID: 0, CampusID: 10, Money: mustAmount(t, "1.00")}, 3140},
		{"金额为 0", RechargeInput{UserID: fundUserID(5), InstitutionID: 1, CampusID: 10, Money: 0}, 2002},
		{"金额为负", RechargeInput{UserID: fundUserID(5), InstitutionID: 1, CampusID: 10, Money: mustAmount(t, "-1.00")}, 2002},
		{"超单笔上限", RechargeInput{UserID: fundUserID(5), InstitutionID: 1, CampusID: 10,
			Money: mustAmount(t, "1000000.01")}, 2002},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			_, err := svc.Recharge(ctx, tc.in)
			requireAppCode(t, err, tc.want)
		})
	}
}

// ---------------------------------------------------------------- 消费（SP3）

// TestExpenditureTypeBranches dump 的两个列组合分支 + 流水方向为负。
func TestExpenditureTypeBranches(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(6)

	if _, err := svc.Recharge(ctx, RechargeInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "100.00")}); err != nil {
		t.Fatalf("准备余额失败: %v", err)
	}

	// type=200（历史扣费）：balance−、total_expenditure+、spend+
	if _, err := svc.Expenditure(ctx, ExpenditureInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "30.00"), Type: model.ExpenseLogTypeHistoryDeduct, RequestID: "REQ-EXP-200"}); err != nil {
		t.Fatalf("Expenditure(200) 失败: %v", err)
	}
	school := readSchool(t, db, user, 1, 10)
	if got := cents(t, school.Balance); got != 7000 {
		t.Fatalf("200 后 balance 应 7000 分，实得 %d", got)
	}
	if got := cents(t, school.TotalExpenditure); got != 3000 {
		t.Fatalf("200 后 total_expenditure 应 3000 分，实得 %d", got)
	}
	if got := cents(t, school.Spend); got != 3000 {
		t.Fatalf("200 后 spend 应 3000 分，实得 %d", got)
	}

	// type=201（校区报课消费）：balance−、total_expenditure+，**spend 不动**
	if _, err := svc.Expenditure(ctx, ExpenditureInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "20.00"), Type: model.ExpenseLogTypeCourseCampusB, RequestID: "REQ-EXP-201"}); err != nil {
		t.Fatalf("Expenditure(201) 失败: %v", err)
	}
	school = readSchool(t, db, user, 1, 10)
	if got := cents(t, school.Balance); got != 5000 {
		t.Fatalf("201 后 balance 应 5000 分，实得 %d", got)
	}
	if got := cents(t, school.TotalExpenditure); got != 5000 {
		t.Fatalf("201 后 total_expenditure 应 5000 分，实得 %d", got)
	}
	if got := cents(t, school.Spend); got != 3000 {
		t.Fatalf("201 不应改 spend（应仍 3000 分），实得 %d", got)
	}
	// 全局表同列同步
	global := readGlobal(t, db, user)
	if got := cents(t, global.Balance); got != 5000 {
		t.Fatalf("全局 balance 应 5000 分，实得 %d", got)
	}
	if got := cents(t, global.TotalExpenditure); got != 5000 {
		t.Fatalf("全局 total_expenditure 应 5000 分，实得 %d", got)
	}

	// 流水金额恒为负（dump: `VALUES(...,-inputMoney,...)`）
	logs := logsByType(t, db, user, model.ExpenseLogTypeHistoryDeduct)
	if len(logs) != 1 {
		t.Fatalf("200 流水应 1 条，实得 %d", len(logs))
	}
	if got := cents(t, logs[0].Money); got != -3000 {
		t.Fatalf("200 流水 money 应 -3000 分，实得 %d", got)
	}
}

// TestExpenditureInvalidType 白名单外 type → 2002（dump 会静默改成 200，Go 显式拒绝）。
func TestExpenditureInvalidType(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	_, err := svc.Expenditure(context.Background(), ExpenditureInput{
		UserID: fundUserID(7), InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "10.00"), Type: 999,
	})
	requireAppCode(t, err, 2002)
}

// ---------------------------------------------------------------- 退费（SP4，BUG#2）

// TestRefundInstitutionFilterPreventsCrossInstitutionUpdate BUG#2 回归：
// 同一 campus_id 在两个机构都有账户行时，只允许更新入参机构那一行。
//
// dump 的 WHERE 是 `userid + campusid`（无 schoolid）→ 两行都会被改；Go 补 institution_id。
func TestRefundInstitutionFilterPreventsCrossInstitutionUpdate(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundSuperScope(), nil) // 超管视角：底层两行都可见
	ctx := context.Background()
	user := fundUserID(8)

	// 两个机构、同一个 campus_id=10
	for _, inst := range []int64{1, 2} {
		if err := db.Create(&model.UserExpenseSchool{
			UserID: user, InstitutionID: inst, CampusID: 10,
			Balance: "100.00", TotalExpenditure: "50.00",
		}).Error; err != nil {
			t.Fatalf("seed 校区账户(inst=%d) 失败: %v", inst, err)
		}
	}
	if err := db.Create(&model.UserExpense{UserID: user, Balance: "200.00", TotalExpenditure: "50.00"}).Error; err != nil {
		t.Fatalf("seed 全局账户失败: %v", err)
	}

	res, err := svc.Refund(ctx, RefundInput{
		UserID: user, InstitutionID: 1, CampusID: 10, Money: mustAmount(t, "20.00"),
		Type: model.ExpenseLogTypeCourseCampus, RequestID: "REQ-REFUND-1",
	})
	if err != nil {
		t.Fatalf("Refund 失败: %v", err)
	}
	if !res.Changed {
		t.Fatalf("Refund 应 changed=true")
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).Balance); got != 12000 {
		t.Fatalf("目标机构 balance 应 12000 分，实得 %d", got)
	}
	// 另一机构必须零变动（BUG#2 的核心断言）
	if got := cents(t, readSchool(t, db, user, 2, 10).Balance); got != 10000 {
		t.Fatalf("另一机构 balance 必须不变（10000 分），实得 %d", got)
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).TotalExpenditure); got != 3000 {
		t.Fatalf("目标机构 total_expenditure 应 3000 分（退费回冲），实得 %d", got)
	}
	logs := logsByType(t, db, user, model.ExpenseLogTypeCourseCampus)
	if len(logs) != 1 || cents(t, logs[0].Money) != 2000 {
		t.Fatalf("退费流水应为 +2000 分一条，实得 %+v", logs)
	}
}

// TestRefundZeroMoneyIsNoop money<=0 → changed=false（对齐 dump `IF inputMoney>0`），不写流水。
func TestRefundZeroMoneyIsNoop(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	user := fundUserID(9)
	res, err := svc.Refund(context.Background(), RefundInput{
		UserID: user, InstitutionID: 1, CampusID: 10, Money: 0, Type: model.ExpenseLogTypeCourseCampus,
	})
	if err != nil {
		t.Fatalf("money=0 应返回成功（no-op），实得错误: %v", err)
	}
	if res.Changed || res.Repeated || res.LogID != 0 {
		t.Fatalf("money=0 应 changed=false 且无流水，实得 %+v", res)
	}
	if count := countLogsByType(t, db, user, model.ExpenseLogTypeCourseCampus); count != 0 {
		t.Fatalf("no-op 不应写流水，实得 %d 条", count)
	}
}

// TestRefundAccountMissing 账户未建户 → 3001（dump 静默无操作；Go 显式失败）。
func TestRefundAccountMissing(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	_, err := svc.Refund(context.Background(), RefundInput{
		UserID: fundUserID(10), InstitutionID: 1, CampusID: 10, Money: mustAmount(t, "5.00"),
		Type: model.ExpenseLogTypeCourseCampus,
	})
	requireAppCode(t, err, 3001)
}

// ---------------------------------------------------------------- 可退金额（SP5）

// TestRefundableAmount 账户不存在 → 0；负余额 → 0；正余额 → 余额。
func TestRefundableAmount(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()

	// 账户不存在
	if got, err := svc.RefundableAmount(ctx, fundUserID(11), 1, 10); err != nil || got != 0 {
		t.Fatalf("账户不存在应返回 0 且无错，实得 (%d, %v)", got, err)
	}
	// 负数余额（欠费）
	if err := db.Create(&model.UserExpenseSchool{UserID: fundUserID(12), InstitutionID: 1, CampusID: 10,
		Balance: "-25.00"}).Error; err != nil {
		t.Fatalf("seed 欠费账户失败: %v", err)
	}
	if got, err := svc.RefundableAmount(ctx, fundUserID(12), 1, 10); err != nil || got != 0 {
		t.Fatalf("负余额应返回 0，实得 (%d, %v)", got, err)
	}
	// 正余额
	if err := db.Create(&model.UserExpenseSchool{UserID: fundUserID(13), InstitutionID: 1, CampusID: 10,
		Balance: "88.50"}).Error; err != nil {
		t.Fatalf("seed 正余额账户失败: %v", err)
	}
	if got, err := svc.RefundableAmount(ctx, fundUserID(13), 1, 10); err != nil || got.Cents() != 8850 {
		t.Fatalf("正余额应返回 8850 分，实得 (%d, %v)", got, err)
	}
	// 校区缺失 → 3140
	if _, err := svc.RefundableAmount(ctx, fundUserID(13), 1, 0); err != nil {
		requireAppCode(t, err, 3140)
	}
}

// ---------------------------------------------------------------- 坏账（SP7）

// TestBadDebtOnlySpecialExpenses 只加 special_expenses（**不动 balance**），108 流水为正。
func TestBadDebtOnlySpecialExpenses(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(14)

	if _, err := svc.Recharge(ctx, RechargeInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "100.00")}); err != nil {
		t.Fatalf("准备余额失败: %v", err)
	}
	res, err := svc.BadDebt(ctx, BadDebtInput{UserID: user, InstitutionID: 1, CampusID: 10,
		Money: mustAmount(t, "30.00")})
	if err != nil {
		t.Fatalf("BadDebt 失败: %v", err)
	}
	school := readSchool(t, db, user, 1, 10)
	if got := cents(t, school.Balance); got != 10000 {
		t.Fatalf("坏账不应改 balance（应仍 10000 分），实得 %d", got)
	}
	if got := cents(t, school.SpecialExpenses); got != 3000 {
		t.Fatalf("special_expenses 应 3000 分，实得 %d", got)
	}
	global := readGlobal(t, db, user)
	if got := cents(t, global.SpecialExpenses); got != 3000 {
		t.Fatalf("全局 special_expenses 应 3000 分（双表同步），实得 %d", got)
	}
	if got := cents(t, global.Balance); got != 10000 {
		t.Fatalf("全局 balance 不应变（应仍 10000 分），实得 %d", got)
	}
	if res.SpecialExpenses.Cents() != 3000 {
		t.Fatalf("返回 specialExpenses 应 3000 分，实得 %d", res.SpecialExpenses.Cents())
	}
	logs := logsByType(t, db, user, model.ExpenseLogTypeBadDebt)
	if len(logs) != 1 || cents(t, logs[0].Money) != 3000 {
		t.Fatalf("108 流水应为 +3000 分一条，实得 %+v", logs)
	}
}

// ---------------------------------------------------------------- 累计消费（SP11，BUG#1）

// TestAccumulateSpendOnlySpend 只更新 spend（不动 balance），且**不写流水**；负数归 0。
func TestAccumulateSpendOnlySpend(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(15)

	// 账户不存在时也应能建户并写 spend（dump 的 INSERT 分支；BUG#1 修正前该分支是 3 值对 2 列必报错）
	res, err := svc.AccumulateSpend(ctx, SpendInput{UserID: user, InstitutionID: 1, CampusID: 10,
		SpendMoney: mustAmount(t, "25.00")})
	if err != nil {
		t.Fatalf("AccumulateSpend 失败: %v", err)
	}
	if res.Spend.Cents() != 2500 {
		t.Fatalf("返回 spend 应 2500 分，实得 %d", res.Spend.Cents())
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).Spend); got != 2500 {
		t.Fatalf("校区 spend 应 2500 分，实得 %d", got)
	}
	if got := cents(t, readGlobal(t, db, user).Spend); got != 2500 {
		t.Fatalf("全局 spend 应 2500 分，实得 %d", got)
	}
	if got := cents(t, readSchool(t, db, user, 1, 10).Balance); got != 0 {
		t.Fatalf("spend SP 不得改 balance（应 0），实得 %d", got)
	}
	var total int64
	if err := db.Model(&model.UserExpenseLog{}).Where("user_id = ?", user).Count(&total).Error; err != nil {
		t.Fatalf("统计流水失败: %v", err)
	}
	if total != 0 {
		t.Fatalf("spend SP 不写流水（dump 无 INSERT log），实得 %d 条", total)
	}

	// 负数一律归 0（dump INSERT 分支同口径；spend 只增）
	res, err = svc.AccumulateSpend(ctx, SpendInput{UserID: user, InstitutionID: 1, CampusID: 10,
		SpendMoney: mustAmount(t, "-10.00")})
	if err != nil {
		t.Fatalf("AccumulateSpend(负数) 失败: %v", err)
	}
	if res.Spend.Cents() != 2500 {
		t.Fatalf("负数应被归 0（spend 仍 2500 分），实得 %d", res.Spend.Cents())
	}
}

// ---------------------------------------------------------------- 幂等键与金额越界（负例）

// TestInsertLogDuplicateMapsToRepeated 撞 uk_request_type → 内部哨兵 3114（不是 5002）。
func TestInsertLogDuplicateMapsToRepeated(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(16)

	mk := func() *model.UserExpenseLog {
		return newExpenseLog(user, model.ExpenseLogTypeRecharge, mustAmount(t, "1.00"),
			"REQ-DUP-1", "dup", "", nil)
	}
	if err := db.Transaction(func(tx *gorm.DB) error {
		return svc.insertLog(repository.WithTxContext(ctx, tx), tx, mk())
	}); err != nil {
		t.Fatalf("首次写流水失败: %v", err)
	}
	err := db.Transaction(func(tx *gorm.DB) error {
		return svc.insertLog(repository.WithTxContext(ctx, tx), tx, mk())
	})
	if !errors.Is(err, apperr.ErrRepeated) {
		t.Fatalf("同 request_id+type 二次写入应映射为 3114 幂等哨兵，实得: %v", err)
	}
}

// TestAmountOverflowRejectedBeforeWrite AC-04 的落库负例：
// 超出 decimal(12,2) 全域的金额必须在**写库前**被 `Amount.Validate()` 拦下（ErrOverflow），
// 且账户零残留（不是"写了个截断值"）。
func TestAmountOverflowRejectedBeforeWrite(t *testing.T) {
	db := newFundServiceDB(t)
	svc := NewFundService(db, fundScope(), nil)
	ctx := context.Background()
	user := fundUserID(17)

	if err := db.Create(&model.UserExpense{UserID: user, Balance: "0.00"}).Error; err != nil {
		t.Fatalf("seed 全局账户失败: %v", err)
	}
	if err := db.Create(&model.UserExpenseSchool{UserID: user, InstitutionID: 1, CampusID: 10,
		Balance: "0.00"}).Error; err != nil {
		t.Fatalf("seed 校区账户失败: %v", err)
	}

	overflow := money.MaxAmount + 1
	err := db.Transaction(func(tx *gorm.DB) error {
		_, e := svc.repo.AddColumnsGlobalThenCampus(ctx, tx, "OverflowTest", user, 1, 10,
			repository.ColumnDelta{Column: repository.ExpenseColumnBalance, Delta: overflow})
		return e
	})
	if !errors.Is(err, money.ErrOverflow) {
		t.Fatalf("越界金额应返回 money.ErrOverflow，实得: %v", err)
	}
	var appErr *infraerrors.AppError
	if !errors.As(err, &appErr) {
		t.Fatalf("越界金额应返回 *AppError，实得: %v", err)
	}
	// 仓储层（AC-03 既有形状）把越界金额挂在 2001 哨兵上；Service 层对**入参**金额用 2002
	// （见 validatePositiveAmount）。此处断言的是"落库前被拦下"这一红约束，两层都属 2xxx 参数错。
	if appErr.Code != infraerrors.ErrBadParam.Code && appErr.Code != infraerrors.ErrBadFormat.Code {
		t.Fatalf("越界金额应映射为 2xxx 参数错，实得 %d: %v", appErr.Code, err)
	}
	if got := cents(t, readGlobal(t, db, user).Balance); got != 0 {
		t.Fatalf("越界金额不得落库（余额应仍 0），实得 %d", got)
	}
}