package member

import (
	"errors"
	"testing"

	"perms-system-server/internal/consts"
	"perms-system-server/internal/response"
	"perms-system-server/internal/svc"
	"perms-system-server/internal/testutil"
	"perms-system-server/internal/testutil/ctxhelper"
	"perms-system-server/internal/types"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// ---------------------------------------------------------------------------
// 覆盖目标：审计 L-R11-1 —— UpdateMemberReq 的 MemberType / Status 指针化后，
//   1) 既表达"字段未传"≠"字段传零值"（区分"不改"和"改成 0"/"改成 ''"），
//   2) 又要在两者都 nil 时由 Logic 层兜底 400，避免无害路径被当"空 update"落库；
//   3) 只传 Status 不传 MemberType（反之亦然）时不得回归出"把对面字段写成空字符串"的 bug；
//   4) 已经是 DEVELOPER 的人，只传 Status 冻结/启用时绝不得误触 CheckMemberTypeAssignment，
//      否则普通 admin 永远无法对 DEVELOPER 做冻结/解冻。
// ---------------------------------------------------------------------------

func int64Ptr(v int64) *int64 { return &v }

// TC-1056: L-R11-1 —— 两字段同时 nil，必须 400，且不得做任何 DB 读写
func TestUpdateMember_BothFieldsNil_RejectedWith400(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
		Id: sp.mId,
	})
	require.Error(t, err)
	var ce *response.CodeError
	require.True(t, errors.As(err, &ce),
		"L-R11-1：两字段全 nil 必须命中 response.ErrBadRequest，且以 *CodeError 传递")
	assert.Equal(t, 400, ce.Code(),
		"L-R11-1：两字段全 nil 必须 400，不得退化成 200 no-op 或 500")
	assert.Contains(t, ce.Error(), "至少提供一个",
		"错误消息应明确提示至少要传 memberType 或 status 之一，便于接入方排查空请求体")

	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
		"L-R11-1：Logic 提前 400，任何 DB 落库都是回归；MemberType 必须保留原值")
	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
		"L-R11-1：Logic 提前 400 时 Status 也必须保留原值")
}

// TC-1057: L-R11-1 —— 仅改 Status，MemberType 字段必须按原值保留；绝不回归成 ""
func TestUpdateMember_OnlyStatus_PreservesMemberType(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	require.NoError(t,
		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
			Id:     sp.mId,
			Status: int64Ptr(consts.StatusDisabled),
		}),
		"只改 Status 必须成功")

	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, int64(consts.StatusDisabled), got.Status,
		"L-R11-1：Status 应按入参更新到禁用")
	assert.Equal(t, consts.MemberTypeMember, got.MemberType,
		"L-R11-1 回归防线：旧实现若以空串当缺省值会把 memberType 改写成 ''，"+
			"权限侧会当这行为非法成员吊销其全部权限，必须杜绝")
}

// TC-1058: L-R11-1 —— 仅改 MemberType，Status 原值保留
func TestUpdateMember_OnlyMemberType_PreservesStatus(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	require.NoError(t,
		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
			Id:         sp.mId,
			MemberType: strPtr(consts.MemberTypeAdmin),
		}),
		"只改 MemberType 必须成功")

	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, consts.MemberTypeAdmin, got.MemberType)
	assert.Equal(t, int64(consts.StatusEnabled), got.Status,
		"L-R11-1：Status 未提供时必须保留原值；若回归成 0 会让该成员瞬间冻结")
}

// TC-1059: L-R11-1 —— DEVELOPER 成员仅改 Status 冻结，不得误触 CheckMemberTypeAssignment
// 语义上 CheckMemberTypeAssignment 拦的是"用普通 admin 指派/变更 DEVELOPER"的动作；仅冻结
// 一个已存在的 DEVELOPER 不属于"指派 DEVELOPER"，必须放行。否则普通 admin 将永远无法管理
// DEVELOPER 的启停，只能靠超管——属于管理面瘫痪。
func TestUpdateMember_DeveloperStatusOnly_BypassesAssignmentCheck(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeDeveloper)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	require.NoError(t,
		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
			Id:     sp.mId,
			Status: int64Ptr(consts.StatusDisabled),
		}),
		"L-R11-1：DEVELOPER 只冻结 (Status=2) 时必须跳过 CheckMemberTypeAssignment；"+
			"修复前的 `if memberType == DEVELOPER` 早期校验会把这条合法请求拒成 403")

	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, consts.MemberTypeDeveloper, got.MemberType,
		"MemberType 在未传时必须保留 DEVELOPER")
	assert.Equal(t, int64(consts.StatusDisabled), got.Status)
}

// TC-1060: L-R11-1 —— 无效 Status（非 1/2）必须 400，不得被"只传 Status"分支绕过校验
func TestUpdateMember_InvalidStatusValue_Rejected(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	for _, bad := range []int64{0, 3, -1, 999} {
		err := NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
			Id:     sp.mId,
			Status: int64Ptr(bad),
		})
		require.Error(t, err)
		var ce *response.CodeError
		require.True(t, errors.As(err, &ce),
			"L-R11-1：无效 Status 必须 *CodeError")
		assert.Equal(t, 400, ce.Code(),
			"L-R11-1：Status=%d 必须 400 被拒，严禁靠 DB CHECK 或下游枚举触发 500", bad)
	}

	got, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, int64(consts.StatusEnabled), got.Status, "非法 Status 全部被拒，原值必须不变")
}

// TC-1061: L-R11-1 —— 值与现状完全一致（no-op）不报错，且**不触发** DB 事务/缓存失效
// 这里只能通过"不返回 error"以及"DB 值稳定 + updateTime 不前进"的软信号来近似验证；
// 契约上：nextType == member.MemberType && nextStatus == member.Status 时 Logic 早退。
func TestUpdateMember_NoOpUpdate_ReturnsNil(t *testing.T) {
	ctx := ctxhelper.SuperAdminCtx()
	svcCtx := svc.NewServiceContext(testutil.GetTestConfig())
	sp := seedEnabledProductWithMember(t, svcCtx, consts.MemberTypeMember)
	t.Cleanup(func() { cleanupSeeded(t, svcCtx, sp) })

	before, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)

	require.NoError(t,
		NewUpdateMemberLogic(ctx, svcCtx).UpdateMember(&types.UpdateMemberReq{
			Id:         sp.mId,
			MemberType: strPtr(before.MemberType),
			Status:     int64Ptr(before.Status),
		}),
		"L-R11-1：no-op update 必须 nil，不得被 ErrUpdateConflict 之类误报")

	after, err := svcCtx.SysProductMemberModel.FindOne(ctx, sp.mId)
	require.NoError(t, err)
	assert.Equal(t, before.MemberType, after.MemberType)
	assert.Equal(t, before.Status, after.Status)
	assert.Equal(t, before.UpdateTime, after.UpdateTime,
		"L-R11-1 强化：Logic 在 no-op 时应直接 return nil，不进事务，"+
			"updateTime 不应被推进；推进即说明 Logic 仍然走了一次冗余 UPDATE")
}