//package com.backendsys.service.System;
//
//import cn.hutool.core.convert.Convert;
//import com.backendsys.utils.UserUtils;
//import com.backendsys.utils.MD5Util;
//import com.github.pagehelper.PageHelper;
//import com.backendsys.entity.System.SysUserDTO;
//import com.backendsys.mapper.System.SysUserMapper;
//import com.backendsys.utils.response.PageInfoResult;
//
//import org.redisson.api.RLock;
//import org.redisson.api.RedissonClient;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.beans.factory.annotation.Value;
//import org.springframework.context.annotation.Lazy;
//import org.springframework.data.redis.core.RedisTemplate;
//import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//
//import java.security.NoSuchAlgorithmException;
//import java.util.*;
//import java.util.concurrent.TimeUnit;
//import java.util.stream.Collectors;
//
//@Service
//public class SysUserServiceImpl implements SysUserService {
//
//    @Value("${REDIS_LOGIN_TOKEN_PREFIX}")
//    private String REDIS_LOGIN_TOKEN_PREFIX;
//
//    @Lazy
//    @Autowired
//    RedissonClient redissonClient;
//    @Autowired
//    private RedisTemplate redisTemplate;
//    @Autowired
//    private SysUserMapper sysUserMapper;
//
//    /**
//     * 查询 系统用户列表
//     */
//    @Override
//    public Map<String, Object> queryUserList(Integer pageNum, Integer pageSize, SysUserDTO sysUserDTO) {
//        // 分页查询
//        if (pageNum != null && pageSize != null) {
//            PageHelper.startPage(pageNum, pageSize);
//        }
//        // 分页输出 (自定义)
//        List<Map<String, Object>> list = sysUserMapper.queryUserList(sysUserDTO);
//        PageInfoResult pageInfoResult = new PageInfoResult(list);
//        return pageInfoResult.toMap();
//    }
//
//    /**
//     * 查询 系统用户列表 (在线)
//     */
//    @Override
//    public List<Map<String, Object>> queryUserWithLogined(Integer pageNum, Integer pageSize, SysUserDTO sysUserDTO) {
//        // 分页查询
//        if (pageNum != null && pageSize != null) {
//            PageHelper.startPage(pageNum, pageSize);
//        }
//
//        // 获得用户最后登录的UUID
//        Set redisKeys = redisTemplate.keys("token:*");
//        // 获得UUID数组
//        Set last_login_uuids = (Set) redisKeys.stream().map(
//            e -> String.valueOf(e).replace(REDIS_LOGIN_TOKEN_PREFIX, "")
//        ).collect(Collectors.toSet());
//
//        return sysUserMapper.queryUserWithLogined(last_login_uuids);
//    }
//
//    /**
//     * 查询 系统用户详情
//     */
//    @Override
//    public Map<String, Object> queryUserById(Long user_id) {
//        Map<String, Object> sysUser = sysUserMapper.queryUserDetail(user_id);
//        if (sysUser == null) { return null; }
//
//        // 原格式 roles: [{ id, module_name, module_codes: "sy:userRole:update,sy:userRole:create"
//        // [格式化] 输出 modules: ["sy:userRole:update", "sy:userRole:create"]
//        List<Map<String, Object>> roles = (List<Map<String, Object>>) sysUser.get("roles");
//        sysUser.put("modules", UserUtils.extractModuleCodes(roles));
//
//        // [格式化] 输出 roles: [{ id, module_name }]
//        roles.forEach(role -> role.remove("module_ids"));
//        sysUser.put("roles", roles);
//
//        // [格式化] 输出 role_ids: [1, 2]
//        List<Long> role_ids = roles.stream().map(role -> (Long) role.get("id")).collect(Collectors.toList());
//        sysUser.put("role_id", role_ids);
//
//        return sysUser;
//    }
//
//
//
//
//    /**
//     * 创建 系统用户
//     * @param sysUserDTO
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> insertUser(SysUserDTO sysUserDTO) {
//
//        //// 如果可以获得当前 token 的 id，那以后创建分布式锁时，可以按照 userId 来创建锁
//        //System.out.println("tokenService.getLoginUUID() = " + tokenService.getLoginUUID());
//
//        RLock lock = redissonClient.getLock("insertUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 密码二次加密
//            String password = sysUserDTO.getPassword();
//            BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
//            String encodedPassword = encoder.encode(password);
//            sysUserDTO.setPassword(encodedPassword);
//
//            // 获取参数，并将 [1,2] 转换为 [{ id: 1 }, { id: 2 }]
//            List<Long> role_id = sysUserDTO.getRole_id();
//            List<LinkedHashMap<String,Object>> convertedList = role_id.stream()
//                .map(id -> {
//                    LinkedHashMap<String,Object> map = new LinkedHashMap<>();
//                    map.put("id", id);
//                    return map;
//                })
//                .collect(Collectors.toList());
//            sysUserDTO.setRoles(convertedList);
//            // ------------------------------------------------------
//
//            sysUserMapper.insertUser(sysUserDTO);
//            return Map.of("user_id", sysUserDTO.getId());
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 更新 系统用户信息
//     * @param sysUserDTO
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> updateUserInfo(SysUserDTO sysUserDTO) {
//        RLock lock = redissonClient.getLock("updateUserInfo");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 当 status 状态为 -1(禁用) 时，同时清除登录状态
//            Integer status = sysUserDTO.getStatus();
//            if (status != null && status == -1) {
//                String last_login_uuid = sysUserDTO.getLast_login_uuid();
//                redisTemplate.delete(REDIS_LOGIN_TOKEN_PREFIX + last_login_uuid);
//                sysUserDTO.setLast_login_uuid("");
//            }
//
//            // 获取参数，并将 [1,2] 转换为 [{ id: 1 }, { id: 2 }]
//            List<Long> role_id = sysUserDTO.getRole_id();
//            if (role_id != null && role_id.size() > 0) {
//                List<LinkedHashMap<String, Object>> convertedList = role_id.stream()
//                        .map(id -> {
//                            LinkedHashMap<String, Object> map = new LinkedHashMap<>();
//                            map.put("id", id);
//                            return map;
//                        })
//                        .collect(Collectors.toList());
//                sysUserDTO.setRoles(convertedList);
//            }
//            // ------------------------------------------------------
//
//            // 更新
//            sysUserMapper.updateUserInfo(sysUserDTO);
//            return Map.of("user_id", sysUserDTO.getUser_id());
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 审核 系统用户
//     * @param sysUserDTO
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> auditUser(SysUserDTO sysUserDTO) {
//        RLock lock = redissonClient.getLock("auditUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            sysUserMapper.auditUser(sysUserDTO);
//            return Map.of("user_id", sysUserDTO.getUser_id());
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//
//    /**
//     * 删除 系统用户 (物理删除)
//     * @param id
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> deleteUser(Long id) {
//        RLock lock = redissonClient.getLock("deleteUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 删除前，清除登录状态
//            Map<String, Object> sysUser = sysUserMapper.queryUserDetail(id);
////            String last_login_uuid = (String) sysUser.get("last_login_uuid");
//            String last_login_uuid = Convert.toStr(sysUser.get("last_login_uuid"));
//            redisTemplate.delete(REDIS_LOGIN_TOKEN_PREFIX + last_login_uuid);
//
//            sysUserMapper.deleteUser(id);
//            return Map.of("user_id", id);
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 删除 系统用户 (批量)
//     * @param ids
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> deleteUserBatch(List<Long> ids) {
//        RLock lock = redissonClient.getLock("deleteUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 删除前，清除登录状态 (这里的查询需要优化一下，使用批量查询)
//            List<Map<String, Object>> uuids = sysUserMapper.queryUserUUIDSByIds(ids);
//            for (Map<String, Object> uuidMap : uuids) {
//                if (uuidMap != null && uuidMap.containsKey("last_login_uuid")) {
//                    String last_login_uuid = (String) uuidMap.get("last_login_uuid");
//                    if (last_login_uuid != null && !last_login_uuid.isEmpty()) {
//                        // 这里忽略清除 userInfo 的 last_login_uuid 字段，因为要删除了
//                        redisTemplate.delete(REDIS_LOGIN_TOKEN_PREFIX + last_login_uuid);
//                    }
//                }
//            }
//
//            sysUserMapper.deleteUserBatch(ids);
//            return Map.of("user_ids", ids);
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//
//    /**
//     * 删除 系统用户 (逻辑删除)
//     * @param id
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> deactivateUser(Long id) {
//        RLock lock = redissonClient.getLock("deactivateUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 删除前，清除登录状态
//            Map<String, Object> sysUser = sysUserMapper.queryUserDetail(id);
////            String last_login_uuid = (String) sysUser.get("last_login_uuid");
//            String last_login_uuid = Convert.toStr(sysUser.get("last_login_uuid"));
//            redisTemplate.delete(REDIS_LOGIN_TOKEN_PREFIX + last_login_uuid);
//
//            sysUserMapper.deactivateUser(id);
//            return Map.of("user_id", id);
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 查询用户密码
//     * @param id
//     * @return
//     */
//    @Override
//    public Map<String, Object> queryUserPassword(Long id) {
//        return sysUserMapper.queryUserPassword(id);
//    }
//
//    /**
//     * 更新 系统用户密码 (自身)
//     * @param sysUserDTO
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> updateUserPasswordSelf(SysUserDTO sysUserDTO) {
//        RLock lock = redissonClient.getLock("updateUserPasswordSelf");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 密码二次加密
//            String password = sysUserDTO.getPassword();
//            BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
//            String encodedPassword = encoder.encode(password);
//            sysUserDTO.setPassword(encodedPassword);
//            //
//            sysUserMapper.updateUserPassword(sysUserDTO);
//            return Map.of("user_id", sysUserDTO.getUser_id());
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 更新 重置用户密码 (超级管理员)
//     * @param sysUserDTO
//     * @return { user_id }
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> resetUserPassword(SysUserDTO sysUserDTO) throws NoSuchAlgorithmException {
//        RLock lock = redissonClient.getLock("resetUserPassword");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            // 生成一个六位的随机数密码
//            String uuid = UUID.randomUUID().toString().replace("-", "");
//            String password = uuid.substring(0, 6);
//            // MD5加密
//            String md5Password = MD5Util.encrypt(password);
//            // 加盐加密
//            BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
//            String encodedPassword = encoder.encode(md5Password);
//            sysUserDTO.setPassword(encodedPassword);
//            //
//            sysUserMapper.updateUserPassword(sysUserDTO);
//            Map<String, Object> response = new LinkedHashMap<>();
//            response.put("user_id", sysUserDTO.getUser_id());
//            response.put("plain_password", password);
//            return response;
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//    /**
//     * 踢出用户 (下线)
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> kickUser(Long user_id) {
//        RLock lock = redissonClient.getLock("kickUser");
//        try { lock.tryLock(3, TimeUnit.SECONDS);
//
//            Map<String, Object> sysUser = sysUserMapper.queryUserDetail(user_id);
//            if (sysUser.isEmpty()) { return null; }
//
//            // 清除 info 表中的 last_login_uuid 信息 (注意：至少要有一个值，不能全部是 null，否则报错)
//            SysUserDTO sysUserDTO = new SysUserDTO();
//            sysUserDTO.setUser_id(user_id);
//            // sysUserDTO.setNickname((String) sysUser.get("nickname"));
//            sysUserDTO.setLast_login_uuid("");
//            sysUserMapper.updateUserInfo(sysUserDTO);
//
//            // 清除 Redis 登录信息
////            String last_login_uuid = (String) sysUser.get("last_login_uuid");
//            String last_login_uuid = Convert.toStr(sysUser.get("last_login_uuid"));
//            if (!last_login_uuid.isEmpty()) {
//                redisTemplate.delete(REDIS_LOGIN_TOKEN_PREFIX + last_login_uuid);
//                return Map.of("user_id", user_id);
//            } else {
//                return Map.of("user_id", null);
//            }
//
//        } catch (InterruptedException e) { throw new RuntimeException(e);
//        } finally { lock.unlock(); }
//    }
//
//}
