DEV-MERGE-LEGACY-BACKEND-2026/internal/academic/handler/payroll_handler_test.go

// 课酬试算 + 维护型端点单测（端点 59、61、62、63）——AC-13d 第一批。
//
// 断言纪律同前几批：只断 body 契约，**每个端点至少一条"写错会变红"的断言**，尽量落在库上。
//
// 覆盖：
//
//	59 试算     命中规则 → 9 字段（percentage 是**百分数字符串**不是金额）；无方案 → 3112；
//	            跨机构 → 1004；日期格式非法 → 2002
//	61 修 max_people  回填后库值 = 分类值；可重跑（第二次 affected=0）；分类也 0 的行**不写**
//	62 修 campus_id   单校区课程回填；**多校区课程保持 0**；无规则课程不动
//	63 活动同步     mode=used-log 重建 used_log（DELETE+INSERT）；mode=signed 只回写 status>0；
//	            非法 mode → 2001；非超管 → 1004
package handler

import (
	"strconv"
	"strings"
	"testing"
	"time"

	"github.com/gofiber/fiber/v2"
	"gorm.io/gorm"

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

// newPayrollTestApp 挂 59/61/62/63 四条路由（**不做角色白名单**：白名单由 e2e 验，
// 但 61~63 的"仅超管"还有 Service 层 `assertSuperAdmin` 第二道，本文件**要验第二道**）。
//
// 作用域：`X-Test-Scope: super` 超管；`academic` 教务（非超管，用于验 1004）。
func newPayrollTestApp(t *testing.T, db *gorm.DB) *fiber.App {
	t.Helper()
	h, err := New(Config{DB: db})
	if err != nil {
		t.Fatalf("handler.New 失败: %v", err)
	}
	app := fiber.New(fiber.Config{DisableStartupMessage: true})
	app.Use(func(c *fiber.Ctx) error {
		switch c.Get("X-Test-Scope") {
		case "none":
			// 无作用域 → 1001
		case "academic":
			appscope.Set(c, &appscope.Scope{
				InstitutionID: 1, CampusID: 10, UserID: "01HACADEMIC0000000000001", Role: RoleAcademic,
			})
		default:
			appscope.Set(c, testSuperScope())
		}
		return c.Next()
	})
	app.Post(PathPayrollQuote, h.QuotePayroll)
	app.Post(PathMaintenanceCoursesMaxPeople, h.BackfillCoursesMaxPeople)
	app.Post(PathMaintenanceCoursesCampus, h.BackfillCoursesCampus)
	app.Post(PathMaintenanceActivitySync, h.SyncActivityData)
	return app
}

// ---------------------------------------------------------------- 端点 59：课酬试算

// TestPayrollQuoteReturnsRuleTraceableFields 端点 59 必须回 9 个**可溯源**字段（不能裁掉 4 个溯源字段）。
//
// 变红条件：
//   - 漏 `schemeScope`/`ruleTier` → 前端无法定位"命中哪一档"，且契约 §4.6 明确不得裁掉；
//   - 把 `percentage` 当金额下发（"85.0" → "85.00"）→ 量纲污染断言红。
func TestPayrollQuoteReturnsRuleTraceableFields(t *testing.T) {
	db := newCourseTestDB(t)
	classify := seedPayrollClassify(t, db, 1000)
	scheme, detail := seedPayrollScheme(t, db, classify.ClassType, "85.0", "0.00", "0.00", "0.00")
	app := newPayrollTestApp(t, db)

	code, msg, data := doJSON(t, app, fiber.MethodPost, PathPayrollQuote, map[string]any{
		"teacherId":  courseTestTeacher,
		"schoolId":   1,
		"campusId":   10,
		"classifyId": classify.ID,
		"teacherExp": 3.5,
		"date":       "2026-11-09",
	}, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("课酬试算 = %d（%s），期望 200", code, msg)
	}
	payload := jsonMap(t, data)

	if got, _ := payload["detailId"].(float64); got != float64(detail.ID) {
		t.Fatalf("detailId = %v，期望 %d", payload["detailId"], detail.ID)
	}
	if got, _ := payload["schemeId"].(float64); got != float64(scheme.ID) {
		t.Fatalf("schemeId = %v，期望 %d", payload["schemeId"], scheme.ID)
	}
	if got, _ := payload["schemeCampusId"].(float64); got != 10 {
		t.Fatalf("schemeCampusId = %v，期望 10（校区级方案）", payload["schemeCampusId"])
	}
	if got, _ := payload["schemeScope"].(string); got != "campus" {
		t.Fatalf("schemeScope = %v，期望 campus（命中校区级方案）", payload["schemeScope"])
	}
	if got, _ := payload["ruleTier"].(string); got == "" {
		t.Fatalf("ruleTier 为空：溯源字段不得裁掉（契约 §4.6 v0.1.29）")
	}
	// 量纲红线：percentage 是**百分数字符串**，不是金额（不能被 money 格式化）。
	// ⚠ 不比较字面量：SQLite 无 DECIMAL 类型，"85.0" 读回来是 "85"；生产 MySQL 是 "85.0"。
	// 断言"数值等于 85 且**不是 0.85 / 8500**"——这才是"被当 0~1 比率或被 ×100"的真实失败条件。
	pctText, _ := payload["percentage"].(string)
	pctValue, pctErr := strconv.ParseFloat(strings.TrimSpace(pctText), 64)
	if pctErr != nil {
		t.Fatalf("percentage = %q 不是合法百分数字符串: %v", pctText, pctErr)
	}
	if pctValue != 85 {
		t.Fatalf("percentage = %q（数值 %v），期望 85（百分数）；0.85 说明被当比率、8500 说明被 ×100",
			pctText, pctValue)
	}
	if got, _ := payload["min"].(string); got != "0.00" {
		t.Fatalf("min = %v，期望 \"0.00\"", payload["min"])
	}
}

// TestPayrollQuoteErrors 端点 59 的错误分流：无方案 → 3112；跨机构 → 1004；日期非法 → 2002。
func TestPayrollQuoteErrors(t *testing.T) {
	db := newCourseTestDB(t)
	classify := seedPayrollClassify(t, db, 1000) // 只建分类，**不建方案**
	app := newPayrollTestApp(t, db)
	base := map[string]any{
		"teacherId": courseTestTeacher, "schoolId": 1, "campusId": 10,
		"classifyId": classify.ID, "teacherExp": 1, "date": "2026-11-09",
	}

	// 无方案 → 3112（结课侧会把它降级为 0 课酬，但试算入口必须暴露）
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathPayrollQuote, base, "X-Test-Token", "t"); code != apperr.CodePayrollPlanMissing {
		t.Fatalf("无方案试算 = %d（%s），期望 3112", code, msg)
	}
	// 跨机构（作用域机构 1，传入 2）→ 1004。
	// **必须用非超管作用域**：超管按设计可查任意机构（`assertInstitution` 放行），
	// 用超管测 1004 会得到 3112（无方案），把"越权没拦"误判成"业务错"。
	cross := map[string]any{
		"teacherId": courseTestTeacher, "schoolId": 2, "campusId": 10,
		"classifyId": classify.ID, "teacherExp": 1, "date": "2026-11-09",
	}
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathPayrollQuote, cross,
		"X-Test-Token", "t", "X-Test-Scope", "academic"); code != infraerrors.ErrUnscoped.Code {
		t.Fatalf("跨机构试算 = %d（%s），期望 1004", code, msg)
	}
	// 日期格式非法 → 2002
	bad := map[string]any{
		"teacherId": courseTestTeacher, "schoolId": 1, "campusId": 10,
		"classifyId": classify.ID, "teacherExp": 1, "date": "2026/11/09",
	}
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathPayrollQuote, bad, "X-Test-Token", "t"); code != infraerrors.ErrBadFormat.Code {
		t.Fatalf("非法日期 = %d（%s），期望 2002", code, msg)
	}
}

// seedPayrollClassify 建课程分类（class_type 决定课酬规则维度）。
func seedPayrollClassify(t *testing.T, db *gorm.DB, classType int32) *model.CoursesClassify {
	t.Helper()
	row := &model.CoursesClassify{
		InstitutionID: 1, CampusID: 10, ClassType: classType, GradeID: 0, SubjectID: 0,
		Name: "课酬测试班", UnitPrice: "100.00", MinPeople: 1, MaxPeople: 10,
	}
	if err := db.Create(row).Error; err != nil {
		t.Fatalf("建分类失败: %v", err)
	}
	return row
}

// seedPayrollScheme 建一套"校区级方案 + 无证通用规则"（命中确定，便于逐字段断言）。
func seedPayrollScheme(t *testing.T, db *gorm.DB, classType int32, percentage, minPayment, maxPayment, reward string) (*model.CoursePayment, *model.CoursePaymentDetail) {
	t.Helper()
	effect := time.Now().AddDate(0, 0, -30)
	scheme := &model.CoursePayment{
		InstitutionID: 1, CampusID: 10, Actived: true, EffectDate: &effect,
	}
	if err := db.Create(scheme).Error; err != nil {
		t.Fatalf("建课酬方案失败: %v", err)
	}
	detail := &model.CoursePaymentDetail{
		CoursePaymentID: scheme.ID, GradeID: -1, SubjectID: -1, ClassType: classType, ClassifyID: 0,
		Percentage: percentage, MinPayment: minPayment, MaxPayment: maxPayment, Reward: reward,
		TeacherCert: false, TeacherExpMin: "0.000", TeacherExpMax: "100.000", Actived: true,
	}
	if err := db.Create(detail).Error; err != nil {
		t.Fatalf("建课酬规则失败: %v", err)
	}
	return scheme, detail
}

// ---------------------------------------------------------------- 端点 61：修 max_people

// TestBackfillMaxPeopleIdempotent 端点 61：按分类回填 + 分类未配置的行**不写 0** + 可重跑。
//
// 变红条件：
//   - 分类未配置(max_people=0)的课程被写成 0 → 该断言行"必须保持 NULL/0 且计入 skipped"红；
//   - 第二次执行 affected≠0 → 幂等红。
func TestBackfillMaxPeopleIdempotent(t *testing.T) {
	db := newCourseTestDB(t)
	// 分类 A：max_people=25；分类 B：max_people=0（未配置）
	classifyA := seedPayrollClassify(t, db, 1000)
	classifyA.MaxPeople = 25
	if err := db.Save(classifyA).Error; err != nil {
		t.Fatalf("更新分类失败: %v", err)
	}
	classifyB := seedPayrollClassify(t, db, 1001) // MaxPeople 默认 1000 → 显式压成 0
	if err := db.Model(&model.CoursesClassify{}).Where("id = ?", classifyB.ID).
		UpdateColumn("max_people", 0).Error; err != nil {
		t.Fatalf("压零分类 B 失败: %v", err)
	}
	courseA := seedCourse(t, db, "待回填A", 10)
	courseA.ClassifyID = classifyA.ID
	db.Save(courseA)
	courseB := seedCourse(t, db, "分类未配置B", 10)
	courseB.ClassifyID = classifyB.ID
	db.Save(courseB)

	app := newPayrollTestApp(t, db)
	code, msg, data := doJSON(t, app, fiber.MethodPost, PathMaintenanceCoursesMaxPeople, nil, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("修 max_people = %d（%s），期望 200", code, msg)
	}
	if got, _ := jsonMap(t, data)["affected"].(float64); got != 1 {
		t.Fatalf("affected = %v，期望 1（只有 A 被回填；分类为 0 的行不得写 0）", jsonMap(t, data)["affected"])
	}
	var gotA, gotB int32
	db.Raw("SELECT max_people FROM t_courses WHERE id = ?", courseA.ID).Scan(&gotA)
	db.Raw("SELECT max_people FROM t_courses WHERE id = ?", courseB.ID).Scan(&gotB)
	if gotA != 25 {
		t.Fatalf("课程 A max_people = %d，期望 25（继承分类）", gotA)
	}
	if gotB != 0 {
		t.Fatalf("课程 B max_people = %d，期望 0（分类未配置，不得写别的值）", gotB)
	}
	// 可重跑：第二次 affected = 0
	code, msg, data = doJSON(t, app, fiber.MethodPost, PathMaintenanceCoursesMaxPeople, nil, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("二次修 max_people = %d（%s），期望 200", code, msg)
	}
	if got, _ := jsonMap(t, data)["affected"].(float64); got != 0 {
		t.Fatalf("二次 affected = %v，期望 0（幂等）", jsonMap(t, data)["affected"])
	}
}

// ---------------------------------------------------------------- 端点 62：修 campus_id

// TestBackfillCoursesCampusSkipsMultiCampus 端点 62：**多校区课程必须保持 0**（机构级），单校区回填。
//
// 变红条件：把多校区课程也回填 → 课程被锁进某一个校区、其它校区看不到（越权/丢数据）；
//
//	无排班规则的课程被回填（0≠1）→ affected 变 2。
func TestBackfillCoursesCampusSkipsMultiCampus(t *testing.T) {
	db := newCourseTestDB(t)
	single := seedCourse(t, db, "单校区课", 0) // campus_id=0 待回填
	multi := seedCourse(t, db, "多校区课", 0)  // 两条规则、两个校区 → 保持 0
	noRule := seedCourse(t, db, "无规则课", 0) // 无规则 → 不回填
	// 单校区：1 条规则（campus 10）
	seedClassRule(t, db, single.ID, 9101, courseTestTeacher, "1", model.CoursesClassStatusOngoing, "09:00", "10:00")
	// 多校区：2 条规则，其中一条改到 campus 20
	seedClassRule(t, db, multi.ID, 9201, courseTestTeacher, "1", model.CoursesClassStatusOngoing, "09:00", "10:00")
	otherCampus := seedClassRule(t, db, multi.ID, 9201, courseTestTeacher, "3", model.CoursesClassStatusOngoing, "11:00", "12:00")
	otherCampus.CampusID = 20
	if err := db.Save(otherCampus).Error; err != nil {
		t.Fatalf("改规则校区失败: %v", err)
	}
	app := newPayrollTestApp(t, db)
	code, msg, data := doJSON(t, app, fiber.MethodPost, PathMaintenanceCoursesCampus, nil, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("修 campus_id = %d（%s），期望 200", code, msg)
	}
	if got, _ := jsonMap(t, data)["affected"].(float64); got != 1 {
		t.Fatalf("affected = %v，期望 1（只有单校区课程被回填）", jsonMap(t, data)["affected"])
	}
	var gotSingle, gotMulti, gotNoRule int64
	db.Raw("SELECT campus_id FROM t_courses WHERE id = ?", single.ID).Scan(&gotSingle)
	db.Raw("SELECT campus_id FROM t_courses WHERE id = ?", multi.ID).Scan(&gotMulti)
	db.Raw("SELECT campus_id FROM t_courses WHERE id = ?", noRule.ID).Scan(&gotNoRule)
	if gotSingle != 10 {
		t.Fatalf("单校区课程 campus_id = %d，期望 10", gotSingle)
	}
	if gotMulti != 0 {
		t.Fatalf("多校区课程 campus_id = %d，期望 0（机构级课程不得被锁进单校区）", gotMulti)
	}
	if gotNoRule != 0 {
		t.Fatalf("无规则课程 campus_id = %d，期望 0（计数 0 ≠ 1，不回填）", gotNoRule)
	}
}

// ---------------------------------------------------------------- 端点 63：活动数据同步

// TestActivitySyncModes 端点 63：两种 mode 各走各的 SP；非法 mode → 2001；非超管 → 1004。
//
// 变红条件：
//   - 非法 mode 落进某个分支（会被当成 used-log 而清表！）→ 2001 断言红；
//   - mode=signed 把已取消报名(status=0)的行走回写 → 数据断言红。
func TestActivitySyncModes(t *testing.T) {
	db := newCourseTestDB(t)
	// ---- used-log 模式：造 1 条 discount_log，重建后 used_log 应有 1 行
	activity := &model.CoursesActivity{
		InstitutionID: 1, CampusID: 10, Type: 2, Title: ptr("充值赠送活动"), Status: 1,
		Money: "100.00",
	}
	if err := db.Create(activity).Error; err != nil {
		t.Fatalf("建活动失败: %v", err)
	}
	const studentID = courseTestStudent
	// SP30 的数据形状：**流水只指向池行**（`t_courses_activity_user_discount_log` 没有
	// activity_id/user_id 列）⇒ 必须"池行 + 流水行"两条，重建才能 JOIN 出 activity/user。
	pool := &model.CoursesActivityUserDiscount{
		ActivityID: activity.ID, InstitutionID: 1, CampusID: 10, UserID: studentID,
		Income: "100.00", DiscountAmount: "100.00", DiscountAmountUsed: "50.00",
	}
	if err := db.Create(pool).Error; err != nil {
		t.Fatalf("建赠送池行失败: %v", err)
	}
	logRow := &model.CoursesActivityUserDiscountLog{
		ActivityUserDiscountID: pool.ID,
		DiscountAmountUsed:     "-50.00", Memo: ptr("使用赠送"),
	}
	if err := db.Create(logRow).Error; err != nil {
		t.Fatalf("建赠送流水失败: %v", err)
	}
	app := newPayrollTestApp(t, db)

	code, msg, data := doJSON(t, app, fiber.MethodPost, PathMaintenanceActivitySync,
		map[string]any{"mode": "used-log"}, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("used-log 同步 = %d（%s），期望 200", code, msg)
	}
	if got, _ := jsonMap(t, data)["affected"].(float64); got != 1 {
		t.Fatalf("used-log affected = %v，期望 1（重建出 1 行）", jsonMap(t, data)["affected"])
	}
	var usedCount int64
	db.Model(&model.CoursesActivityUsedLog{}).Count(&usedCount)
	if usedCount != 1 {
		t.Fatalf("used_log 行数 = %d，期望 1", usedCount)
	}

	// ---- signed 模式：status=0（已取消）的行不得被历史工单"复活"
	signed := &model.CoursesActivitySigned{
		ActivityID: activity.ID, UserID: studentID, Status: 0, RechargeAmount: "0.00",
	}
	if err := db.Create(signed).Error; err != nil {
		t.Fatalf("建报名行失败: %v", err)
	}
	request := &model.UserBalanceRequest{
		BizNo: "REQ-SYNC-1", InstitutionID: 1, CampusID: 10, UserID: studentID,
		Type: 100, Money: "100.00", Approved: 1,
	}
	if err := db.Create(request).Error; err != nil {
		t.Fatalf("建充值工单失败: %v", err)
	}
	pool2 := &model.CoursesActivityUserDiscount{
		ActivityID: activity.ID, InstitutionID: 1, CampusID: 10, UserID: studentID,
		BalanceRequestID: &request.ID, Income: "100.00", DiscountAmount: "100.00",
	}
	if err := db.Create(pool2).Error; err != nil {
		t.Fatalf("建第二池行失败: %v", err)
	}
	code, msg, _ = doJSON(t, app, fiber.MethodPost, PathMaintenanceActivitySync,
		map[string]any{"mode": "signed"}, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("signed 同步 = %d（%s），期望 200", code, msg)
	}
	var signedStatus int8
	db.Raw("SELECT status FROM t_courses_activity_signed WHERE id = ?", signed.ID).Scan(&signedStatus)
	if signedStatus != 0 {
		t.Fatalf("已取消报名的 status = %d，期望仍为 0（重放不得复活已取消报名）", signedStatus)
	}

	// ---- 非法 / 缺失 mode → 2001（**绝不能落进任何分支**：落进 used-log 会清表）
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathMaintenanceActivitySync,
		map[string]any{"mode": "drop-all"}, "X-Test-Token", "t"); code != infraerrors.ErrBadParam.Code {
		t.Fatalf("非法 mode = %d（%s），期望 2001", code, msg)
	}
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathMaintenanceActivitySync,
		map[string]any{}, "X-Test-Token", "t"); code != infraerrors.ErrBadParam.Code {
		t.Fatalf("缺失 mode = %d（%s），期望 2001", code, msg)
	}
	// 非法 mode 之后 used_log 必须还在（证明没有误清表）
	db.Model(&model.CoursesActivityUsedLog{}).Count(&usedCount)
	if usedCount != 1 {
		t.Fatalf("非法 mode 后 used_log 行数 = %d，期望仍为 1（**误清表**）", usedCount)
	}
}

// TestMaintenanceRequiresSuperAdmin 61~63 的**第二道防线**：非超管即使绕过路由白名单也要 1004。
//
// 为什么必须测第二道：路由白名单和种子是**配置**，配错只会让"该拦的没拦"；
// Service 层 `assertSuperAdmin` 是代码里的硬断言，两者独立，缺一不可。
func TestMaintenanceRequiresSuperAdmin(t *testing.T) {
	db := newCourseTestDB(t)
	app := newPayrollTestApp(t, db)
	cases := []struct {
		name string
		path string
		body any
	}{
		{"61 修 max_people", PathMaintenanceCoursesMaxPeople, nil},
		{"62 修 campus", PathMaintenanceCoursesCampus, nil},
		{"63 活动同步", PathMaintenanceActivitySync, map[string]any{"mode": "used-log"}},
	}
	for _, tc := range cases {
		code, msg, _ := doJSON(t, app, fiber.MethodPost, tc.path, tc.body,
			"X-Test-Token", "t", "X-Test-Scope", "academic")
		if code != infraerrors.ErrUnscoped.Code {
			t.Errorf("%s 非超管 = %d（%s），期望 1004（Service 层 assertSuperAdmin）", tc.name, code, msg)
		}
	}
	// 对照：超管通过（61 在空库上 affected=0，不是 1004）
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathMaintenanceCoursesMaxPeople, nil,
		"X-Test-Token", "t"); code != 200 {
		t.Errorf("61 超管 = %d（%s），期望 200", code, msg)
	}
}

// ptr 返回字符串指针（测试夹具的可空列用）。
func ptr(v string) *string { return &v }