// 课酬试算 + 维护型端点单测（端点 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.Get(PathPayrollPlans, h.ListPayrollPlans)
	app.Post(PathPayrollPlans, h.CreatePayrollPlan)
	app.Put(PathPayrollPlanDetail, h.UpdatePayrollPlan)
	app.Post(PathPayrollQuote, h.QuotePayroll)
	app.Post(PathMaintenanceCoursesMaxPeople, h.BackfillCoursesMaxPeople)
	app.Post(PathMaintenanceCoursesCampus, h.BackfillCoursesCampus)
	app.Post(PathMaintenanceActivitySync, h.SyncActivityData)
	return app
}

// ---------------------------------------------------------------- 端点 58：课酬方案

// TestPayrollPlanCreateAndList 端点 58：两级形状（方案 + details）、字段名不与方案撞车、列表回读。
//
// 断言重点（都是 D17 裁决里"命名必须分开"的具体后果）：
//
//	`schemeName` ≠ 明细 `displayName`：两者在库里都叫 `name`，若实现里同名字段，第二个会覆盖第一个；
//	`actived`（方案级）≠ `detailActived`（明细级）：两级启用状态必须能看到差异；
//	教龄是**区间两字段** `teacherExpMin/teacherExpMax`，不是单值。
func TestPayrollPlanCreateAndList(t *testing.T) {
	db := newCourseTestDB(t)
	app := newPayrollTestApp(t, db)
	body := map[string]any{
		"schemeName": "2026 集体班方案",
		"campusId":   10,
		"effectDate": "2026-01-01",
		"actived":    true,
		"details": []map[string]any{{
			"classType": 1000, "gradeId": -1, "subjectId": -1,
			"teacherExpMin": "1.000", "teacherExpMax": "5.000",
			"percentage": "85.0", "min": "0.00", "max": "300.00", "reward": "20.00",
			"displayName": "集体班-无证档", "detailActived": true,
		}, {
			"classType": 1000, "gradeId": -1, "subjectId": -1,
			"teacherExpMin": "0.000", "teacherExpMax": "0.999",
			"percentage": "60.0", "min": "0.00", "max": "0.00", "reward": "0.00",
			"displayName": "集体班-新人档", "detailActived": false,
		}},
	}
	code, msg, data := doJSON(t, app, fiber.MethodPost, PathPayrollPlans, body, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("新建课酬方案 = %d（%s），期望 200", code, msg)
	}
	payload := jsonMap(t, data)
	if name, _ := payload["schemeName"].(string); name != "2026 集体班方案" {
		t.Fatalf("schemeName = %v，期望 2026 集体班方案（与明细 displayName 分开）", payload["schemeName"])
	}
	if got, _ := payload["campusId"].(float64); got != 10 {
		t.Fatalf("campusId = %v，期望 10", payload["campusId"])
	}
	planID, _ := payload["id"].(float64)
	if planID <= 0 {
		t.Fatalf("方案 id = %v，期望 >0", payload["id"])
	}
	details, _ := payload["details"].([]any)
	if len(details) != 2 {
		t.Fatalf("details 条数 = %d，期望 2", len(details))
	}
	first, _ := details[0].(map[string]any)
	if name, _ := first["displayName"].(string); name != "集体班-无证档" {
		t.Fatalf("明细 displayName = %v，期望 集体班-无证档（被 schemeName 覆盖就是同名字段）", first["displayName"])
	}
	// ⚠ 这三条从"比数值"升级为"比字节"（出口定点化之后才可能这么断言）。
	// 定点化前 SQLite 的 numeric 亲和性把 "1.000" 读回 "1"、"85.0" 读回 "85"，
	// 只能写 mustDecimal 比数值 —— 而"位数"恰好是量纲指纹（百分比 1 位 / 教龄 3 位 / 金额 2 位），
	// 比数值等于把这条防线让出去。现在出口恒按列 scale 定点化，两种方言字节一致，才钉得住。
	if got, _ := first["teacherExpMin"].(string); got != "1.000" {
		t.Fatalf("teacherExpMin = %v，期望 \"1.000\"（区间下界单独下发，且定点化到 decimal(10,3)）",
			first["teacherExpMin"])
	}
	if got, _ := first["teacherExpMax"].(string); got != "5.000" {
		t.Fatalf("teacherExpMax = %v，期望 \"5.000\"（区间上界必须单独下发，否则前端改档会写坏）",
			first["teacherExpMax"])
	}
	if got, _ := first["percentage"].(string); got != "85.0" {
		t.Fatalf("percentage = %v，期望 \"85.0\"（**百分数且 1 位小数**）；"+
			"\"0.85\" 说明被当比率、\"8500\" 说明被 ×100、\"85.00\" 说明被当金额格式化", first["percentage"])
	}
	if got, _ := first["min"].(string); got != "0.00" {
		t.Fatalf("min = %v，期望 \"0.00\"（金额 2 位小数；\"0\" 说明金额没走定点出口）", first["min"])
	}
	// `teacherId` 未填 ⇒ 通用档 ⇒ 必须是 JSON `null`，**不能是 ""**。
	// 空串无法区分"不限定老师"（正常）与"限定了老师但 ID 为空"（脏数据）。
	if v, ok := first["teacherId"]; !ok {
		t.Fatalf("响应里没有 teacherId 字段（契约要求存在且可空）")
	} else if v != nil {
		t.Fatalf("teacherId = %#v，期望 null（未填老师 = 通用档）；\"\" 会让前端把脏数据当通用档", v)
	}
	second, _ := details[1].(map[string]any)
	if v, _ := second["detailActived"].(bool); v {
		t.Fatalf("第二条 detailActived = true，期望 false（明细级启用与方案级 actived 必须能不同）")
	}

	// 列表：两级形状回读（GET 必须把 details 一并带回，否则前端要 N+1）
	code, msg, data = doJSON(t, app, fiber.MethodGet,
		PathPayrollPlans+"?institutionId=1&pageSize=10", nil, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("方案列表 = %d（%s），期望 200", code, msg)
	}
	items := pageList(t, data)
	if len(items) != 1 {
		t.Fatalf("方案条数 = %d，期望 1", len(items))
	}
	row, _ := items[0].(map[string]any)
	if got, _ := row["id"].(float64); got != planID {
		t.Fatalf("列表首行 id = %v，期望 %v", row["id"], planID)
	}
	listDetails, _ := row["details"].([]any)
	if len(listDetails) != 2 {
		t.Fatalf("列表行的 details = %d 条，期望 2（列表必须带明细，否则前端要逐行再查）", len(listDetails))
	}
}

// TestPayrollPlanTeacherIDNullVersusULID 端点 58：`teacherId` 为 NULL 时下发 `null`，**不是 `""`**。
//
// 变红条件（每条都对应一个真实可犯的错）：
//
//	字段声明成 `string` 且用 `strValue()` 兜底   → NULL 变成 ""，本条断言红；
//	写入侧把空 teacherId 写成 `""` 而不是 NULL   → 库里 teacher_id = ''，本条"库值必须 IS NULL"红；
//	`optionalTrimmedPtr` 不 trim                    → 历史脏值 " " 被当成有值下发，本条红（见下用例）。
//
// 为什么值得单独立一条用例：`teacherId` 是"通用档"与"老师专属档"的唯一区分依据。
// 若 NULL 被折叠成 ""，前端 `if (teacherId)` 两支都走"通用档"，**专属档的规则会被当成通用档生效**——
// 数值全对、类型全对，只有课酬算错，且错得很隐蔽（多算/少算都合法）。
func TestPayrollPlanTeacherIDNullVersusULID(t *testing.T) {
	db := newCourseTestDB(t)
	app := newPayrollTestApp(t, db)
	const teacherULID = "01HTEACHER0000000000000042"
	body := map[string]any{
		"schemeName": "专属档 vs 通用档", "campusId": 10, "actived": true,
		"details": []map[string]any{
			// 第 1 条：老师专属档
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "90.0",
				"teacherId": teacherULID, "displayName": "专属档"},
			// 第 2 条：通用档（不传 teacherId）
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "70.0",
				"displayName": "通用档"},
			// 第 3 条：传空串（等价于不传，**不许落成 ""**）
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "60.0",
				"teacherId": "", "displayName": "空串档"},
		},
	}
	code, msg, data := doJSON(t, app, fiber.MethodPost, PathPayrollPlans, body, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("新建课酬方案 = %d（%s），期望 200", code, msg)
	}
	planID, _ := jsonMap(t, data)["id"].(float64)
	assertTeacherID := func(when string, details []any) {
		t.Helper()
		if len(details) != 3 {
			t.Fatalf("%s：details = %d 条，期望 3", when, len(details))
		}
		d0, _ := details[0].(map[string]any)
		if got, _ := d0["teacherId"].(string); got != teacherULID {
			t.Fatalf("%s：专属档 teacherId = %#v，期望 %q（有值必须原样下发）", when, d0["teacherId"], teacherULID)
		}
		for i := 1; i < 3; i++ {
			di, _ := details[i].(map[string]any)
			v, ok := di["teacherId"]
			if !ok {
				t.Fatalf("%s：第 %d 条没有 teacherId 字段（可空字段也必须存在）", when, i+1)
			}
			if v != nil {
				t.Fatalf("%s：第 %d 条 teacherId = %#v，期望 null（不填/空串都是通用档）；"+
					"空串会让前端把「写了老师但 ID 是空」的脏数据也当通用档", when, i+1, v)
			}
		}
	}
	assertTeacherID("POST 响应", jsonMap(t, data)["details"].([]any))

	// 列表回读：同一口径（GET 与 POST 不能两套规格）
	code, msg, data = doJSON(t, app, fiber.MethodGet,
		PathPayrollPlans+"?institutionId=1&pageSize=10", nil, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("方案列表 = %d（%s），期望 200", code, msg)
	}
	items := pageList(t, data)
	if len(items) != 1 {
		t.Fatalf("方案条数 = %d，期望 1", len(items))
	}
	row, _ := items[0].(map[string]any)
	assertTeacherID("GET 列表", row["details"].([]any))

	// 库值：空 teacherId 必须落 NULL（不是 ""）——否则"通用档"在 SQL 里会变成
	// `teacher_id = ''`，而 SQL 的三值逻辑下 `teacher_id = ''` 永远匹配不到"通用档"这句查询。
	var rows []model.CoursePaymentDetail
	if err := db.Where("course_payment_id = ?", int64(planID)).Order("id ASC").Find(&rows).Error; err != nil {
		t.Fatalf("回读明细失败: %v", err)
	}
	if len(rows) != 3 {
		t.Fatalf("库中明细 %d 条，期望 3", len(rows))
	}
	if rows[0].TeacherID == nil || *rows[0].TeacherID != teacherULID {
		t.Fatalf("库中第 1 条 teacher_id = %v，期望 %q", rows[0].TeacherID, teacherULID)
	}
	for i := 1; i < 3; i++ {
		if rows[i].TeacherID != nil {
			t.Fatalf("库中第 %d 条 teacher_id = %q，期望 NULL（空串会被存成 ''，通用档就永远匹配不到）",
				i+1, *rows[i].TeacherID)
		}
	}
}


//
// 变红条件：
//   - 把 `:id` 当明细 id（按明细删改）→ 方案字段改不动 / 明细条数不对；
//   - "整体替换"写成"追加" → 明细变 3 条（旧 2 + 新 1）。
func TestPayrollPlanUpdateReplacesDetails(t *testing.T) {
	db := newCourseTestDB(t)
	app := newPayrollTestApp(t, db)
	create := map[string]any{
		"schemeName": "替换测试方案", "campusId": 10, "actived": true,
		"details": []map[string]any{
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "80.0", "displayName": "旧档A"},
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "70.0", "displayName": "旧档B"},
		},
	}
	code, msg, data := doJSON(t, app, fiber.MethodPost, PathPayrollPlans, create, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("建方案 = %d（%s），期望 200", code, msg)
	}
	planID, _ := jsonMap(t, data)["id"].(float64)

	update := map[string]any{
		"schemeName": "替换后方案名",
		"details": []map[string]any{
			{"classType": 1000, "gradeId": -1, "subjectId": -1, "percentage": "90.0", "displayName": "新档"},
		},
	}
	code, msg, data = doJSON(t, app, fiber.MethodPut,
		"/admin/payroll/plans/"+itoa(int64(planID)), update, "X-Test-Token", "t")
	if code != 200 {
		t.Fatalf("更新方案 = %d（%s），期望 200", code, msg)
	}
	payload := jsonMap(t, data)
	if name, _ := payload["schemeName"].(string); name != "替换后方案名" {
		t.Fatalf("schemeName = %v，期望 替换后方案名", payload["schemeName"])
	}
	details, _ := payload["details"].([]any)
	if len(details) != 1 {
		t.Fatalf("替换后明细 = %d 条，期望 1（整体替换；3 条说明写成了追加）", len(details))
	}
	only, _ := details[0].(map[string]any)
	if name, _ := only["displayName"].(string); name != "新档" {
		t.Fatalf("明细 displayName = %v，期望 新档", only["displayName"])
	}
	// 库里确认旧明细已删（不是只改了响应）
	var count int64
	db.Model(&model.CoursePaymentDetail{}).Where("course_payment_id = ?", int64(planID)).Count(&count)
	if count != 1 {
		t.Fatalf("库中明细条数 = %d，期望 1（旧 2 条必须被删掉）", count)
	}
}

// TestPayrollPlanValidation 端点 58 的写入校验：比例越界 / 教龄区间倒挂 → 2002。
//
// 两条都是"不报错但规则永不命中/课酬少 100 倍"的静默错法，必须在写入时拒。
func TestPayrollPlanValidation(t *testing.T) {
	db := newCourseTestDB(t)
	app := newPayrollTestApp(t, db)
	base := func(detail map[string]any) map[string]any {
		return map[string]any{"schemeName": "校验方案", "campusId": 10, "details": []map[string]any{detail}}
	}
	cases := []struct {
		name   string
		detail map[string]any
	}{
		{"比例 > 100（把 0.85 当比率传成 85 反了）", map[string]any{"classType": 1000, "percentage": "850.0"}},
		{"比例 2 位小数（列是 decimal(5,1)）", map[string]any{"classType": 1000, "percentage": "85.25"}},
		{"教龄区间倒挂（规则永不命中）", map[string]any{"classType": 1000, "percentage": "85.0",
			"teacherExpMin": "5.000", "teacherExpMax": "1.000"}},
	}
	for _, tc := range cases {
		code, msg, _ := doJSON(t, app, fiber.MethodPost, PathPayrollPlans, base(tc.detail), "X-Test-Token", "t")
		if code != infraerrors.ErrBadParam.Code {
			t.Errorf("%s = %d（%s），期望 2002", tc.name, code, msg)
		}
	}
	// 对照：合法明细必须 200
	ok := base(map[string]any{"classType": 1000, "percentage": "85.0",
		"teacherExpMin": "1.000", "teacherExpMax": "2.000"})
	if code, msg, _ := doJSON(t, app, fiber.MethodPost, PathPayrollPlans, ok, "X-Test-Token", "t"); code != 200 {
		t.Fatalf("合法明细 = %d（%s），期望 200", code, msg)
	}
}

// ---------------------------------------------------------------- 端点 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 格式化）。
	// 出口已定点化到 1 位小数 ⇒ 这里可以直接比字节，**并且这条断言正是"量纲污染"的探测器**：
	// 数值 85 在 "85.0"（百分比）/ "85.00"（金额）/ "0.85"（比率）三种写法下"数值断言"各有不同，
	// 但 "85.00" 与 "85.0" 的差别只有位数 —— 只有字节断言抓得住"比例被按金额格式化"。
	pctText, _ := payload["percentage"].(string)
	if pctText != "85.0" {
		t.Fatalf("percentage = %q，期望 \"85.0\"（百分数 + 1 位小数）；"+
			"\"0.85\" 说明被当比率、\"8500\" 说明被 ×100、\"85.00\" 说明量纲被当成了金额",
			pctText)
	}
	// 数值断言保留一条：即使字节被人为改坏，也要能看出"是不是 85 这个数"
	if pctValue, pctErr := strconv.ParseFloat(strings.TrimSpace(pctText), 64); pctErr != nil || pctValue != 85 {
		t.Fatalf("percentage = %q（解析 %v，错 %v），数值必须是 85", pctText, pctValue, pctErr)
	}
	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.ErrBadFormat.Code {
		t.Fatalf("非法 mode = %d（%s），期望 2002", code, msg)
	}
	// 缺失 mode → **2001**（未提供必要参数）；传了非法值 → **2002**（枚举越界，与端点 25 一致）
	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 }

// mustDecimal 把 JSON 里的数值字段（字符串或数字）转 float（不比较字面量填充位数）。
//
// 为什么需要：SQLite 没有 DECIMAL 类型，`"1.000"` 读回来是 `"1"`；生产 MySQL 是 `"1.000"`。
// 断言要跨方言成立，只能比数值。
func mustDecimal(t *testing.T, v any) float64 {
	t.Helper()
	switch value := v.(type) {
	case string:
		parsed, err := strconv.ParseFloat(strings.TrimSpace(value), 64)
		if err != nil {
			t.Fatalf("%v 不是合法数值: %v", v, err)
		}
		return parsed
	case float64:
		return value
	default:
		t.Fatalf("%v 既不是字符串也不是数字（%T）", v, v)
		return 0
	}
}