package auth

import (
	"context"
	"errors"
	"testing"

	"perms-system-server/internal/consts"
	"perms-system-server/internal/model/dept"
	"perms-system-server/internal/model/productmember"
	"perms-system-server/internal/testutil/mocks"

	"github.com/stretchr/testify/assert"
	"go.uber.org/mock/gomock"
)

var errDB = errors.New("db error")

// TC-0232: isSuperAdmin=true, deptId=0, FindAllCodesByProductCode返回err
func TestGetUserPerms_Mock_SuperAdmin_FindAllCodesFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindAllCodesByProductCode(gomock.Any(), "pc").Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		Perm: mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", true)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Empty(t, memberType)
}

// TC-0234: deptId=0, FindOneByProductCodeUserId返回DB error
func TestGetUserPerms_Mock_MemberQueryDBError(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Empty(t, memberType)
}

// TC-0237: deptId=0, MemberType="DEVELOPER", FindAllCodesByProductCode失败
func TestGetUserPerms_Mock_Developer_FindAllCodesFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeDeveloper}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindAllCodesByProductCode(gomock.Any(), "pc").Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeDeveloper, memberType)
}

// TC-0252: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindRoleIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0253: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindRoleByIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{10, 20}, nil)

	mockRole := mocks.NewMockSysRoleModel(ctrl)
	mockRole.EXPECT().FindByIds(gomock.Any(), []int64{10, 20}).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
		Role:          mockRole,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0254: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindPermIdsByRoleIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
		RolePerm:      mockRP,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0255: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindAllowPermIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return([]int64{}, nil)

	mockUP := mocks.NewMockSysUserPermModel(ctrl)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectAllow).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
		RolePerm:      mockRP,
		UserPerm:      mockUP,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0256: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindDenyPermIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return([]int64{}, nil)

	mockUP := mocks.NewMockSysUserPermModel(ctrl)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectAllow).Return([]int64{}, nil)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectDeny).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
		RolePerm:      mockRP,
		UserPerm:      mockUP,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0257: deptId=0, 返回err
func TestGetUserPerms_Mock_Member_FindPermByIdsFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return([]int64{}, nil)

	mockUP := mocks.NewMockSysUserPermModel(ctrl)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectAllow).Return([]int64{100}, nil)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectDeny).Return([]int64{}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindByIds(gomock.Any(), gomock.Any()).Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		UserRole:      mockUR,
		RolePerm:      mockRP,
		UserPerm:      mockUP,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 0, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0238: deptId>0, MemberType="MEMBER", SysDeptModel.FindOne返回DeptType="DEV", FindAllCodesByProductCode返回["a","b","c"]
func TestGetUserPerms_Mock_Member_DevDeptGetAllPerms(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockDept := mocks.NewMockSysDeptModel(ctrl)
	mockDept.EXPECT().FindOne(gomock.Any(), int64(100)).
		Return(&dept.SysDept{Id: 100, DeptType: consts.DeptTypeDev}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindAllCodesByProductCode(gomock.Any(), "pc").Return([]string{"p1", "p2", "p3"}, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		Dept:          mockDept,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 100, "pc", false)
	assert.NoError(t, err)
	assert.Equal(t, consts.MemberTypeMember, memberType)
	assert.ElementsMatch(t, []string{"p1", "p2", "p3"}, perms)
}

// TC-0239: deptId>0, DeptType="DEV", FindAllCodesByProductCode返回err
func TestGetUserPerms_Mock_Member_DevDeptFindAllCodesFail(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockDept := mocks.NewMockSysDeptModel(ctrl)
	mockDept.EXPECT().FindOne(gomock.Any(), int64(100)).
		Return(&dept.SysDept{Id: 100, DeptType: consts.DeptTypeDev}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindAllCodesByProductCode(gomock.Any(), "pc").Return(nil, errDB)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		Dept:          mockDept,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 100, "pc", false)
	assert.ErrorIs(t, err, errDB)
	assert.Nil(t, perms)
	assert.Equal(t, consts.MemberTypeMember, memberType)
}

// TC-0241: deptId>0, FindOne返回ErrNotFound
func TestGetUserPerms_Mock_Member_DeptFindOneFail_FallsThrough(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockDept := mocks.NewMockSysDeptModel(ctrl)
	mockDept.EXPECT().FindOne(gomock.Any(), int64(100)).
		Return(nil, errors.New("dept not found"))

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return([]int64{}, nil)

	mockUP := mocks.NewMockSysUserPermModel(ctrl)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectAllow).Return([]int64{}, nil)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectDeny).Return([]int64{}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindByIds(gomock.Any(), gomock.Any()).Return(nil, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		Dept:          mockDept,
		UserRole:      mockUR,
		RolePerm:      mockRP,
		UserPerm:      mockUP,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 100, "pc", false)
	assert.NoError(t, err)
	assert.Equal(t, consts.MemberTypeMember, memberType)
	assert.Empty(t, perms)
}

// TC-0240: deptId>0, DeptType="NORMAL"
func TestGetUserPerms_Mock_Member_NormalDeptFallsThrough(t *testing.T) {
	ctrl := gomock.NewController(t)
	defer ctrl.Finish()

	mockPM := mocks.NewMockSysProductMemberModel(ctrl)
	mockPM.EXPECT().FindOneByProductCodeUserId(gomock.Any(), "pc", int64(1)).
		Return(&productmember.SysProductMember{MemberType: consts.MemberTypeMember}, nil)

	mockDept := mocks.NewMockSysDeptModel(ctrl)
	mockDept.EXPECT().FindOne(gomock.Any(), int64(100)).
		Return(&dept.SysDept{Id: 100, DeptType: consts.DeptTypeNormal}, nil)

	mockUR := mocks.NewMockSysUserRoleModel(ctrl)
	mockUR.EXPECT().FindRoleIdsByUserId(gomock.Any(), int64(1)).Return([]int64{}, nil)

	mockRP := mocks.NewMockSysRolePermModel(ctrl)
	mockRP.EXPECT().FindPermIdsByRoleIds(gomock.Any(), gomock.Any()).Return([]int64{}, nil)

	mockUP := mocks.NewMockSysUserPermModel(ctrl)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectAllow).Return([]int64{}, nil)
	mockUP.EXPECT().FindPermIdsByUserIdAndEffect(gomock.Any(), int64(1), consts.PermEffectDeny).Return([]int64{}, nil)

	mockPerm := mocks.NewMockSysPermModel(ctrl)
	mockPerm.EXPECT().FindByIds(gomock.Any(), gomock.Any()).Return(nil, nil)

	svcCtx := mocks.NewMockServiceContext(mocks.MockModels{
		ProductMember: mockPM,
		Dept:          mockDept,
		UserRole:      mockUR,
		RolePerm:      mockRP,
		UserPerm:      mockUP,
		Perm:          mockPerm,
	})

	perms, memberType, err := GetUserPerms(context.Background(), svcCtx, 1, 100, "pc", false)
	assert.NoError(t, err)
	assert.Equal(t, consts.MemberTypeMember, memberType)
	assert.Empty(t, perms)
}