package user

import (
	"context"
	"testing"

	"github.com/youruser/base/internal/types"
	"github.com/youruser/base/model"

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

// TestCreateUser_WithRole 测试创建用户时指定角色
func TestCreateUser_WithRole(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()
	logic := NewCreateUserLogic(ctx, svcCtx)

	req := &types.CreateUserRequest{
		Username: "admin_test",
		Email:    "admin_test@example.com",
		Password: "password123",
		Role:     "admin",
		Remark:   "Test admin user",
	}

	resp, err := logic.CreateUser(req)

	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "admin", resp.Role)
	assert.Equal(t, "manual", resp.Source)
	assert.Equal(t, "Test admin user", resp.Remark)
}

// TestCreateUser_DefaultRole 测试创建用户时不指定角色，应默认 user
func TestCreateUser_DefaultRole(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()
	logic := NewCreateUserLogic(ctx, svcCtx)

	req := &types.CreateUserRequest{
		Username: "default_role_test",
		Email:    "default_role@example.com",
		Password: "password123",
	}

	resp, err := logic.CreateUser(req)

	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "user", resp.Role)
	assert.Equal(t, "manual", resp.Source)
	assert.Equal(t, "", resp.Remark)
}

// TestGetUser_ReturnsRoleFields 测试获取用户时返回 role/source/remark
func TestGetUser_ReturnsRoleFields(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()

	// 先创建一个带角色的用户
	createLogic := NewCreateUserLogic(ctx, svcCtx)
	createResp, err := createLogic.CreateUser(&types.CreateUserRequest{
		Username: "role_fields_test",
		Email:    "role_fields@example.com",
		Password: "password123",
		Role:     "admin",
		Remark:   "role fields test",
	})
	require.NoError(t, err)

	// 查询该用户
	getLogic := NewGetUserLogic(ctx, svcCtx)
	resp, err := getLogic.GetUser(&types.GetUserRequest{Id: createResp.Id})

	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "admin", resp.Role)
	assert.Equal(t, "manual", resp.Source)
	assert.Equal(t, "role fields test", resp.Remark)
}

// TestGetUserList_ReturnsRoleFields 测试用户列表返回 role/source/remark
func TestGetUserList_ReturnsRoleFields(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()

	// 创建不同角色的用户
	createLogic := NewCreateUserLogic(ctx, svcCtx)
	_, err := createLogic.CreateUser(&types.CreateUserRequest{
		Username: "list_admin",
		Email:    "list_admin@example.com",
		Password: "password123",
		Role:     "admin",
	})
	require.NoError(t, err)

	createLogic2 := NewCreateUserLogic(ctx, svcCtx)
	_, err = createLogic2.CreateUser(&types.CreateUserRequest{
		Username: "list_user",
		Email:    "list_user@example.com",
		Password: "password123",
	})
	require.NoError(t, err)

	// 查询列表
	listLogic := NewGetUserListLogic(ctx, svcCtx)
	resp, err := listLogic.GetUserList(&types.UserListRequest{
		Page:     1,
		PageSize: 10,
	})

	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.GreaterOrEqual(t, len(resp.List), 2)

	// 验证每个用户都有 role 字段
	for _, u := range resp.List {
		assert.NotEmpty(t, u.Role, "用户 %s 的 role 不应为空", u.Username)
		assert.NotEmpty(t, u.Source, "用户 %s 的 source 不应为空", u.Username)
	}
}

// TestUpdateUser_RoleAndRemark 测试更新用户角色和备注
func TestUpdateUser_RoleAndRemark(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()

	// 创建用户
	createLogic := NewCreateUserLogic(ctx, svcCtx)
	createResp, err := createLogic.CreateUser(&types.CreateUserRequest{
		Username: "update_role_test",
		Email:    "update_role@example.com",
		Password: "password123",
	})
	require.NoError(t, err)
	assert.Equal(t, "user", createResp.Role)

	// 更新角色
	updateLogic := NewUpdateUserLogic(ctx, svcCtx)
	resp, err := updateLogic.UpdateUser(&types.UpdateUserRequest{
		Id:     createResp.Id,
		Role:   "admin",
		Remark: "promoted",
	})

	require.NoError(t, err)
	require.NotNil(t, resp)
	assert.Equal(t, "admin", resp.Role)
	assert.Equal(t, "promoted", resp.Remark)
	// Source 不应改变
	assert.Equal(t, "manual", resp.Source)
}

// TestFindOneByRole 测试 FindOneByRole 方法
func TestFindOneByRole(t *testing.T) {
	svcCtx, cleanup := setupUserTestDB(t)
	defer cleanup()

	ctx := context.Background()

	// 创建 super_admin 用户
	adminUser := &model.User{
		Username: "find_role_admin",
		Email:    "find_role_admin@example.com",
		Password: "hashed",
		Role:     model.RoleSuperAdmin,
		Source:   model.SourceSystem,
		Status:   1,
	}
	_, err := model.Insert(ctx, svcCtx.DB, adminUser)
	require.NoError(t, err)

	// 查找 super_admin
	found, err := model.FindOneByRole(ctx, svcCtx.DB, model.RoleSuperAdmin)
	require.NoError(t, err)
	require.NotNil(t, found)
	assert.Equal(t, model.RoleSuperAdmin, found.Role)
	assert.Equal(t, "find_role_admin", found.Username)

	// 查找不存在的角色
	_, err = model.FindOneByRole(ctx, svcCtx.DB, "nonexistent")
	assert.ErrorIs(t, err, model.ErrNotFound)
}