// OrderPayRepo 单测（AC-03）：三通道可见性（含 NULL 行裁定 §2.5）/ CAS 幂等 / 分页 / 幂等单号。
//
// 测试栈：glebarez/sqlite 文件库（**只迁 t_order_pay 单表**——sqlite 索引名库级全局，
// `uk_biz_no` 与工单/支付日志表重名，混迁会撞名，原因见 expense_repo_test.go 注释）。
package repository

import (
	"context"
	"errors"
	"path/filepath"
	"testing"
	"time"

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

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

// newOrderPayRepoDB 支付单表文件库。
func newOrderPayRepoDB(t *testing.T) *gorm.DB {
	t.Helper()
	dsn := filepath.Join(t.TempDir(), "academic_order_pay_repo_test.db")
	db, err := gorm.Open(gormsqlite.Open(dsn), &gorm.Config{})
	if err != nil {
		t.Fatalf("gorm.Open(支付单文件库) 失败: %v", err)
	}
	t.Cleanup(func() {
		if sqlDB, e := db.DB(); e == nil {
			_ = sqlDB.Close()
		}
	})
	if err := db.AutoMigrate(&model.OrderPay{}); err != nil {
		t.Fatalf("AutoMigrate(t_order_pay) 失败: %v", err)
	}
	return db
}

// seedOrderPay 插入一条支付单（机构/校区可为 nil，用于覆盖 NULL 行裁定）。
//
// createTime 传零值即由 DB 默认值兜底（model 侧 `default:CURRENT_TIMESTAMP`）。
func seedOrderPay(t *testing.T, db *gorm.DB, bizNo string, inst, campus *int64, userID *string, createTime time.Time) {
	t.Helper()
	row := &model.OrderPay{
		BizNo: bizNo, InstitutionID: inst, CampusID: campus, UserID: userID,
		PayMoney: "100.00", Status: model.OrderPayStatusUnpaid, CreateTime: createTime,
	}
	if err := db.Create(row).Error; err != nil {
		t.Fatalf("seed 支付单 %s 失败: %v", bizNo, err)
	}
}

// ptrI64 int64 指针助手（NULL 与 0 语义不同，显式构造便于阅读）。
func ptrI64(v int64) *int64 { return &v }

// ptrStr 字符串指针助手。
func ptrStr(v string) *string { return &v }

// TestOrderPayListByUserIncludesNullScope 通道①：付款人主口径——本人付的 NULL 机构行**必须**可见。
func TestOrderPayListByUserIncludesNullScope(t *testing.T) {
	db := newOrderPayRepoDB(t)
	const owner = "01HUSER000000000000000301"
	const otherUser = "01HUSER000000000000000302"
	base := time.Date(2026, 3, 1, 0, 0, 0, 0, time.UTC)

	seedOrderPay(t, db, "PAY-A", ptrI64(1), ptrI64(2), ptrStr(owner), base)
	seedOrderPay(t, db, "PAY-B", nil, nil, ptrStr(owner), base.Add(time.Minute)) // 家长代付/历史行：NULL 机构
	seedOrderPay(t, db, "PAY-C", ptrI64(2), ptrI64(5), ptrStr(otherUser), base)

	repo := NewOrderPayRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	rows, err := repo.ListByUser(context.Background(), owner, PageQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("ListByUser 失败: %v", err)
	}
	if len(rows) != 2 {
		t.Fatalf("本人订单数 = %d，期望 2（含 NULL 机构行，且不含他人订单）", len(rows))
	}
	if rows[0].BizNo != "PAY-B" || rows[1].BizNo != "PAY-A" {
		t.Fatalf("排序应为 create_time DESC：%s / %s", rows[0].BizNo, rows[1].BizNo)
	}
	nullSeen := false
	for _, r := range rows {
		if r.InstitutionID == nil {
			nullSeen = true
		}
	}
	if !nullSeen {
		t.Fatal("付款人通道必须返回 NULL 机构行（§2.5：钱是本人付的）")
	}
}

// TestOrderPayListByScopeExcludesNullRows 通道②：显式机构参数——NULL 行**不得**出现；非超管越权拒绝。
func TestOrderPayListByScopeExcludesNullRows(t *testing.T) {
	db := newOrderPayRepoDB(t)
	const user = "01HUSER000000000000000303"
	seedOrderPay(t, db, "PAY-D", ptrI64(1), ptrI64(2), ptrStr(user), time.Time{})
	seedOrderPay(t, db, "PAY-E", nil, nil, ptrStr(user), time.Time{}) // NULL 行：institution/campus 都空
	seedOrderPay(t, db, "PAY-F", ptrI64(2), ptrI64(5), ptrStr(user), time.Time{})

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

	all, err := repo.ListByScope(ctx, 1, nil, PageQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("ListByScope(inst=1) 失败: %v", err)
	}
	if len(all) != 1 || all[0].BizNo != "PAY-D" {
		t.Fatalf("机构 1 只应有 1 条非 NULL 行，实得 %d：%v", len(all), all)
	}

	withCampus, err := repo.ListByScope(ctx, 1, ptrI64(2), PageQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("ListByScope(inst=1,campus=2) 失败: %v", err)
	}
	if len(withCampus) != 1 || withCampus[0].BizNo != "PAY-D" {
		t.Fatalf("机构 1 校区 2 只应有 1 条，实得 %d", len(withCampus))
	}

	emptyCampus, err := repo.ListByScope(ctx, 1, ptrI64(9), PageQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("ListByScope(inst=1,campus=9) 失败: %v", err)
	}
	if emptyCampus == nil || len(emptyCampus) != 0 {
		t.Fatalf("空结果必须是非 nil 空切片：%v", emptyCampus)
	}

	// 非超管借参数跨机构 → ErrUnscoped
	if _, err := repo.ListByScope(ctx, 2, nil, PageQuery{}); !errors.Is(err, infraerrors.ErrUnscoped) {
		t.Fatalf("跨机构参数错误 = %v，期望 ErrUnscoped", err)
	}
	// 机构参数非法
	if _, err := repo.ListByScope(ctx, 0, nil, PageQuery{}); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("institution_id=0 错误 = %v，期望 ErrBadParam", err)
	}
	// nil 作用域（系统任务）不得走参数通道
	sys := NewOrderPayRepo(db, nil)
	if _, err := sys.ListByScope(ctx, 1, nil, PageQuery{}); !errors.Is(err, infraerrors.ErrUnscoped) {
		t.Fatalf("nil 作用域错误 = %v，期望 ErrUnscoped", err)
	}
	// 超管可看任意机构
	admin := NewOrderPayRepo(db, &appscope.Scope{SuperAdmin: true, InstitutionID: 9})
	adminRows, err := admin.ListByScope(ctx, 2, nil, PageQuery{PageSize: 10})
	if err != nil {
		t.Fatalf("超管查询失败: %v", err)
	}
	if len(adminRows) != 1 || adminRows[0].BizNo != "PAY-F" {
		t.Fatalf("超管应看到机构 2 的 1 条，实得 %d", len(adminRows))
	}
}

// TestOrderPayGetByOrderNo 通道③：系统通道按 biz_no 命中；pay_order 兜底；不存在 → ErrNotFound。
func TestOrderPayGetByOrderNo(t *testing.T) {
	db := newOrderPayRepoDB(t)
	const user = "01HUSER000000000000000304"
	seedOrderPay(t, db, "PAY-G", nil, nil, ptrStr(user), time.Time{})
	if err := db.Model(&model.OrderPay{}).Where("biz_no = ?", "PAY-G").
		UpdateColumn("pay_order", "4200001234").Error; err != nil {
		t.Fatalf("回填 pay_order 失败: %v", err)
	}

	sys := NewOrderPayRepo(db, nil) // 回调路径：无请求作用域
	ctx := context.Background()

	byBiz, err := sys.GetByOrderNo(ctx, "PAY-G")
	if err != nil {
		t.Fatalf("按 biz_no 查询失败: %v", err)
	}
	if byBiz.BizNo != "PAY-G" || byBiz.InstitutionID != nil {
		t.Fatalf("命中结果不符：%s / %v", byBiz.BizNo, byBiz.InstitutionID)
	}

	byPayOrder, err := sys.GetByOrderNo(ctx, "4200001234")
	if err != nil {
		t.Fatalf("按第三方流水号兜底查询失败: %v", err)
	}
	if byPayOrder.BizNo != "PAY-G" {
		t.Fatalf("兜底命中结果不符：%s", byPayOrder.BizNo)
	}

	if _, err := sys.GetByOrderNo(ctx, "PAY-NOT-EXIST"); !errors.Is(err, infraerrors.ErrNotFound) {
		t.Fatalf("不存在单号错误 = %v，期望 ErrNotFound", err)
	}
	if _, err := sys.GetByOrderNo(ctx, "  "); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("空单号错误 = %v，期望 ErrBadParam", err)
	}
}

// TestOrderPayUpdateStatusCASIdempotent CAS：首次成功、重复调用 affected=0、非法状态拒绝。
func TestOrderPayUpdateStatusCASIdempotent(t *testing.T) {
	db := newOrderPayRepoDB(t)
	repo := NewOrderPayRepo(db, nil)
	runner := NewTxRunner(db)
	ctx := context.Background()
	const user = "01HUSER000000000000000305"

	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		return repo.Create(ctx, tx, &model.OrderPay{
			BizNo: "PAY-H", UserID: ptrStr(user), InstitutionID: ptrI64(1), CampusID: ptrI64(2),
			PayMoney: "88.00", Status: model.OrderPayStatusUnpaid,
		})
	}); err != nil {
		t.Fatalf("创建支付单失败: %v", err)
	}

	// 首次回调：0 → 1
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		affected, e := repo.UpdateStatusCAS(ctx, tx, "PAY-H",
			model.OrderPayStatusUnpaid, model.OrderPayStatusSucceeded)
		if e != nil {
			return e
		}
		if affected != 1 {
			t.Fatalf("首次 CAS affected = %d，期望 1", affected)
		}
		return nil
	}); err != nil {
		t.Fatalf("首次 CAS 失败: %v", err)
	}

	// 重复回调：affected=0（幂等，禁止重复入账）
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		affected, e := repo.UpdateStatusCAS(ctx, tx, "PAY-H",
			model.OrderPayStatusUnpaid, model.OrderPayStatusSucceeded)
		if e != nil {
			return e
		}
		if affected != 0 {
			t.Fatalf("重复 CAS affected = %d，期望 0", affected)
		}
		return nil
	}); err != nil {
		t.Fatalf("重复 CAS 失败: %v", err)
	}

	// 不存在的单号：affected=0（不报错，由 Service 判 404/幂等）
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		affected, e := repo.UpdateStatusCAS(ctx, tx, "PAY-NONE",
			model.OrderPayStatusUnpaid, model.OrderPayStatusSucceeded)
		if e != nil {
			return e
		}
		if affected != 0 {
			t.Fatalf("不存在单号 affected = %d，期望 0", affected)
		}
		return nil
	}); err != nil {
		t.Fatalf("不存在单号用例失败: %v", err)
	}

	// 非法状态值 → ErrBadParam
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error {
		_, e := repo.UpdateStatusCAS(ctx, tx, "PAY-H", model.OrderPayStatusSucceeded, 9)
		if !errors.Is(e, infraerrors.ErrBadParam) {
			t.Fatalf("非法状态错误 = %v，期望 ErrBadParam", e)
		}
		return nil
	}); err != nil {
		t.Fatalf("非法状态用例失败: %v", err)
	}
}

// TestOrderPayCreateDuplicateBizNo 下单幂等：biz_no 撞键 → ErrDuplicateBizNo（3003）。
func TestOrderPayCreateDuplicateBizNo(t *testing.T) {
	db := newOrderPayRepoDB(t)
	repo := NewOrderPayRepo(db, nil)
	runner := NewTxRunner(db)
	ctx := context.Background()

	order := &model.OrderPay{BizNo: "PAY-I", PayMoney: "1.00", Status: model.OrderPayStatusUnpaid}
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error { return repo.Create(ctx, tx, order) }); err != nil {
		t.Fatalf("创建支付单失败: %v", err)
	}
	dup := &model.OrderPay{BizNo: "PAY-I", PayMoney: "1.00", Status: model.OrderPayStatusUnpaid}
	err := runner.WithinTx(ctx, func(tx *gorm.DB) error { return repo.Create(ctx, tx, dup) })
	if !errors.Is(err, ErrDuplicateBizNo) {
		t.Fatalf("重复单号错误 = %v，期望 ErrDuplicateBizNo", err)
	}
	// 缺 biz_no → ErrBadParam
	bad := &model.OrderPay{PayMoney: "1.00"}
	if err := runner.WithinTx(ctx, func(tx *gorm.DB) error { return repo.Create(ctx, tx, bad) }); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("缺 biz_no 错误 = %v，期望 ErrBadParam", err)
	}
}

// TestOrderPayListPagingEmpty 分页：空结果非 nil；pageSize 钳制 200。
func TestOrderPayListPagingEmpty(t *testing.T) {
	db := newOrderPayRepoDB(t)
	repo := NewOrderPayRepo(db, &appscope.Scope{InstitutionID: 1, CampusID: 2})
	ctx := context.Background()

	empty, err := repo.ListByUser(ctx, "01HUSER000000000000000399", PageQuery{})
	if err != nil {
		t.Fatalf("空结果查询失败: %v", err)
	}
	if empty == nil || len(empty) != 0 {
		t.Fatalf("空结果必须是非 nil 空切片：%v", empty)
	}
	if got := (PageQuery{PageSize: 1000}).Limit(); got != MaxPageSize {
		t.Fatalf("pageSize 钳制 = %d，期望 %d", got, MaxPageSize)
	}
	// 空 user_id → ErrBadParam
	if _, err := repo.ListByUser(ctx, " ", PageQuery{}); !errors.Is(err, infraerrors.ErrBadParam) {
		t.Fatalf("空 user_id 错误 = %v，期望 ErrBadParam", err)
	}
}