package com.ygtx.system.service.impl;

import java.util.*;
import java.util.stream.Collectors;
import javax.validation.Validator;

import net.sourceforge.pinyin4j.format.HanyuPinyinCaseType;
import net.sourceforge.pinyin4j.format.HanyuPinyinOutputFormat;
import net.sourceforge.pinyin4j.format.HanyuPinyinToneType;
import net.sourceforge.pinyin4j.format.exception.BadHanyuPinyinOutputFormatCombination;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import com.ygtx.common.annotation.DataScope;
import com.ygtx.common.constant.UserConstants;
import com.ygtx.common.core.domain.entity.SysDept;
import com.ygtx.common.core.domain.entity.SysRole;
import com.ygtx.common.core.domain.entity.SysUser;
import com.ygtx.common.exception.ServiceException;
import com.ygtx.common.utils.SecurityUtils;
import com.ygtx.common.utils.StringUtils;
import com.ygtx.common.utils.bean.BeanValidators;
import com.ygtx.common.utils.spring.SpringUtils;
import com.ygtx.common.core.domain.entity.UserDeptPost;
import net.sourceforge.pinyin4j.PinyinHelper;
import com.ygtx.system.domain.SysPost;
import com.ygtx.system.domain.SysUserDept;
import com.ygtx.system.domain.SysUserPost;
import com.ygtx.system.domain.SysUserRole;
import com.ygtx.system.mapper.SysPostMapper;
import com.ygtx.system.mapper.SysRoleMapper;
import com.ygtx.system.mapper.SysUserMapper;
import com.ygtx.system.mapper.SysUserPostMapper;
import com.ygtx.system.mapper.SysUserRoleMapper;
import com.ygtx.system.service.ISysConfigService;
import com.ygtx.system.service.ISysDeptService;
import com.ygtx.system.service.ISysPostService;
import com.ygtx.system.service.ISysRoleService;
import com.ygtx.system.service.ISysUserService;

/**
 * 用户 业务层处理
 *
 * @author ruoyi
 */
@Service
public class SysUserServiceImpl implements ISysUserService
{
    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);

    @Autowired
    private SysUserMapper userMapper;

    @Autowired
    private SysRoleMapper roleMapper;

    @Autowired
    private SysPostMapper postMapper;

    @Autowired
    private SysUserRoleMapper userRoleMapper;

    @Autowired
    private SysUserPostMapper userPostMapper;

    @Autowired
    private ISysConfigService configService;

    @Autowired
    private ISysDeptService deptService;

    @Autowired
    private ISysPostService postService;

    @Autowired
    private ISysRoleService roleService;

    @Autowired
    protected Validator validator;

    /**
     * 根据条件分页查询用户列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<SysUser> selectUserList(SysUser user)
    {
        List<SysUser> userList = userMapper.selectUserList(user);
        // 为导出功能加载角色和岗位信息
        if (userList != null && !userList.isEmpty()) {
            for (SysUser sysUser : userList) {
                // 加载角色信息
                List<SysRole> roles = roleMapper.selectRolePermissionByUserId(sysUser.getUserId());
                sysUser.setRoles(roles);
                // 设置角色名称用于导出
                if (roles != null && !roles.isEmpty()) {
                    StringBuilder roleNames = new StringBuilder();
                    for (int i = 0; i < roles.size(); i++) {
                        if (i > 0) {
                            roleNames.append(",");
                        }
                        roleNames.append(roles.get(i).getRoleName());
                    }
                    sysUser.setRoleNames(roleNames.toString());
                }

                // 加载岗位信息（从主岗位表获取）
                List<SysPost> posts = postService.selectPostsByUserId(sysUser.getUserId());
                // 设置岗位名称用于导出
                if (posts != null && !posts.isEmpty()) {
                    StringBuilder postNames = new StringBuilder();
                    for (int i = 0; i < posts.size(); i++) {
                        if (i > 0) {
                            postNames.append(",");
                        }
                        postNames.append(posts.get(i).getPostName());
                    }
                    sysUser.setPostNames(postNames.toString());
                }
            }
        }
        return userList;
    }

    public List<SysUser> selectUserListNoDataScope(SysUser user)
    {
        return userMapper.selectUserList(user);
    }

    @Override
    public List<SysUser> selectUserListByDeptId(SysUser user)
    {
        return userMapper.selectUserListByDeptId(user);
    }

    /**
     * 根据条件分页查询已分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<SysUser> selectAllocatedList(SysUser user)
    {
        return userMapper.selectAllocatedList(user);
    }

    /**
     * 根据条件分页查询未分配用户角色列表
     *
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<SysUser> selectUnallocatedList(SysUser user)
    {
        return userMapper.selectUnallocatedList(user);
    }

    /**
     * 通过用户名查询用户
     *
     * @param userName 用户名
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserByUserName(String userName)
    {
        return userMapper.selectUserByUserName(userName);
    }

    /**
     * 通过用户ID查询用户
     *
     * @param userId 用户ID
     * @return 用户对象信息
     */
    @Override
    public SysUser selectUserById(Long userId)
    {
        SysUser user = userMapper.selectUserById(userId);
        if (user != null) {
            // 加载用户的部门岗位信息
            List<UserDeptPost> userDeptPosts = userMapper.selectUserDeptPostsByUserId(userId);
            // 过滤掉无效的数据
            if (userDeptPosts != null) {
                userDeptPosts = userDeptPosts.stream()
                    .filter(udp -> udp != null && udp.getDeptId() != null && udp.getPostId() != null)
                    .collect(Collectors.toList());
            }
            user.setUserDeptPosts(userDeptPosts);
        }
        return user;
    }

    /**
     * 通过用户昵称查询用户列表
     *
     * @param nickName 用户昵称
     * @return 用户对象信息集合
     */
    @Override
    public List<SysUser> selectUserByNickName(String nickName)
    {
        return userMapper.selectUserByNickName(nickName);
    }

    /**
     * 查询用户所属角色组
     *
     * @param userName 用户名
     * @return 结果
     */
    @Override
    public String selectUserRoleGroup(String userName)
    {
        List<SysRole> list = roleMapper.selectRolesByUserName(userName);
        if (CollectionUtils.isEmpty(list))
        {
            return StringUtils.EMPTY;
        }
        return list.stream().map(SysRole::getRoleName).collect(Collectors.joining(","));
    }

    /**
     * 查询用户所属岗位组
     *
     * @param userName 用户名
     * @return 结果
     */
    @Override
    public String selectUserPostGroup(String userName)
    {
        List<SysPost> list = postMapper.selectPostsByUserName(userName);
        if (CollectionUtils.isEmpty(list))
        {
            return StringUtils.EMPTY;
        }
        return list.stream().map(SysPost::getPostName).collect(Collectors.joining(","));
    }

    /**
     * 校验用户名称是否唯一
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public boolean checkUserNameUnique(SysUser user)
    {
        Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
        SysUser info = userMapper.checkUserNameUnique(user.getUserName());
        if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验手机号码是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public boolean checkPhoneUnique(SysUser user)
    {
        Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
        SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
        if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验email是否唯一
     *
     * @param user 用户信息
     * @return
     */
    @Override
    public boolean checkEmailUnique(SysUser user)
    {
        Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
        SysUser info = userMapper.checkEmailUnique(user.getEmail());
        if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue())
        {
            return UserConstants.NOT_UNIQUE;
        }
        return UserConstants.UNIQUE;
    }

    /**
     * 校验用户是否允许操作
     *
     * @param user 用户信息
     */
    @Override
    public void checkUserAllowed(SysUser user)
    {
        if (StringUtils.isNotNull(user.getUserId()) && user.isAdmin())
        {
            throw new ServiceException("不允许操作超级管理员用户");
        }
    }

    /**
     * 校验用户是否有数据权限
     *
     * @param userId 用户id
     */
    @Override
    public void checkUserDataScope(Long userId)
    {
        if (!SysUser.isAdmin(SecurityUtils.getUserId()))
        {
            SysUser user = new SysUser();
            user.setUserId(userId);
            List<SysUser> users = SpringUtils.getAopProxy(this).selectUserList(user);
            if (StringUtils.isEmpty(users))
            {
                throw new ServiceException("没有权限访问用户数据！");
            }
        }
    }

    /**
     * 新增保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    public int insertUser(SysUser user)
    {
        // 新增用户信息
        int rows = userMapper.insertUser(user);
        // 新增用户岗位关联
        insertUserPost(user);
        // 新增用户与角色管理
        insertUserRole(user);
        return rows;
    }

    /**
     * 注册用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public boolean registerUser(SysUser user)
    {
        return userMapper.insertUser(user) > 0;
    }

    /**
     * 修改保存用户信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    @Transactional
    public int updateUser(SysUser user)
    {
        Long userId = user.getUserId();
        // 删除用户与角色关联
        userRoleMapper.deleteUserRoleByUserId(userId);
        // 新增用户与角色管理
        insertUserRole(user);
        // 删除用户与岗位关联
        userPostMapper.deleteUserPostByUserId(userId);
        // 新增用户与岗位管理
        insertUserPost(user);
        return userMapper.updateUser(user);
    }

    /**
     * 用户授权角色
     *
     * @param userId 用户ID
     * @param roleIds 角色组
     */
    @Override
    @Transactional
    public void insertUserAuth(Long userId, Long[] roleIds)
    {
        userRoleMapper.deleteUserRoleByUserId(userId);
        insertUserRole(userId, roleIds);
    }

    /**
     * 修改用户状态
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserStatus(SysUser user)
    {
        return userMapper.updateUserStatus(user.getUserId(), user.getStatus());
    }

    /**
     * 修改用户基本信息
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int updateUserProfile(SysUser user)
    {
        return userMapper.updateUser(user);
    }

    /**
     * 修改用户头像
     *
     * @param userId 用户ID
     * @param avatar 头像地址
     * @return 结果
     */
    @Override
    public boolean updateUserAvatar(Long userId, String avatar)
    {
        return userMapper.updateUserAvatar(userId, avatar) > 0;
    }

    /**
     * 更新用户登录信息（IP和登录时间）
     *
     * @param userId 用户ID
     * @param loginIp 登录IP地址
     * @param loginDate 登录时间
     * @return 结果
     */
    public void updateLoginInfo(Long userId, String loginIp, Date loginDate)
    {
        userMapper.updateLoginInfo(userId, loginIp, loginDate);
    }

    /**
     * 重置用户密码
     *
     * @param user 用户信息
     * @return 结果
     */
    @Override
    public int resetPwd(SysUser user)
    {
        return userMapper.resetUserPwd(user.getUserId(), user.getPassword());
    }

    /**
     * 重置用户密码
     *
     * @param userId 用户ID
     * @param password 密码
     * @return 结果
     */
    @Override
    public int resetUserPwd(Long userId, String password)
    {
        return userMapper.resetUserPwd(userId, password);
    }

    /**
     * 新增用户角色信息
     *
     * @param user 用户对象
     */
    public void insertUserRole(SysUser user)
    {
        this.insertUserRole(user.getUserId(), user.getRoleIds());
    }

    /**
     * 新增用户角色信息
     *
     * @param userId 用户ID
     * @param roleIds 角色组
     */
    public void insertUserRole(Long userId, Long[] roleIds)
    {
        if (StringUtils.isNotEmpty(roleIds))
        {
            // 新增用户与角色管理
            List<SysUserRole> list = new ArrayList<SysUserRole>(roleIds.length);
            for (Long roleId : roleIds)
            {
                // 检查角色是否存在
                try {
                    SysRole role = roleService.selectRoleById(roleId);
                    if (role != null) {
                        SysUserRole ur = new SysUserRole();
                        ur.setUserId(userId);
                        ur.setRoleId(roleId);
                        list.add(ur);
                    } else {
                        log.warn("角色不存在，角色ID: {}, 用户ID: {}", roleId, userId);
                    }
                } catch (Exception e) {
                    // 角色不存在，跳过
                    log.warn("角色ID {} 不存在，跳过关联", roleId);
                }
            }
            if (!list.isEmpty()) {
                log.info("准备保存用户角色关联，用户ID: {}, 角色数量: {}", userId, list.size());
                int result = userRoleMapper.batchUserRole(list);
                log.info("用户角色关联保存结果，用户ID: {}, 保存数量: {}", userId, result);
            } else {
                log.info("没有有效的角色关联需要保存，用户ID: {}", userId);
            }
        } else {
            log.info("用户没有角色信息需要保存，用户ID: {}", userId);
        }
    }

    /**
     * 新增用户岗位信息
     *
     * @param user 用户对象
     */
    public void insertUserPost(SysUser user)
    {
        Long[] posts = user.getPostIds();
        if (StringUtils.isNotEmpty(posts))
        {
            // 新增用户与岗位管理
            List<SysUserPost> list = new ArrayList<SysUserPost>(posts.length);
            for (Long postId : posts)
            {
                // 检查岗位是否存在
                try {
                    SysPost post = postService.selectPostById(postId);
                    if (post != null) {
                        SysUserPost up = new SysUserPost();
                        up.setUserId(user.getUserId());
                        up.setPostId(postId);
                        list.add(up);
                    } else {
                        log.warn("岗位不存在，岗位ID: {}, 用户ID: {}", postId, user.getUserId());
                    }
                } catch (Exception e) {
                    // 岗位不存在，跳过
                    log.warn("岗位ID {} 不存在，跳过关联", postId);
                }
            }
            if (!list.isEmpty()) {
                log.info("准备保存用户岗位关联，用户ID: {}, 岗位数量: {}", user.getUserId(), list.size());
                int result = userPostMapper.batchUserPost(list);
                log.info("用户岗位关联保存结果，用户ID: {}, 保存数量: {}", user.getUserId(), result);
            } else {
                log.info("没有有效的岗位关联需要保存，用户ID: {}", user.getUserId());
            }
        } else {
            log.info("用户没有岗位信息需要保存，用户ID: {}", user.getUserId());
        }
    }

    /**
     * 通过用户ID删除用户
     *
     * @param userId 用户ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteUserById(Long userId)
    {
        // 删除用户与角色关联
        userRoleMapper.deleteUserRoleByUserId(userId);
        // 删除用户与岗位表
        userPostMapper.deleteUserPostByUserId(userId);
        return userMapper.deleteUserById(userId);
    }

    /**
     * 批量删除用户信息
     *
     * @param userIds 需要删除的用户ID
     * @return 结果
     */
    @Override
    @Transactional
    public int deleteUserByIds(Long[] userIds)
    {
        for (Long userId : userIds)
        {
            checkUserAllowed(new SysUser(userId));
            checkUserDataScope(userId);
        }
        // 删除用户与角色关联
        userRoleMapper.deleteUserRole(userIds);
        // 删除用户与岗位关联
        userPostMapper.deleteUserPost(userIds);
        return userMapper.deleteUserByIds(userIds);
    }

    /**
     * 导入用户数据
     *
     * @param userList 用户数据列表
     * @param isUpdateSupport 是否更新支持，如果已存在，则进行更新数据
     * @param operName 操作用户
     * @return 结果
     */
    @Override
    public String importUser(List<SysUser> userList, Boolean isUpdateSupport, String operName)
    {
        if (StringUtils.isNull(userList) || userList.size() == 0)
        {
            throw new ServiceException("导入用户数据不能为空！");
        }
        int successNum = 0;
        int failureNum = 0;
        int partialSuccessNum = 0;
        StringBuilder successMsg = new StringBuilder();
        StringBuilder failureMsg = new StringBuilder();
        StringBuilder partialSuccessMsg = new StringBuilder();
        for (SysUser user : userList)
        {
            try
            {
                // 通过部门名称查找部门ID
                if (StringUtils.isNotEmpty(user.getDeptName())) {
                    SysDept dept = deptService.selectDeptByDeptName(user.getDeptName());
                    if (dept != null) {
                        user.setDeptId(dept.getDeptId());
                    }
                }

                // 通过角色名称查找角色ID
                if (StringUtils.isNotEmpty(user.getRoleNames())) {
                    String[] roleNames = user.getRoleNames().split(",");
                    List<Long> roleIds = new ArrayList<>();
                    for (String roleName : roleNames) {
                        roleName = roleName.trim();
                        if (StringUtils.isNotEmpty(roleName)) {
                            SysRole role = roleService.selectRoleByRoleName(roleName);
                            if (role != null) {
                                roleIds.add(role.getRoleId());
                            }
                        }
                    }
                    if (!roleIds.isEmpty()) {
                        user.setRoleIds(roleIds.toArray(new Long[0]));
                    }
                }

                // 通过岗位名称查找岗位ID
                if (StringUtils.isNotEmpty(user.getPostNames())) {
                    String[] postNames = user.getPostNames().split(",");
                    List<Long> postIds = new ArrayList<>();
                    for (String postName : postNames) {
                        postName = postName.trim();
                        if (StringUtils.isNotEmpty(postName)) {
                            SysPost post = postService.selectPostByPostName(postName);
                            if (post != null) {
                                postIds.add(post.getPostId());
                            }
                        }
                    }
                    if (!postIds.isEmpty()) {
                        user.setPostIds(postIds.toArray(new Long[0]));
                    }
                }

                // 验证是否存在这个用户
                SysUser u = userMapper.selectUserByUserName(user.getUserName());
                if (StringUtils.isNull(u))
                {
                    BeanValidators.validateWithException(validator, user);
                    String password = configService.selectConfigByKey("sys.user.initPassword");
                    user.setPassword(SecurityUtils.encryptPassword(password));
                    user.setCreateBy(operName);

                    // 检查部门是否存在，如果不存在则记录警告但继续导入
                    boolean deptExists = true;
                    if (user.getDeptId() != null) {
                        try {
                            deptService.checkDeptDataScope(user.getDeptId());
                        } catch (Exception e) {
                            deptExists = false;
                            partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 部门信息未找到");
                        }
                    }

                    // 插入用户
                    userMapper.insertUser(user);
                    successNum++;

                    // 确保用户ID已被正确设置
                    if (user.getUserId() == null) {
                        log.error("用户插入后ID为空，用户名: {}", user.getUserName());
                        partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 用户ID为空");
                        partialSuccessNum++;
                    } else {
                        // 处理角色关联
                        boolean roleProcessed = true;
                        if (user.getRoleIds() != null && user.getRoleIds().length > 0) {
                            try {
                                insertUserRole(user);
                            } catch (Exception e) {
                                roleProcessed = false;
                                log.error("用户角色关联保存失败，用户名: " + user.getUserName(), e);
                                partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 角色信息未完全导入");
                            }
                        }

                        // 处理岗位关联
                        boolean postProcessed = true;
                        if (user.getPostIds() != null && user.getPostIds().length > 0) {
                            try {
                                insertUserPost(user);
                            } catch (Exception e) {
                                postProcessed = false;
                                log.error("用户岗位关联保存失败，用户名: " + user.getUserName(), e);
                                partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 岗位信息未完全导入");
                            }
                        }

                        if (!deptExists || !roleProcessed || !postProcessed) {
                            partialSuccessNum++;
                        }

                        if (deptExists && roleProcessed && postProcessed) {
                            successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 导入成功");
                        } else {
                            partialSuccessMsg.append("<br/>" + (partialSuccessNum) + "、账号 " + user.getUserName() + " 已导入，但部分信息缺失");
                        }
                    }
                }
                else if (isUpdateSupport)
                {
                    BeanValidators.validateWithException(validator, user);
                    checkUserAllowed(u);
                    checkUserDataScope(u.getUserId());
                    user.setUserId(u.getUserId());
                    user.setUpdateBy(operName);

                    // 检查部门是否存在
                    boolean deptExists = true;
                    if (user.getDeptId() != null) {
                        try {
                            deptService.checkDeptDataScope(user.getDeptId());
                        } catch (Exception e) {
                            deptExists = false;
                            partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 部门信息未找到");
                        }
                    }

                    // 更新用户
                    userMapper.updateUser(user);
                    successNum++;

                    // 处理角色关联
                    boolean roleProcessed = true;
                    if (user.getRoleIds() != null && user.getRoleIds().length > 0) {
                        try {
                            // 删除原有角色关联
                            userRoleMapper.deleteUserRoleByUserId(user.getUserId());
                            // 添加新角色关联
                            insertUserRole(user);
                        } catch (Exception e) {
                            roleProcessed = false;
                            log.error("用户角色关联更新失败，用户名: " + user.getUserName(), e);
                            partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 角色信息未完全更新");
                        }
                    }

                    // 处理岗位关联
                    boolean postProcessed = true;
                    if (user.getPostIds() != null && user.getPostIds().length > 0) {
                        try {
                            // 删除原有岗位关联
                            userPostMapper.deleteUserPostByUserId(user.getUserId());
                            // 添加新岗位关联
                            insertUserPost(user);
                        } catch (Exception e) {
                            postProcessed = false;
                            log.error("用户岗位关联更新失败，用户名: " + user.getUserName(), e);
                            partialSuccessMsg.append("<br/>" + (partialSuccessNum + 1) + "、账号 " + user.getUserName() + " 岗位信息未完全更新");
                        }
                    }

                    if (!deptExists || !roleProcessed || !postProcessed) {
                        partialSuccessNum++;
                    }

                    if (deptExists && roleProcessed && postProcessed) {
                        successMsg.append("<br/>" + successNum + "、账号 " + user.getUserName() + " 更新成功");
                    } else {
                        partialSuccessMsg.append("<br/>" + (partialSuccessNum) + "、账号 " + user.getUserName() + " 已更新，但部分信息缺失");
                    }
                }
                else
                {
                    failureNum++;
                    failureMsg.append("<br/>" + failureNum + "、账号 " + user.getUserName() + " 已存在");
                }
            }
            catch (Exception e)
            {
                failureNum++;
                String msg = "<br/>" + failureNum + "、账号 " + user.getUserName() + " 导入失败：";
                failureMsg.append(msg + e.getMessage());
                log.error(msg, e);
            }
        }
        StringBuilder resultMsg = new StringBuilder();
        if (successNum > 0)
        {
            resultMsg.append("成功导入完整用户 " + successNum + " 条，数据如下：");
            resultMsg.append(successMsg);
        }
        if (partialSuccessNum > 0)
        {
            if (resultMsg.length() > 0) {
                resultMsg.append("<br/><br/>");
            }
            resultMsg.append("成功导入但信息不完整用户 " + partialSuccessNum + " 条，数据如下：");
            resultMsg.append(partialSuccessMsg);
        }
        if (failureNum > 0)
        {
            if (resultMsg.length() > 0) {
                resultMsg.append("<br/><br/>");
            }
            resultMsg.append("导入失败 " + failureNum + " 条，错误如下：");
            resultMsg.append(failureMsg);
        }
        if (resultMsg.length() == 0) {
            resultMsg.append("没有数据被导入");
        }
        return resultMsg.toString();
    }

    /**
     * 通过用户ID查询用户部门岗位信息
     *
     * @param userId 用户ID
     * @return 用户部门岗位信息集合
     */
    @Override
    public List<UserDeptPost> selectUserDeptPostsByUserId(Long userId)
    {
        return userMapper.selectUserDeptPostsByUserId(userId);
    }

    /**
     * 批量新增用户部门岗位信息
     *
     * @param userId 用户ID
     * @param userDeptPosts 用户部门岗位信息集合
     * @return 结果
     */
    @Override
    @Transactional
    public int insertUserDeptPosts(Long userId, List<UserDeptPost> userDeptPosts)
    {
        // 删除用户原有的部门岗位关联
        userMapper.deleteUserDeptByUserId(userId);

        // 新增用户部门岗位关联
        if (StringUtils.isNotEmpty(userDeptPosts))
        {
            List<SysUserDept> list = new ArrayList<SysUserDept>();
            for (UserDeptPost udp : userDeptPosts)
            {
                // 确保必要的字段不为null
                if (udp.getDeptId() != null && udp.getPostId() != null) {
                    SysUserDept sud = new SysUserDept();
                    sud.setUserId(userId);
                    sud.setDeptId(udp.getDeptId());
                    sud.setPostId(udp.getPostId());
                    sud.setIsMain(udp.getIsMain() != null ? udp.getIsMain() : "0");
                    list.add(sud);
                }
            }
            if (!list.isEmpty()) {
                return userMapper.batchUserDept(list);
            }
        }
        // 即使没有插入新记录，也返回1表示操作成功（删除旧记录成功）
        return 1;
    }

    @Override
    public List<SysUser> selectUserListNoPermi(SysUser user) {
        if(user.getDeptId() < 0){
            //配置要查找的部门及以下人员
            String leaderSelDept = configService.selectConfigByKey("gxt.leader.selDept");
            if(StringUtils.isNotEmpty(leaderSelDept)){
                user.setDeptId(Long.parseLong(leaderSelDept));
            }
        }
        List<SysUser> userList = userMapper.selectUserList(user);
        // 创建拼音格式配置（可复用，建议提为 static final）
        HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
        format.setCaseType(HanyuPinyinCaseType.LOWERCASE);      // 小写
        format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);  // 无声调

        // 3. 按部门分组（保持原始顺序），组内按昵称拼音排序
        Map<Long, List<SysUser>> groupedByDeptId = new LinkedHashMap<>(); // 保持插入顺序

        for (SysUser u : userList) {
            Long deptId = u.getDeptId();
            if (deptId == null) deptId = -1L; // 处理 null 部门
            groupedByDeptId.computeIfAbsent(deptId, k -> new ArrayList<>()).add(u);
        }

        // 4. 对每个部门内的用户按昵称拼音排序
        for (List<SysUser> usersInDept : groupedByDeptId.values()) {
            usersInDept.sort(Comparator.comparing(
                    u -> getPinyin(u.getNickName(), format)
            ));
        }

        // 5. 合并回原顺序的列表
        List<SysUser> result = new ArrayList<>();
        for (List<SysUser> usersInDept : groupedByDeptId.values()) {
            result.addAll(usersInDept);
        }

        return result;
    }

    @Override
    public SysUser selectDelUserByUserName(String userName) {
        return userMapper.selectDelUserByUserName(userName);
    }

    @Override
    public int updateUserName(SysUser user) {
        return userMapper.updateUserName(user);
    }

    /**
     * 将中文字符串转换为无空格、无音调的全拼（如 "张三" → "zhangsan"）
     */
    private String getPinyin(String chinese, HanyuPinyinOutputFormat format) {
        if (chinese == null || chinese.trim().isEmpty()) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        char[] chars = chinese.toCharArray();

        for (char c : chars) {
            // 判断是否是汉字（避免对英文/数字做拼音转换）
            if (c >= '\u4e00' && c <= '\u9fa5') {
                try {
                    String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray(c, format);
                    if (pinyinArray != null && pinyinArray.length > 0) {
                        sb.append(pinyinArray[0]); // 取第一个读音（多音字默认）
                    } else {
                        sb.append(c); // 转换失败，保留原字符
                    }
                } catch (BadHanyuPinyinOutputFormatCombination e) {
                    sb.append(c); // 异常时保留原字符
                }
            } else {
                // 非汉字（如字母、数字、符号）直接追加
                sb.append(c);
            }
        }

        return sb.toString().toLowerCase(); // 再次确保小写（保险）
    }

    @Override
    public List<SysUser> selectUserListByPostIds(List<Long> postIds) {
        return userMapper.selectUserListByPostIds(postIds);
    }
}
