package com.monkeylessey.sys.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.monkeylessey.constant.RedisKeyPrefixConstants;
import com.monkeylessey.sys.domain.entity.*;
import com.monkeylessey.sys.domain.form.ResetPwdForm;
import com.monkeylessey.sys.domain.form.SysUserForm;
import com.monkeylessey.sys.domain.form.SysUserStatusForm;
import com.monkeylessey.sys.domain.query.SysUserQuery;
import com.monkeylessey.sys.domain.vo.SysMenuVO;
import com.monkeylessey.sys.domain.vo.SysUserVO;
import com.monkeylessey.sys.domain.vo.UserRolePermissionVO;
import com.monkeylessey.enums.general.MenuTypeEnum;
import com.monkeylessey.enums.general.StatusEnum;
import com.monkeylessey.enums.general.UserStatusEnum;
import com.monkeylessey.exception.ServiceException;
import com.monkeylessey.sys.mapper.*;
import com.monkeylessey.response.Result;
import com.monkeylessey.sys.service.SysUserService;
import com.monkeylessey.framework.utils.RedisUtil;
import com.monkeylessey.framework.utils.SecurityUtil;
import com.monkeylessey.utils.PageUtil;
import com.monkeylessey.utils.TreeUtil;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 系统用户 服务实现类
 *
 * @author 向培
 * @since 2022-05-30
 */
@Service
@RequiredArgsConstructor
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements SysUserService {

    private final SysUserMapper sysUserMapper;
    private final SysMenuMapper sysMenuMapper;
    private final SysRoleMenuMapper roleMenuMapper;
    private final SysRoleMapper roleMapper;
    private final RedisUtil redisUtil;
    private final PasswordEncoder passwordEncoder;
    private final SysOrgMapper sysOrgMapper;

    @Override
    public Result addSysUser(SysUserForm form) {
        SysUser entity = SysUserForm.getSysUser(null, form);
        // 加密密码
        entity.setPassword(passwordEncoder.encode(form.getPassword()));
        // 默认禁用
        entity.setStatus(UserStatusEnum.INACTIVE);
        String s = SecurityUtil.getCurrentUserName();
        entity.setCreateBy(s);
        try {
            if (baseMapper.insert(entity) > 0) {
                return Result.ok("添加成功");
            }
            return Result.error("添加失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("添加失败");
        }
    }

    @Override
    public Result editSysUser(SysUserForm form) {
        SysUser user = baseMapper.selectById(form.getId());
        if (Objects.isNull(user)) {
            return Result.error("修改用户不存在");
        }
        SysUser entity = SysUserForm.getSysUser(user, form);
        String s = SecurityUtil.getCurrentUserName();
        entity.setUpdateBy(s);
        baseMapper.updateById(entity);
        SysUserVO vo = SysUserVO.getVoByEntity(entity, null);
        vo.setPassword("");
        return Result.ok("修改成功").data(vo);
    }

    @Override
    public Result deleteSysUserById(String id) {
        try {
            if (baseMapper.deleteById(id) > 0) {
                return Result.ok("删除成功");
            }
            return Result.error("删除失败");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败");
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteSysUserByIds(List<String> ids) {
        if (baseMapper.deleteBatchIds(ids) > 0) {
            return Result.ok("删除成功");
        }
        return Result.error("删除失败");
    }

    @Override
    public Result getSysUserByPage(SysUserQuery query) {
        List<SysUserVO> vos = new ArrayList<>();
        Long total = 0L;
        try {
            IPage<SysUser> page = PageUtil.getPage(query, SysUser.class);
            new LambdaQueryChainWrapper<>(this.baseMapper)
                    .eq(StringUtils.isNotBlank(query.getUserName()), SysUser::getUserName, query.getUserName())
                    .eq(StringUtils.isNotBlank(query.getNickName()), SysUser::getNickName, query.getNickName())
                    .page(page);
            page.getRecords().stream()
                .map(sysUser -> SysUserVO.getVoByEntity(sysUser, null))
                .forEach(user -> {
                    if (StringUtils.isNotBlank(user.getBelongOrg())) {
                        SysOrg org = new LambdaQueryChainWrapper<>(sysOrgMapper)
                                .select(SysOrg::getOrgName)
                                .eq(SysOrg::getId, user.getBelongOrg())
                                .one();
                        if (Objects.nonNull(org)) {
                            user.setBelongOrgName(org.getOrgName());
                        }
                    }
                    vos.add(user);
                });
            total = page.getTotal();
            return Result.ok().data(vos).total(total);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Result.error("查询错误");
    }

    @Override
    public Result getSysUserById(String id) {
        SysUser entity = baseMapper.selectById(id);
        if (Objects.isNull(entity)) {
            return Result.error("用户不存在");
        }
        SysUserVO vo = SysUserVO.getVoByEntity(entity, null);
        // 获取组织
        if (StringUtils.isNotBlank(entity.getBelongOrg())) {
            SysOrg org = sysOrgMapper.selectById(entity.getBelongOrg());
            if (Objects.nonNull(org)) {
                vo.setBelongOrgName(org.getOrgName());
            }
        }
        return Result.ok().data(vo);
    }

    @Override
    public List<String> getUserMenuPermissions(String username) {
        List<String> permissions = new ArrayList();
        // 先查出用户所有角色
        String roleString = sysUserMapper.getRoleString(username);
        if (StringUtils.isNotBlank(roleString)) {
            // 通过角色查找拥有的菜单id
            String[] split = roleString.split(",");
            List<SysRoleMenu> list = new LambdaQueryChainWrapper<>(roleMenuMapper)
                    .select(SysRoleMenu::getMenuId)
                    .in(SysRoleMenu::getRoleId, split)
                    .list();
            Set<String> set = new HashSet();
            for (SysRoleMenu sysRoleMenu : list) {
                if (StringUtils.isNotBlank(sysRoleMenu.getMenuId())) {
                    for (String s : sysRoleMenu.getMenuId().split(",")) {
                        set.add(s);
                    }
                }
            }
            // 根据id查出对应菜单
            List<SysMenu> sysMenus = new LambdaQueryChainWrapper<>(sysMenuMapper)
                    .ne(SysMenu::getStatus, StatusEnum.INACTIVE.getCode())
                    .in(SysMenu::getId, set)
                    .list();
            for (SysMenu sysMenu : sysMenus) {
                if (StringUtils.isNotBlank(sysMenu.getPermission())) {
                    permissions.add(sysMenu.getPermission());
                }
            }
        }
        return permissions;
    }

    @Override
    public List<String> getUserRolePermissions(String username) {
        List<String> permissions = new ArrayList();
        // 先查出用户所有角色
        String roleString = sysUserMapper.getRoleString(username);
        if (StringUtils.isNotBlank(roleString)) {
            String[] roleIds = roleString.split(",");
            List<SysRole> roleList = new LambdaQueryChainWrapper<>(roleMapper)
                    .select(SysRole::getRoleKey)
                    .in(SysRole::getId, roleIds)
                    .list();
            roleList.stream()
                    .map(SysRole::getRoleKey)
                    .forEach(roleKey -> permissions.add(roleKey));
        }
        return permissions;
    }

    @Override
    public UserRolePermissionVO getMenus(String username) {
        UserRolePermissionVO userRolePermissionVO = new UserRolePermissionVO();
        Set<String> set = new HashSet();
        // 先查出用户所有角色
        String roleString = sysUserMapper.getRoleString(username);
        if (StringUtils.isNotBlank(roleString)) {
            // 通过角色查找拥有的菜单id
            String[] split = roleString.split(",");
            List<SysRoleMenu> list = new LambdaQueryChainWrapper<>(roleMenuMapper)
                    .select(SysRoleMenu::getMenuId)
                    .in(SysRoleMenu::getRoleId, split)
                    .list();
            for (SysRoleMenu sysRoleMenu : list) {
                if (StringUtils.isNotBlank(sysRoleMenu.getMenuId())) {
                    for (String s : sysRoleMenu.getMenuId().split(",")) {
                        set.add(s);
                    }
                }
            }
        }
        // 根据id查出对应菜单(正常和隐藏的菜单)
        List<SysMenuVO> sysMenuVOS = new ArrayList<>();
        // 菜单为空直接返回
        if (set.isEmpty()) {
            return userRolePermissionVO;
        }
        List<SysMenu> sysMenus = new LambdaQueryChainWrapper<>(sysMenuMapper)
                .ne(SysMenu::getStatus, StatusEnum.INACTIVE)
                .in(SysMenu::getId, set)
                .orderByAsc(SysMenu::getOrderNum)
                .list();

        // 转化为VO
        for (SysMenu sysMenu : sysMenus) {
            SysMenuVO sysMenuVO = new SysMenuVO();
            BeanUtils.copyProperties(sysMenu, sysMenuVO);
            sysMenuVOS.add(sysMenuVO);
        }
        // 获取到按钮权限
        List<String> buttonPermissions = sysMenuVOS.stream()
                .filter(menu -> MenuTypeEnum.BUTTON.equals(menu.getMenuType()))
                .map(SysMenuVO::getPermission)
                .collect(Collectors.toList());
        userRolePermissionVO.setButtonPermissions(buttonPermissions);

        // 获取动态菜单
        List<SysMenuVO> dynMenus = sysMenuVOS.stream().filter(menu -> !MenuTypeEnum.BUTTON.equals(menu.getMenuType())).collect(Collectors.toList());
        List<SysMenuVO> tree = TreeUtil.buildMenuTree(dynMenus);
        tree.sort(Comparator.comparing(SysMenuVO::getOrderNum));
        userRolePermissionVO.setMenuPermissions(tree);
        return userRolePermissionVO;
    }

    @Override
    public Result editSysUserStatus(SysUserStatusForm form) {
        SysUser sysUser = baseMapper.selectById(form.getId());
        if (sysUser == null) {
            throw new ServiceException("用户不存在");
        }
        // 校验：自己不能修改自己
        if (sysUser.getId().equals(SecurityUtil.getCurrentUserId())) {
            throw new ServiceException("自己不能修改自己的状态");
        }
        sysUser.setStatus(form.getStatus());
        if (baseMapper.updateById(sysUser) > 0) {
            if (form.getStatus().equals(UserStatusEnum.INACTIVE)) {
                // 如果禁用，清空该用户redis中的token
                redisUtil.deleteKey(RedisKeyPrefixConstants.TOKEN_PREFIX + sysUser.getId());
            }
            return Result.ok("修改成功");
        }
        return Result.error("修改失败");
    }

    @Override
    public Result updatePwd(ResetPwdForm form) {
        String userId = SecurityUtil.getCurrentUserId();
        SysUser user = new LambdaQueryChainWrapper<>(baseMapper)
                .eq(SysUser::getId, userId)
                .eq(SysUser::getStatus, UserStatusEnum.ACTIVE.getCode())
                .one();
        if (user == null) {
            throw new ServiceException("用户不存在或被禁用");
        }
        form.setNewPwd(passwordEncoder.encode(form.getNewPwd()));
        form.setOldPwd(passwordEncoder.encode(form.getOldPwd()));

        if (passwordEncoder.matches(form.getOldPwd(), user.getPassword())) {
            throw new ServiceException("旧密码不正确");
        }
        user.setPassword(form.getNewPwd());
        if (baseMapper.updateById(user) > 0) {
            // 清除现有token
            redisUtil.deleteKey(RedisKeyPrefixConstants.TOKEN_PREFIX + user.getId());
            return Result.ok("密码修改成功，请重新登录");
        }
        return Result.error("修改失败");
    }

    @Override
    public Result resetUserPwd(Integer userId) {
        new LambdaUpdateChainWrapper<>(sysUserMapper)
                .eq(SysUser::getId, userId)
                .set(SysUser::getPassword, passwordEncoder.encode("123456"))
                .update();
        return Result.ok("操作成功");
    }

}