DEV-MERGE-LEGACY-BACKEND-2026/internal/academic/repository/activity_discount_repo_test.go

// ActivityDiscountRepo 单测（AC-06）：可用额口径 / dump 3 参汇总 / 原子增减 / 批量单语句 CASE。
package repository

import (
	"context"
	"errors"
	"strings"
	"testing"
	"time"

	"gorm.io/gorm"

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

// seedPool 插入一条赠送金额池（显式 ID）。
func seedPool(t *testing.T, db *gorm.DB, id, inst, campus int64, userID, discount, used string) {
	t.Helper()
	row := &model.CoursesActivityUserDiscount{
		ID:                 id,
		ActivityID:         1,
		InstitutionID:      inst,
		CampusID:           campus,
		UserID:             userID,
		Income:             "0.00",
		DiscountAmount:     discount,
		DiscountAmountUsed: used,
		CreateTime:         time.Now(),
	}
	if err := db.Create(row).Error; err != nil {
		t.Fatalf("seed pool(%d) 失败: %v", id, err)
	}
}

// amountOf 读取池的「已使用金额」（money 归类，规避 sqlite NUMERIC 回读差异）。
func amountOf(t *testing.T, db *gorm.DB, id int64) money.Amount {
	t.Helper()
	var row model.CoursesActivityUserDiscount
	if err := db.Where("id = ?", id).First(&row).Error; err != nil {
		t.Fatalf("读池(%d) 失败: %v", id, err)
	}
	amt, err := money.Parse(row.DiscountAmountUsed)
	if err != nil {
		t.Fatalf("解析 used(%d) 失败: %v", id, err)
	}
	return amt
}

// TestListUsableFilterAndOrder 可用口径（discount > used）+ 活动维度 + 游标方向。
func TestListUsableFilterAndOrder(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000011"
	seedPool(t, db, 1, 1, 2, user, "10.00", "0.00")  // 可用
	seedPool(t, db, 2, 1, 2, user, "20.00", "20.00") // 用尽：不可用
	seedPool(t, db, 3, 1, 2, user, "-5.00", "0.00")  // 负赠送：不可用
	seedPool(t, db, 4, 1, 2, user, "7.50", "2.50")   // 可用

	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	ctx := context.Background()

	asc, err := repo.ListUsable(ctx, user, 0, OrderAsc)
	if err != nil {
		t.Fatalf("ListUsable(asc) 失败: %v", err)
	}
	if len(asc) != 2 || asc[0].ID != 1 || asc[1].ID != 4 {
		t.Fatalf("可用行应为 {1,4}（升序），实得 %+v", asc)
	}
	desc, err := repo.ListUsable(ctx, user, 0, OrderDesc)
	if err != nil {
		t.Fatalf("ListUsable(desc) 失败: %v", err)
	}
	if len(desc) != 2 || desc[0].ID != 4 || desc[1].ID != 1 {
		t.Fatalf("可用行应为 {4,1}（降序），实得 %+v", desc)
	}
	if _, err := repo.ListUsable(ctx, "", 0, OrderAsc); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("空 user_id 应 ErrBadParam，实得 %v", err)
	}
	if _, err := repo.ListUsable(ctx, user, 0, "desc,1;--"); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("非法方向应 ErrBadParam，实得 %v", err)
	}
	if _, err := repo.ListUsable(ctx, user, -1, OrderAsc); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("activity_id<0 应 ErrBadParam，实得 %v", err)
	}
	// activityID>0 只取该活动（seedPool 里全是活动 1）
	onlyOne, err := repo.ListUsable(ctx, user, 1, OrderAsc)
	if err != nil {
		t.Fatalf("ListUsable(activity=1) 失败: %v", err)
	}
	if len(onlyOne) != 2 {
		t.Fatalf("活动 1 可用行应为 2，实得 %d", len(onlyOne))
	}
	none, err := repo.ListUsable(ctx, user, 2, OrderAsc)
	if err != nil {
		t.Fatalf("ListUsable(activity=2) 失败: %v", err)
	}
	if len(none) != 0 {
		t.Fatalf("活动 2 应无可用行（活动维度隔离），实得 %d", len(none))
	}
}

// TestListUsableActivityIsolation A 活动的扣减不影响 B 活动的池（audit A8，dump 763216）。
//
// 若 ListUsable 漏了 `activity_id = ?`（或不传 activityID），扣 A 活动时会按 id 升序先吃光 B 活动的池
// → 用户"用 A 的赠送额度却扣了 B 的池"，且退费时退回对象错位。本用例是该缺陷的回归门禁。
func TestListUsableActivityIsolation(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000021"
	// 活动 1 的池 id=1（后建），活动 2 的池 id=2（id 更大）——故意让 id 序与活动序相反
	if err := db.Create(&model.CoursesActivityUserDiscount{
		ID: 1, ActivityID: 1, InstitutionID: 1, CampusID: 2, UserID: user,
		Income: "0.00", DiscountAmount: "10.00", DiscountAmountUsed: "0.00",
	}).Error; err != nil {
		t.Fatalf("seed 池 1 失败: %v", err)
	}
	if err := db.Create(&model.CoursesActivityUserDiscount{
		ID: 2, ActivityID: 2, InstitutionID: 1, CampusID: 2, UserID: user,
		Income: "0.00", DiscountAmount: "20.00", DiscountAmountUsed: "0.00",
	}).Error; err != nil {
		t.Fatalf("seed 池 2 失败: %v", err)
	}
	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	ctx := context.Background()

	rows, err := repo.ListUsable(ctx, user, 2, OrderAsc)
	if err != nil {
		t.Fatalf("ListUsable(activity=2) 失败: %v", err)
	}
	if len(rows) != 1 || rows[0].ID != 2 {
		t.Fatalf("活动 2 只应命中池 2，实得 %+v", rows)
	}
	if _, err := repo.IncUsed(ctx, db, 2, money.FromCents(2000)); err != nil {
		t.Fatalf("扣减活动 2 的池失败: %v", err)
	}
	if got := amountOf(t, db, 1); got != 0 {
		t.Fatalf("活动 1 的池不得被活动 2 的扣减影响，实得 %s", got.String())
	}
}

// TestSumUsableThreeParamScoping dump usable 3 参**等值且 campus 嵌套在 school 分支内**口径
// （audit A7 二次修正，dump 763181-763185 逐字）：
//
//	IF inputSchoolid>0 THEN selectCondition = " AND `schoolid`=… AND `campusid`=…;
//	ELSE selectCondition = '';   END IF;
//
// 两条推论（本用例的门禁点）：
//  1. `campusid=0` **不是"不限校区"**，而是等值匹配 `campus_id=0` 的"机构级池"；
//  2. `schoolid<=0` 时**一条作用域条件都不加**，传入的 `campusid` 被**忽略**（dump 无"只按校区筛"路径）。
//
// 池清单（用户 user，可用 = discount - used）：
//
//	pool1 inst1 campus2  可用 10    pool2 inst1 campus0  可用 15（机构级池）
//	pool3 inst1 campus3  可用 100   pool4 inst2 campus2  可用 50
//	pool5 inst1 campus2  可用 0（用尽）  pool6 他人 —— 用户过滤永远排除
func TestSumUsableThreeParamScoping(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000012"
	seedPool(t, db, 1, 1, 2, user, "10.00", "0.00")
	seedPool(t, db, 2, 1, 0, user, "20.00", "5.00")
	seedPool(t, db, 3, 1, 3, user, "100.00", "0.00")
	seedPool(t, db, 4, 2, 2, user, "50.00", "0.00")
	seedPool(t, db, 5, 1, 2, user, "5.00", "5.00")
	seedPool(t, db, 6, 1, 2, "01HOTHER00000000000001", "999.00", "0.00")

	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	ctx := context.Background()

	// ① (inst=1, campus=2) → 两个等值条件 → pool1(10) + pool5(0) = 10.00（**不含**机构级池 15）
	if got, err := repo.SumUsable(ctx, user, 1, 2); err != nil || got.Cents() != 1000 {
		t.Fatalf("SumUsable(1,2) 应为 10.00（等值口径，不含 campus=0 池），实得 %s err=%v", got.String(), err)
	}
	// ② (inst=1, campus=0) → `campus_id = 0` **等值** → 只有机构级池 pool2 = 15.00
	//    （旧期望 125.00 是照"campusID=0 即不筛"的错误实现写的，dump 无此语义）
	if got, err := repo.SumUsable(ctx, user, 1, 0); err != nil || got.Cents() != 1500 {
		t.Fatalf("SumUsable(1,0) 应为 15.00（只命中 campus_id=0 的机构级池），实得 %s err=%v", got.String(), err)
	}
	// ③ (0,0) 平台视角：selectCondition='' → 不过滤机构/校区 → 10+15+100+50 = 175.00
	if got, err := repo.SumUsable(ctx, user, 0, 0); err != nil || got.Cents() != 17500 {
		t.Fatalf("SumUsable(0,0) 平台视角应为 175.00，实得 %s err=%v", got.String(), err)
	}
	// ④ (0,2) 平台视角下 **campusID 被忽略**（campusid 只出现在 school 分支内）→ 同 ③ = 175.00
	//    （旧期望 60.00 是"单独按校区过滤"的错误实现；dump 里没有这条路径）
	if got, err := repo.SumUsable(ctx, user, 0, 2); err != nil || got.Cents() != 17500 {
		t.Fatalf("SumUsable(0,2) 应忽略 campusID → 175.00，实得 %s err=%v", got.String(), err)
	}
	// ⑤ 他机构等值：inst=2 且 campus=2 → pool4 = 50.00
	//    （越权防线已按裁定移到 Handler 角色白名单，仓储不再拦）
	if got, err := repo.SumUsable(ctx, user, 2, 2); err != nil || got.Cents() != 5000 {
		t.Fatalf("SumUsable(2,2) 应为 50.00，实得 %s err=%v", got.String(), err)
	}
	// 参数防御：负数非法（0 是合法取值，语义见上）
	if _, err := repo.SumUsable(ctx, user, -1, 2); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("institutionID<0 应 ErrBadParam，实得 %v", err)
	}
	if _, err := repo.SumUsable(ctx, user, 1, -1); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("campusID<0 应 ErrBadParam，实得 %v", err)
	}
	if _, err := repo.SumUsable(ctx, "", 1, 2); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("空 user_id 应 ErrBadParam，实得 %v", err)
	}
	// 无可用行 → 0（不是错误）
	if got, err := repo.SumUsable(ctx, "01HNOBODY00000000000001", 1, 2); err != nil || !got.IsZero() {
		t.Fatalf("无可用行应返回 0，实得 %s err=%v", got.String(), err)
	}
}

// TestIncUsedAndBatch 原子增减 + 批量单语句 CASE（正负增量都精确到分）。
func TestIncUsedAndBatch(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000013"
	seedPool(t, db, 1, 1, 2, user, "100.00", "0.00")
	seedPool(t, db, 2, 1, 2, user, "100.00", "0.00")
	seedPool(t, db, 3, 1, 2, user, "100.00", "10.00")

	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	runner := NewTxRunner(db)
	ctx := context.Background()

	// 单账户：消费 12.34
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		n, e := repo.IncUsed(ctx, tx, 1, money.FromCents(1234))
		if e != nil {
			return e
		}
		if n != 1 {
			t.Fatalf("IncUsed 应影响 1 行，实得 %d", n)
		}
		return nil
	}); err != nil {
		t.Fatalf("IncUsed 失败: %v", err)
	}
	if got := amountOf(t, db, 1); got.Cents() != 1234 {
		t.Fatalf("id=1 used 应为 12.34，实得 %s", got.String())
	}

	// 批量：id1 +1.00 / id2 +2.50 / id3 -0.01（退回冲正）
	sqls := captureSQL(t, db)
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		_, e := repo.IncUsedBatch(ctx, tx, []UsedDelta{
			{DiscountID: 1, Delta: money.FromCents(100)},
			{DiscountID: 2, Delta: money.FromCents(250)},
			{DiscountID: 3, Delta: money.FromCents(-1)},
		})
		return e
	}); err != nil {
		t.Fatalf("IncUsedBatch 失败: %v", err)
	}
	// 立即断言（后续读库也会被回调捕获，故此处先判再读）
	if len(*sqls) != 1 {
		t.Fatalf("批量增减必须 1 条语句（禁止逐行 UPDATE），实得 %d 条: %v", len(*sqls), *sqls)
	}
	if !strings.Contains((*sqls)[0], "CASE id") {
		t.Fatalf("批量增减应为 CASE WHEN 单语句，SQL=%q", (*sqls)[0])
	}
	if got := amountOf(t, db, 1); got.Cents() != 1334 {
		t.Fatalf("id=1 used 应为 13.34，实得 %s", got.String())
	}
	if got := amountOf(t, db, 2); got.Cents() != 250 {
		t.Fatalf("id=2 used 应为 2.50，实得 %s", got.String())
	}
	if got := amountOf(t, db, 3); got.Cents() != 999 {
		t.Fatalf("id=3 used 应为 9.99（10.00-0.01），实得 %s", got.String())
	}
}

// TestIncUsedBatchEdgeCases 空集合/零增量/非法 id 不发 SQL；同 id 重复出现以后者为准。
func TestIncUsedBatchEdgeCases(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000014"
	seedPool(t, db, 1, 1, 2, user, "100.00", "0.00")
	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	runner := NewTxRunner(db)
	ctx := context.Background()

	sqls := captureSQL(t, db)
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		n, e := repo.IncUsedBatch(ctx, tx, nil)
		if e != nil {
			return e
		}
		if n != 0 {
			t.Fatalf("空集合应 0 行，实得 %d", n)
		}
		_, e = repo.IncUsedBatch(ctx, tx, []UsedDelta{{DiscountID: 0, Delta: money.FromCents(1)}, {DiscountID: 1, Delta: 0}})
		return e
	}); err != nil {
		t.Fatalf("IncUsedBatch 边界用例失败: %v", err)
	}
	if len(*sqls) != 0 {
		t.Fatalf("无有效条目不应发 SQL，实得 %v", *sqls)
	}

	// 同 id 两次：后者覆盖前者
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		_, e := repo.IncUsedBatch(ctx, tx, []UsedDelta{
			{DiscountID: 1, Delta: money.FromCents(500)},
			{DiscountID: 1, Delta: money.FromCents(700)},
		})
		return e
	}); err != nil {
		t.Fatalf("IncUsedBatch(重复 id) 失败: %v", err)
	}
	if got := amountOf(t, db, 1); got.Cents() != 700 {
		t.Fatalf("重复 id 应以后者为准（7.00），实得 %s", got.String())
	}

	// tx 缺失 → ErrInternal
	if _, err := repo.IncUsed(nil, nil, 1, money.FromCents(1)); !errors.Is(err, infraerrors.ErrInternal) {
		t.Fatalf("tx 为 nil 应 ErrInternal，实得 %v", err)
	}
	if _, err := repo.IncUsedBatch(ctx, nil, []UsedDelta{{DiscountID: 1, Delta: 1}}); !errors.Is(err, infraerrors.ErrInternal) {
		t.Fatalf("tx 为 nil 应 ErrInternal，实得 %v", err)
	}
	if _, err := repo.IncUsed(ctx, repo.DB, 0, money.FromCents(1)); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("id<=0 应 ErrBadParam，实得 %v", err)
	}
}

// TestInsertDiscountAndUsedLog 两条流水写入（参数校验 + 落库形态）。
func TestInsertDiscountAndUsedLog(t *testing.T) {
	db := newActivityRepoDB(t)
	user := "01HUSER000000000000000015"
	seedPool(t, db, 1, 1, 2, user, "100.00", "0.00")
	repo := NewActivityDiscountRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	runner := NewTxRunner(db)
	ctx := context.Background()
	stuCourse := int64(901)

	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		return repo.InsertDiscountLog(ctx, tx, &model.CoursesActivityUserDiscountLog{
			ActivityUserDiscountID: 1,
			CoursesStudentID:       &stuCourse,
			DiscountAmountUsed:     "-10.00",
			CreateTime:             time.Now(),
		})
	}); err != nil {
		t.Fatalf("InsertDiscountLog 失败: %v", err)
	}
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		return repo.InsertUsedLog(ctx, tx, &model.CoursesActivityUsedLog{
			ActivityID:        1,
			UserID:            user,
			OrderNo:           ptrString("901"),
			ActivityMoneyUsed: "-10.00",
			CreateTime:        time.Now(),
		})
	}); err != nil {
		t.Fatalf("InsertUsedLog 失败: %v", err)
	}

	var dlogCount, ulogCount int64
	if err := db.Model(&model.CoursesActivityUserDiscountLog{}).Count(&dlogCount).Error; err != nil {
		t.Fatalf("count discount log 失败: %v", err)
	}
	if err := db.Model(&model.CoursesActivityUsedLog{}).Count(&ulogCount).Error; err != nil {
		t.Fatalf("count used log 失败: %v", err)
	}
	if dlogCount != 1 || ulogCount != 1 {
		t.Fatalf("两条流水应各 1 行，实得 discount=%d used=%d", dlogCount, ulogCount)
	}

	// 参数/事务防御
	if err := repo.InsertDiscountLog(ctx, nil, &model.CoursesActivityUserDiscountLog{ActivityUserDiscountID: 1}); !errors.Is(err, infraerrors.ErrInternal) {
		t.Fatalf("tx nil 应 ErrInternal，实得 %v", err)
	}
	if err := repo.InsertDiscountLog(ctx, repo.DB, &model.CoursesActivityUserDiscountLog{ActivityUserDiscountID: 0}); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("缺 discount id 应 ErrBadParam，实得 %v", err)
	}
	if err := repo.InsertUsedLog(ctx, repo.DB, &model.CoursesActivityUsedLog{ActivityID: 0, UserID: user}); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("缺 activity_id 应 ErrBadParam，实得 %v", err)
	}
	if err := repo.InsertUsedLog(ctx, repo.DB, nil); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("nil 行应 ErrBadParam，实得 %v", err)
	}
}

// ptrString 字符串指针构造（测试用）。
func ptrString(s string) *string { return &s }