package roleperm

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 randRolePermId() 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
}

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	data := &SysRolePerm{
		RoleId:     roleId,
		PermId:     permId,
		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_role_perm", id)

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

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

	newTs := ts + 1
	got.UpdateTime = newTs
	got.PermId = permId
	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.UpdateTime != newTs {
		t.Fatalf("UpdateTime want %d got %d", newTs, updated.UpdateTime)
	}

	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-0399: 正常查询
func TestSysRolePermModel_FindPermIdsByRoleId(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	var ids []int64
	for _, permId := range []int64{p1, p2} {
		res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, 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_role_perm", id)
		}
	}()

	got, err := m.FindPermIdsByRoleId(ctx, roleId)
	if err != nil {
		t.Fatalf("FindPermIdsByRoleId: %v", err)
	}
	if !int64SliceEqualIgnoreOrder(got, []int64{p1, p2}) {
		t.Fatalf("FindPermIdsByRoleId got %v want %v", got, []int64{p1, p2})
	}
}

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

	sharedPerm := randRolePermId()
	r1, r2 := randRolePermId(), randRolePermId()
	otherPerm := randRolePermId()
	ts := time.Now().Unix()

	rows := []struct {
		roleId, permId int64
	}{
		{r1, sharedPerm},
		{r2, sharedPerm},
		{r1, otherPerm},
	}
	var ids []int64
	for i, row := range rows {
		res, err := m.Insert(ctx, &SysRolePerm{
			Id:         int64(910000000 + i),
			RoleId:     row.roleId,
			PermId:     row.permId,
			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_role_perm", id)
		}
	}()

	empty, err := m.FindPermIdsByRoleIds(ctx, nil)
	if err != nil {
		t.Fatalf("empty nil slice: %v", err)
	}
	if empty != nil {
		t.Fatalf("empty nil slice want nil got %#v", empty)
	}

	empty2, err := m.FindPermIdsByRoleIds(ctx, []int64{})
	if err != nil {
		t.Fatalf("empty slice: %v", err)
	}
	if empty2 != nil {
		t.Fatalf("empty slice want nil got %#v", empty2)
	}

	got, err := m.FindPermIdsByRoleIds(ctx, []int64{r1, r2})
	if err != nil {
		t.Fatalf("FindPermIdsByRoleIds: %v", err)
	}
	want := []int64{sharedPerm, otherPerm}
	if !int64SliceEqualIgnoreOrder(got, want) {
		t.Fatalf("FindPermIdsByRoleIds got %v want %v (distinct shared perm)", got, want)
	}
}

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

	roleId := randRolePermId()
	keepRole := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysRolePerm{RoleId: keepRole, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer func() {
		testutil.CleanTable(ctx, conn, "sys_role_perm", id1, id2)
	}()

	if err := m.DeleteByRoleId(ctx, roleId); err != nil {
		t.Fatalf("DeleteByRoleId: %v", err)
	}
	if _, err := m.FindOne(ctx, id1); err != ErrNotFound {
		t.Fatalf("row1 should be deleted: %v", err)
	}
	if _, err := m.FindOne(ctx, id2); err != nil {
		t.Fatalf("row2 should remain: %v", err)
	}
}

// TC-0406: 正常事务内删除
func TestSysRolePermModel_DeleteByRoleIdTx(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id)

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

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

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	list := []*SysRolePerm{
		{Id: 920000001, RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: ts},
		{Id: 920000002, RoleId: roleId, PermId: p2, CreateTime: ts, UpdateTime: ts},
	}
	if err := m.BatchInsert(ctx, list); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	got, err := m.FindPermIdsByRoleId(ctx, roleId)
	if err != nil {
		t.Fatalf("FindPermIdsByRoleId: %v", err)
	}
	if !int64SliceEqualIgnoreOrder(got, []int64{p1, p2}) {
		t.Fatalf("got %v want %v", got, []int64{p1, p2})
	}
	var rows []struct {
		Id int64 `db:"id"`
	}
	q := "SELECT `id` FROM `sys_role_perm` WHERE `roleId` = ? ORDER BY `id`"
	if err := conn.QueryRowsCtx(ctx, &rows, q, roleId); err != nil {
		t.Fatalf("query ids: %v", err)
	}
	defer func() {
		for _, r := range rows {
			testutil.CleanTable(ctx, conn, "sys_role_perm", r.Id)
		}
	}()
	if len(rows) != 2 {
		t.Fatalf("want 2 rows got %d", len(rows))
	}
}

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

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

// TC-0400: 无绑定
func TestSysRolePermModel_FindPermIdsByRoleId_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	got, err := m.FindPermIdsByRoleId(context.Background(), 999999999)
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	if len(got) != 0 {
		t.Fatalf("want empty got %v", got)
	}
}

// TC-0405: 无绑定
func TestSysRolePermModel_DeleteByRoleId_NoRows(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if err := m.DeleteByRoleId(context.Background(), 999999999); err != nil {
		t.Fatalf("DeleteByRoleId on no rows: %v", err)
	}
}

// TC-0288: 空列表
func TestSysRolePermModel_BatchInsert_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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(), []*SysRolePerm{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

// TC-0305: 空ids
func TestSysRolePermModel_BatchDelete_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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 TestSysRolePermModel_Insert_UniqueConflict(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id)

	_, err = m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, 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 TestSysRolePermModel_InsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	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, &SysRolePerm{RoleId: roleId, PermId: permId, 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_role_perm", insertedId)

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

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		_, err := m.InsertWithTx(c, session, &SysRolePerm{RoleId: roleId, PermId: permId, 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.FindOneByRoleIdPermId(ctx, roleId, permId)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

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

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

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id)

	newTs := ts + 100
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.UpdateWithTx(c, session, &SysRolePerm{
			Id: id, RoleId: roleId, PermId: permId, 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.UpdateTime != newTs {
		t.Fatalf("UpdateTime want %d got %d", newTs, got.UpdateTime)
	}
}

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

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_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 TestSysRolePermModel_TransactCtx_Rollback(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_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 TestSysRolePermModel_TableName(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())
	if m.TableName() != "`sys_role_perm`" {
		t.Fatalf("want `sys_role_perm` got %s", m.TableName())
	}
}

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	if err := m.BatchInsert(ctx, []*SysRolePerm{
		{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts},
	}); err != nil {
		t.Fatalf("BatchInsert: %v", err)
	}
	got, err := m.FindOneByRoleIdPermId(ctx, roleId, permId)
	if err != nil {
		t.Fatalf("FindOneByRoleIdPermId: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", got.Id)
	if got.RoleId != roleId || got.PermId != permId {
		t.Fatalf("mismatch: %+v", got)
	}
}

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

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	err := m.BatchInsert(ctx, []*SysRolePerm{
		{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts},
		{RoleId: roleId, PermId: permId, 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 TestSysRolePermModel_BatchUpdate_Empty(t *testing.T) {
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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(), []*SysRolePerm{}); err != nil {
		t.Fatalf("empty: %v", err)
	}
}

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

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p2, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id1, id2)

	newTs := ts + 100
	newP1, newP2 := randRolePermId(), randRolePermId()
	err = m.BatchUpdate(ctx, []*SysRolePerm{
		{Id: id1, RoleId: roleId, PermId: newP1, CreateTime: ts, UpdateTime: newTs},
		{Id: id2, RoleId: roleId, PermId: newP2, 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.UpdateTime != newTs || got1.PermId != newP1 {
		t.Fatalf("got1 mismatch: %+v", got1)
	}
	got2, err := m.FindOne(ctx, id2)
	if err != nil {
		t.Fatalf("FindOne2: %v", err)
	}
	if got2.UpdateTime != newTs || got2.PermId != newP2 {
		t.Fatalf("got2 mismatch: %+v", got2)
	}
}

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

	roleId := randRolePermId()
	p1, p2, p3 := randRolePermId(), randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	var ids []int64
	for _, permId := range []int64{p1, p2, p3} {
		res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, 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_role_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 TestSysRolePermModel_BatchDelete_Single(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_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 TestSysRolePermModel_BatchDelete_ContainsNonExist(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	ts := time.Now().Unix()

	res, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert: %v", err)
	}
	id, _ := res.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_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 TestSysRolePermModel_BatchInsertWithTx_Normal(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchInsertWithTx(c, session, []*SysRolePerm{
			{RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: ts},
			{RoleId: roleId, PermId: p2, CreateTime: ts, UpdateTime: ts},
		})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx: %v", err)
	}
	got1, err := m.FindOneByRoleIdPermId(ctx, roleId, p1)
	if err != nil {
		t.Fatalf("FindOne p1: %v", err)
	}
	got2, err := m.FindOneByRoleIdPermId(ctx, roleId, p2)
	if err != nil {
		t.Fatalf("FindOne p2: %v", err)
	}
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", got1.Id, got2.Id)
}

// TC-0293: 空列表
func TestSysRolePermModel_BatchInsertWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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, []*SysRolePerm{})
	})
	if err != nil {
		t.Fatalf("BatchInsertWithTx empty: %v", err)
	}
}

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

	roleId := randRolePermId()
	p1 := randRolePermId()
	ts := time.Now().Unix()

	err := m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		if err := m.BatchInsertWithTx(c, session, []*SysRolePerm{
			{RoleId: roleId, PermId: p1, 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.FindOneByRoleIdPermId(ctx, roleId, p1)
	if err != ErrNotFound {
		t.Fatalf("after rollback want ErrNotFound got %v", err)
	}
}

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

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p2, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id1, id2)

	newTs := ts + 200
	err = m.TransactCtx(ctx, func(c context.Context, session sqlx.Session) error {
		return m.BatchUpdateWithTx(c, session, []*SysRolePerm{
			{Id: id1, RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: newTs},
			{Id: id2, RoleId: roleId, PermId: p2, 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.UpdateTime != newTs {
		t.Fatalf("got1 UpdateTime want %d got %d", newTs, got1.UpdateTime)
	}
}

// TC-0300: 空列表
func TestSysRolePermModel_BatchUpdateWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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, []*SysRolePerm{})
	})
	if err != nil {
		t.Fatalf("BatchUpdateWithTx empty: %v", err)
	}
}

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

	roleId := randRolePermId()
	p1, p2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	res1, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p1, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert1: %v", err)
	}
	id1, _ := res1.LastInsertId()
	res2, err := m.Insert(ctx, &SysRolePerm{RoleId: roleId, PermId: p2, CreateTime: ts, UpdateTime: ts})
	if err != nil {
		t.Fatalf("Insert2: %v", err)
	}
	id2, _ := res2.LastInsertId()
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", id1, id2)

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

// TC-0309: 空ids
func TestSysRolePermModel_BatchDeleteWithTx_Empty(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(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 TestSysRolePermModel_FindOneWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	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, &SysRolePerm{RoleId: roleId, PermId: permId, 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)
		if err != nil {
			return err
		}
		assert.Equal(t, roleId, got.RoleId)
		assert.Equal(t, permId, got.PermId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", insertedId)
}

// TC-0277: 事务内记录不存在
func TestSysRolePermModel_FindOneWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, 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-0333: FindOneByRoleIdPermIdWithTx
func TestSysRolePermModel_FindOneByRoleIdPermIdWithTx_InsertThenFind(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	roleId := randRolePermId()
	permId := randRolePermId()
	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, &SysRolePerm{RoleId: roleId, PermId: permId, CreateTime: ts, UpdateTime: ts})
		if err != nil {
			return err
		}
		insertedId, err = res.LastInsertId()
		if err != nil {
			return err
		}
		got, err := m.FindOneByRoleIdPermIdWithTx(c, session, roleId, permId)
		if err != nil {
			return err
		}
		assert.Equal(t, insertedId, got.Id)
		assert.Equal(t, roleId, got.RoleId)
		assert.Equal(t, permId, got.PermId)
		return nil
	})
	require.NoError(t, err)
	defer testutil.CleanTable(ctx, conn, "sys_role_perm", insertedId)
}

// TC-0334: FindOneByRoleIdPermIdWithTx
func TestSysRolePermModel_FindOneByRoleIdPermIdWithTx_NotFound(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

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

// TC-0403: FindPermIdsByRoleIds 去重验证
func TestSysRolePermModel_FindPermIdsByRoleIds_Dedup(t *testing.T) {
	ctx := context.Background()
	conn := testutil.GetTestSqlConn()
	m := NewSysRolePermModel(conn, testutil.GetTestCacheConf(), testutil.GetTestCachePrefix())

	sharedPerm := randRolePermId()
	r1, r2 := randRolePermId(), randRolePermId()
	ts := time.Now().Unix()

	var ids []int64
	for _, row := range []struct{ roleId, permId int64 }{{r1, sharedPerm}, {r2, sharedPerm}} {
		res, err := m.Insert(ctx, &SysRolePerm{RoleId: row.roleId, PermId: row.permId, CreateTime: ts, UpdateTime: ts})
		require.NoError(t, err)
		id, _ := res.LastInsertId()
		ids = append(ids, id)
	}
	t.Cleanup(func() {
		for _, id := range ids {
			testutil.CleanTable(ctx, conn, "sys_role_perm", id)
		}
	})

	got, err := m.FindPermIdsByRoleIds(ctx, []int64{r1, r2})
	require.NoError(t, err)
	require.Len(t, got, 1)
	assert.Equal(t, sharedPerm, got[0])
}