package userperm

import (
	"context"
	"errors"
	"math/rand"
	"sort"
	"testing"
	"time"

	"perms-system-server/internal/testutil"

	"github.com/go-sql-driver/mysql"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

func randUserPermId() int64 {
	return int64(900000 + rand.Intn(100000))
}

func sortedInt64Copy(a []int64) []int64 {
	b := append([]int64(nil), a...)
	sort.Slice(b, func(i, j int) bool { return b[i] < b[j] })
	return b
}

func int64SliceEqualIgnoreOrder(a, b []int64) bool {
	if len(a) != len(b) {
		return false
	}
	aa, bb := sortedInt64Copy(a), sortedInt64Copy(b)
	for i := range aa {
		if aa[i] != bb[i] {
			return false
		}
	}
	return true
}

func insertTestPerm(t *testing.T, ctx context.Context, conn sqlx.SqlConn, productCode, code string) int64 {
	t.Helper()
	ts := time.Now().Unix()
	q := "INSERT INTO `sys_perm` (`productCode`, `name`, `code`, `status`, `createTime`, `updateTime`) VALUES (?, ?, ?, 1, ?, ?)"
	res, err := conn.ExecCtx(ctx, q, productCode, "t", code, ts, ts)
	if err != nil {
		t.Fatalf("insert sys_perm: %v", err)
	}
	id, err := res.LastInsertId()
	if err != nil {
		t.Fatalf("perm LastInsertId: %v", err)
	}
	return id
}

// TC-0267: 正常插入
func TestSysUserPermModel_CRUD(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	data := &SysUserPerm{
		UserId:     userId,
		PermId:     permId,
		Effect:     "ALLOW",
		CreateTime: ts,
		UpdateTime: ts,
	}
	res, err := m.Insert(ctx, data)
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, err := res.LastInsertId()
	if err != nil {
		t.Fatalf("LastInsertId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.UserId != userId || got.PermId != permId || got.Effect != "ALLOW" {
		t.Fatalf("FindOne mismatch: %+v", got)
	}

	byPair, err := m.FindOneByUserIdPermId(ctx, userId, permId)
	if err != nil {
		t.Fatalf("FindOneByUserIdPermId: %v", err)
	}
	if byPair.Id != id {
		t.Fatalf("FindOneByUserIdPermId id want %d got %d", id, byPair.Id)
	}

	newTs := ts + 1
	got.Effect = "DENY"
	got.UpdateTime = newTs
	if err := m.Update(ctx, got); err != nil {
		t.Fatalf("Update: %v", err)
	}
	updated, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne after update: %v", err)
	}
	if updated.Effect != "DENY" || updated.UpdateTime != newTs {
		t.Fatalf("after Update: %+v", updated)
	}

	if err := m.Delete(ctx, id); err != nil {
		t.Fatalf("Delete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("after Delete want ErrNotFound got %v", err)
	}
}

// TC-0407: 正常查询
func TestSysUserPermModel_FindByUserId(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	p1, p2 := randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	var ids []int64
	for _, permId := range []int64{p1, p2} {
		res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_user_perm", id)
		}
	}()

	list, err := m.FindByUserId(ctx, userId)
	if err != nil {
		t.Fatalf("FindByUserId: %v", err)
	}
	if len(list) != 2 {
		t.Fatalf("len want 2 got %d", len(list))
	}
}

// TC-0409: ALLOW
func TestSysUserPermModel_FindPermIdsByUserIdAndEffect(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	pAllow, pDeny := randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	resA, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: pAllow, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert ALLOW: %v", err)
	}
	idA, _ := resA.LastInsertId()
	resD, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: pDeny, Effect: "DENY", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert DENY: %v", err)
	}
	idD, _ := resD.LastInsertId()
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_user_perm", idA, idD)
	}()

	allowIds, err := m.FindPermIdsByUserIdAndEffect(ctx, userId, "ALLOW")
	if err != nil {
		t.Fatalf("ALLOW: %v", err)
	}
	if !int64SliceEqualIgnoreOrder(allowIds, []int64{pAllow}) {
		t.Fatalf("ALLOW ids got %v", allowIds)
	}
	denyIds, err := m.FindPermIdsByUserIdAndEffect(ctx, userId, "DENY")
	if err != nil {
		t.Fatalf("DENY: %v", err)
	}
	if !int64SliceEqualIgnoreOrder(denyIds, []int64{pDeny}) {
		t.Fatalf("DENY ids got %v", denyIds)
	}
}

// TC-0412: 正常删除
func TestSysUserPermModel_DeleteByUserId(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2 := randUserPermId(), randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserPerm{UserId: u1, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserPerm{UserId: u2, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_user_perm", id1, id2)
	}()

	if err := m.DeleteByUserId(ctx, u1); err != nil {
		t.Fatalf("DeleteByUserId: %v", err)
	}
	if _, err := m.FindOne(ctx, id1); err != ErrNotFound {
		t.Fatalf("u1 row gone: %v", err)
	}
	if _, err := m.FindOne(ctx, id2); err != nil {
		t.Fatalf("u2 row remain: %v", err)
	}
}

// TC-0414: 正常删除
func TestSysUserPermModel_DeleteByUserIdForProduct(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pcA := "t_pc_a_" + testutil.UniqueId()
	pcB := "t_pc_b_" + testutil.UniqueId()
	codeA := "c_a_" + testutil.UniqueId()
	codeB := "c_b_" + testutil.UniqueId()

	permA := insertTestPerm(t, ctx, conn, pcA, codeA)
	permB := insertTestPerm(t, ctx, conn, pcB, codeB)
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_perm", permA, permB)
	}()

	userId := randUserPermId()
	ts := time.Now().Unix()

	resA, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permA, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert A: %v", err)
	}
	idA, _ := resA.LastInsertId()
	resB, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permB, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert B: %v", err)
	}
	idB, _ := resB.LastInsertId()
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_user_perm", idA, idB)
	}()

	if err := m.DeleteByUserIdForProduct(ctx, userId, pcA); err != nil {
		t.Fatalf("DeleteByUserIdForProduct: %v", err)
	}
	if _, err := m.FindOne(ctx, idA); err != ErrNotFound {
		t.Fatalf("permA row should delete: %v", err)
	}
	if _, err := m.FindOne(ctx, idB); err != nil {
		t.Fatalf("permB row should remain: %v", err)
	}
}

// TC-0274: 记录不存在
func TestSysUserPermModel_FindOne_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	_, err := m.FindOne(context.Background(), 999999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0336: FindOneByUserIdPermId
func TestSysUserPermModel_FindOneByUserIdPermId_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	_, err := m.FindOneByUserIdPermId(context.Background(), 999999999, 999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0408: 无记录
func TestSysUserPermModel_FindByUserId_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	list, err := m.FindByUserId(context.Background(), 999999999)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if len(list) != 0 {
		t.Fatalf("want empty got %d", len(list))
	}
}

// TC-0411: 无记录
func TestSysUserPermModel_FindPermIdsByUserIdAndEffect_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	ids, err := m.FindPermIdsByUserIdAndEffect(context.Background(), 999999999, "ALLOW")
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if len(ids) != 0 {
		t.Fatalf("want empty got %v", ids)
	}
}

// TC-0413: 事务内删除
func TestSysUserPermModel_DeleteByUserIdTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdTx(c, session, userId)
	})
	if err != nil {
		t.Fatalf("DeleteByUserIdTx: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("after tx delete want ErrNotFound got %v", err)
	}
}

// TC-0416: 事务内跨产品删除
func TestSysUserPermModel_DeleteByUserIdForProductTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	pcA := "t_upt_a_" + testutil.UniqueId()
	pcB := "t_upt_b_" + testutil.UniqueId()
	codeA := "c_ta_" + testutil.UniqueId()
	codeB := "c_tb_" + testutil.UniqueId()

	permA := insertTestPerm(t, ctx, conn, pcA, codeA)
	permB := insertTestPerm(t, ctx, conn, pcB, codeB)
	defer testutil.CleanTable(ctx, conn, "sys_perm", permA, permB)

	userId := randUserPermId()
	ts := time.Now().Unix()

	resA, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permA, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert A: %v", err)
	}
	idA, _ := resA.LastInsertId()
	resB, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permB, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert B: %v", err)
	}
	idB, _ := resB.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", idA, idB)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteByUserIdForProductTx(c, session, userId, pcA)
	})
	if err != nil {
		t.Fatalf("DeleteByUserIdForProductTx: %v", err)
	}
	if _, err := m.FindOne(ctx, idA); err != ErrNotFound {
		t.Fatalf("pcA row should delete: %v", err)
	}
	if _, err := m.FindOne(ctx, idB); err != nil {
		t.Fatalf("pcB row should remain: %v", err)
	}
}

// TC-0288: 空列表
func TestSysUserPermModel_BatchInsert_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchInsert(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchInsert(context.Background(), []*SysUserPerm{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0305: 空ids
func TestSysUserPermModel_BatchDelete_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchDelete(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchDelete(context.Background(), []int64{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0268: 唯一索引冲突
func TestSysUserPermModel_Insert_UniqueConflict(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	_, err = m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "DENY", CreateTime: ts, UpdateTime: ts})
	if err == nil {
		t.Fatal("second Insert want error")
	}
	var me *mysql.MySQLError
	if !errors.As(err, &me) || me.Number != 1062 {
		t.Fatalf("want duplicate key 1062, got %v", err)
	}
}

// TC-0270: 事务内插入
func TestSysUserPermModel_InsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		insertedId, _ = res.LastInsertId()
		return nil
	})
	if err != nil {
		t.Fatalf("TransactCtx: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", insertedId)

	got, err := m.FindOne(ctx, insertedId)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.UserId != userId || got.PermId != permId || got.Effect != "ALLOW" {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0271: 事务回滚后无数据
func TestSysUserPermModel_InsertWithTx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.InsertWithTx(c, session, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	_, err = m.FindOneByUserIdPermId(ctx, userId, permId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

// TC-0280: 记录不存在
func TestSysUserPermModel_Update_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	ts := time.Now().Unix()
	err := m.Update(context.Background(), &SysUserPerm{
		Id: 999999999, UserId: 1, PermId: 1, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts,
	})
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0281: 事务内更新
func TestSysUserPermModel_UpdateWithTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	newTs := ts + 100
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.UpdateWithTx(c, session, &SysUserPerm{
			Id: id, UserId: userId, PermId: permId, Effect: "DENY", CreateTime: ts, UpdateTime: newTs,
		})
	})
	if err != nil {
		t.Fatalf("UpdateWithTx: %v", err)
	}
	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("FindOne: %v", err)
	}
	if got.Effect != "DENY" || got.UpdateTime != newTs {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0283: 记录不存在
func TestSysUserPermModel_Delete_NotFound(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	err := m.Delete(context.Background(), 999999999)
	if err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0284: 事务内删除
func TestSysUserPermModel_DeleteWithTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.DeleteWithTx(c, session, id)
	})
	if err != nil {
		t.Fatalf("DeleteWithTx: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("after DeleteWithTx want ErrNotFound got %v", err)
	}
}

// TC-0286: fn返回错误
func TestSysUserPermModel_TransactCtx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.DeleteWithTx(c, session, id); err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	got, err := m.FindOne(ctx, id)
	if err != nil {
		t.Fatalf("after rollback FindOne: %v", err)
	}
	if got.Id != id {
		t.Fatalf("row should still exist")
	}
}

// TC-0287: 获取表名
func TestSysUserPermModel_TableName(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if m.TableName() != "`sys_user_perm`" {
		t.Fatalf("want `sys_user_perm` got %s", m.TableName())
	}
}

// TC-0289: 单条记录
func TestSysUserPermModel_BatchInsert_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysUserPerm{
		{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	got, err := m.FindOneByUserIdPermId(ctx, userId, permId)
	if err != nil {
		t.Fatalf("FindOneByUserIdPermId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", got.Id)
	if got.Effect != "ALLOW" {
		t.Fatalf("mismatch: %+v", got)
	}
}

// TC-0290: 多条记录(3条)
func TestSysUserPermModel_BatchInsert_Multi(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2, u3 := randUserPermId(), randUserPermId(), randUserPermId()
	p1, p2, p3 := randUserPermId(), randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysUserPerm{
		{UserId: u1, PermId: p1, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
		{UserId: u2, PermId: p2, Effect: "DENY", CreateTime: ts, UpdateTime: ts},
		{UserId: u3, PermId: p3, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	var ids []int64
	for _, pair := range [][2]int64{{u1, p1}, {u2, p2}, {u3, p3}} {
		got, err := m.FindOneByUserIdPermId(ctx, pair[0], pair[1])
		if err != nil {
			t.Fatalf("FindOneByUserIdPermId(%d,%d): %v", pair[0], pair[1], err)
		}
		ids = append(ids, got.Id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_user_perm", id)
		}
	}()
	if len(ids) != 3 {
		t.Fatalf("want 3 rows got %d", len(ids))
	}
}

// TC-0291: 唯一索引冲突
func TestSysUserPermModel_BatchInsert_UniqueConflict(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	err := m.BatchInsert(ctx, []*SysUserPerm{
		{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
		{UserId: userId, PermId: permId, Effect: "DENY", CreateTime: ts, UpdateTime: ts},
	})
	if err == nil {
		t.Fatal("want error for duplicate")
	}
	var me *mysql.MySQLError
	if !errors.As(err, &me) || me.Number != 1062 {
		t.Fatalf("want duplicate key 1062, got %v", err)
	}
}

// TC-0296: 空列表
func TestSysUserPermModel_BatchUpdate_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.BatchUpdate(context.Background(), nil); err != nil {
		t.Fatalf("nil: %v", err)
	}
	if err := m.BatchUpdate(context.Background(), []*SysUserPerm{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0298: 多条记录(3条)
func TestSysUserPermModel_BatchUpdate_Multi(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2 := randUserPermId(), randUserPermId()
	p1, p2 := randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserPerm{UserId: u1, PermId: p1, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserPerm{UserId: u2, PermId: p2, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id1, id2)

	newTs := ts + 100
	err = m.BatchUpdate(ctx, []*SysUserPerm{
		{Id: id1, UserId: u1, PermId: p1, Effect: "DENY", CreateTime: ts, UpdateTime: newTs},
		{Id: id2, UserId: u2, PermId: p2, Effect: "DENY", CreateTime: ts, UpdateTime: newTs},
	})
	if err != nil {
		t.Fatalf("BatchUpdate: %v", err)
	}
	got1, err := m.FindOne(ctx, id1)
	if err != nil {
		t.Fatalf("FindOne1: %v", err)
	}
	if got1.Effect != "DENY" || got1.UpdateTime != newTs {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
	got2, err := m.FindOne(ctx, id2)
	if err != nil {
		t.Fatalf("FindOne2: %v", err)
	}
	if got2.Effect != "DENY" || got2.UpdateTime != newTs {
		t.Fatalf("got2 mismatch: %+v", got2)
	}
}

// TC-0307: 多个id(3个)
func TestSysUserPermModel_BatchDelete_Multi(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 3; i++ {
		res, err := m.Insert(ctx, &SysUserPerm{
			UserId: randUserPermId(), PermId: randUserPermId(), Effect: "ALLOW", CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_user_perm", id)
		}
	}()

	if err := m.BatchDelete(ctx, ids); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	for _, id := range ids {
		if _, err := m.FindOne(ctx, id); err != ErrNotFound {
			t.Fatalf("id %d should be deleted: %v", id, err)
		}
	}
}

// TC-0306: 单个id
func TestSysUserPermModel_BatchDelete_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	if err := m.BatchDelete(ctx, []int64{id}); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0308: 包含不存在id
func TestSysUserPermModel_BatchDelete_ContainsNonExist(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id)

	if err := m.BatchDelete(ctx, []int64{id, 999999999}); err != nil {
		t.Fatalf("BatchDelete: %v", err)
	}
	if _, err := m.FindOne(ctx, id); err != ErrNotFound {
		t.Fatalf("want ErrNotFound got %v", err)
	}
}

// TC-0294: 正常多条
func TestSysUserPermModel_BatchInsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2 := randUserPermId(), randUserPermId()
	p1, p2 := randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchInsertWithTx(c, session, []*SysUserPerm{
			{UserId: u1, PermId: p1, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
			{UserId: u2, PermId: p2, Effect: "DENY", CreateTime: ts, UpdateTime: ts},
		})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx: %v", err)
	}
	got1, err := m.FindOneByUserIdPermId(ctx, u1, p1)
	if err != nil {
		t.Fatalf("FindOne u1p1: %v", err)
	}
	got2, err := m.FindOneByUserIdPermId(ctx, u2, p2)
	if err != nil {
		t.Fatalf("FindOne u2p2: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", got1.Id, got2.Id)
}

// TC-0293: 空列表
func TestSysUserPermModel_BatchInsertWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchInsertWithTx(c, session, []*SysUserPerm{})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx empty: %v", err)
	}
}

// TC-0295: 事务回滚
func TestSysUserPermModel_BatchInsertWithTx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, []*SysUserPerm{
			{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts},
		}); err != nil {
			return err
		}
		return errors.New("rollback")
	})
	if err == nil || err.Error() != "rollback" {
		t.Fatalf("want rollback error got %v", err)
	}
	_, err = m.FindOneByUserIdPermId(ctx, userId, permId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

// TC-0301: 正常多条
func TestSysUserPermModel_BatchUpdateWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	u1, u2 := randUserPermId(), randUserPermId()
	p1, p2 := randUserPermId(), randUserPermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysUserPerm{UserId: u1, PermId: p1, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysUserPerm{UserId: u2, PermId: p2, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", id1, id2)

	newTs := ts + 200
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchUpdateWithTx(c, session, []*SysUserPerm{
			{Id: id1, UserId: u1, PermId: p1, Effect: "DENY", CreateTime: ts, UpdateTime: newTs},
			{Id: id2, UserId: u2, PermId: p2, Effect: "DENY", CreateTime: ts, UpdateTime: newTs},
		})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx: %v", err)
	}
	got1, err := m.FindOne(ctx, id1)
	if err != nil {
		t.Fatalf("FindOne1: %v", err)
	}
	if got1.Effect != "DENY" || got1.UpdateTime != newTs {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
}

// TC-0300: 空列表
func TestSysUserPermModel_BatchUpdateWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchUpdateWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchUpdateWithTx(c, session, []*SysUserPerm{})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx empty: %v", err)
	}
}

// TC-0310: 正常多条
func TestSysUserPermModel_BatchDeleteWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	ts := time.Now().Unix()
	var ids []int64
	for i := 0; i < 2; i++ {
		res, err := m.Insert(ctx, &SysUserPerm{
			UserId: randUserPermId(), PermId: randUserPermId(), Effect: "ALLOW", CreateTime: ts, UpdateTime: ts,
		})
		if err != nil {
			t.Fatalf("Insert: %v", err)
		}
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	defer func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_user_perm", id)
		}
	}()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchDeleteWithTx(c, session, ids)
	})
	if err != nil {
		t.Fatalf("BatchDeleteWithTx: %v", err)
	}
	for _, id := range ids {
		if _, err := m.FindOne(ctx, id); err != ErrNotFound {
			t.Fatalf("id %d should be deleted: %v", id, err)
		}
	}
}

// TC-0309: 空ids
func TestSysUserPermModel_BatchDeleteWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchDeleteWithTx(c, session, nil); err != nil {
			return err
		}
		return m.BatchDeleteWithTx(c, session, []int64{})
	})
	if err != nil {
		t.Fatalf("BatchDeleteWithTx empty: %v", err)
	}
}

// TC-0278: 事务内可见性
func TestSysUserPermModel_FindOneWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneWithTx(c, session, insertedId)
		require.NoError(t, err)
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, permId, got.PermId)
		assert.Equal(t, "ALLOW", got.Effect)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", insertedId)
}

// TC-0277: 事务内记录不存在
func TestSysUserPermModel_FindOneWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	m := NewSysUserPermModel(testutil.GetTestSqlConn(), testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.FindOneWithTx(c, session, 999999999999)
		require.ErrorIs(t, err, ErrNotFound)
		return nil
	})
	require.NoError(t, err)
}

// TC-0337: FindOneByUserIdPermIdWithTx
func TestSysUserPermModel_FindOneByUserIdPermIdWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysUserPermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	userId := randUserPermId()
	permId := randUserPermId()
	ts := time.Now().Unix()

	var insertedId int64
	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		res, err := m.InsertWithTx(c, session, &SysUserPerm{UserId: userId, PermId: permId, Effect: "ALLOW", CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneByUserIdPermIdWithTx(c, session, userId, permId)
		require.NoError(t, err)
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, userId, got.UserId)
		assert.Equal(t, permId, got.PermId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_user_perm", insertedId)
}

// TC-0338: FindOneByUserIdPermIdWithTx
func TestSysUserPermModel_FindOneByUserIdPermIdWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	m := NewSysUserPermModel(testutil.GetTestSqlConn(), testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.FindOneByUserIdPermIdWithTx(c, session, 999999999, 999999999)
		require.ErrorIs(t, err, ErrNotFound)
		return nil
	})
	require.NoError(t, err)
}