package com.zhongzheng.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zhongzheng.bo.SysUserBo;
import com.zhongzheng.bo.SysUserQuery;
import com.zhongzheng.bo.UserPwdBo;
import com.zhongzheng.entity.*;
import com.zhongzheng.exception.CustomException;
import com.zhongzheng.mapper.SysUserMapper;
import com.zhongzheng.service.*;
import com.zhongzheng.util.DateUtils;
import com.zhongzheng.util.SecurityUtils;
import com.zhongzheng.util.ToolsUtils;
import com.zhongzheng.vo.SysMenuVo;
import com.zhongzheng.vo.SysUserVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Service
public class SysUserServiceImpl extends ServiceImpl<SysUserMapper, SysUser> implements ISysUserService {

    @Autowired
    private ISysUserRoleService userRoleService;

    @Autowired
    private ISysRoleService sysRoleService;

    @Autowired
    private ISysRoleMenuService sysRoleMenuService;

    @Autowired
    private ISysMenuService sysMenuService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addUser(SysUserBo user) {
        if (ObjectUtils.isNotNull(user.getUserId())){
            return editUser(user);
        }
        int count = count(new LambdaQueryWrapper<SysUser>().eq(SysUser::getAccount, user.getAccount()));
        if (count > 0) {
            throw new CustomException("新增用户'" + user.getUserName() + "'失败，登录账号已存在");
        }

        int count1 = count(new LambdaQueryWrapper<SysUser>().eq(SysUser::getEmail, user.getEmail()));
        if (count1 > 0) {
            throw new CustomException("新增用户'" + user.getUserName() + "'失败，邮箱已存在");
        }
        if (CollectionUtils.isEmpty(user.getRoleIds())){
            throw new CustomException("绑定角色不能为空");
        }
        SysUser entity = BeanUtil.toBean(user, SysUser.class);
        entity.setPassword(SecurityUtils.encryptPassword(user.getPassword()));
        entity.setPasswordAes(user.getPassword());
        entity.setCreateTime(DateUtils.getNowTime());
        entity.setUpdateTime(DateUtils.getNowTime());
        save(entity);
        //保存用户角色关联关系
        List<SysUserRole> collect = user.getRoleIds().stream().map(item -> {
            SysUserRole sysUserRole = new SysUserRole();
            sysUserRole.setUserId(entity.getUserId());
            sysUserRole.setRoleId(item);
            return sysUserRole;
        }).collect(Collectors.toList());
        return userRoleService.saveBatch(collect);
    }

    @Override
    public Page<SysUserVo> selectUserList(SysUserQuery bo) {
        Page<SysUser> page = new Page<>();
         if (ObjectUtils.isNull(bo.getRoleId())){
             //全部列表
             page = page(new Page<>(bo.getPageNum(), bo.getPageSize()));

         }else {
             List<SysUserRole> userRoleList = userRoleService.list(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getRoleId, bo.getRoleId()));
             if (CollectionUtils.isNotEmpty(userRoleList)){
                 page = page(new Page<>(bo.getPageNum(), bo.getPageSize()),
                         new LambdaQueryWrapper<SysUser>().in(SysUser::getUserId, userRoleList.stream().map(SysUserRole::getUserId).collect(Collectors.toList())));
             }
         }
         if (CollectionUtils.isEmpty(page.getRecords())){
             return new Page<>();
         }
         //获取角色
        List<SysUserVo> userVos = page.getRecords().stream().map(item -> {
            SysUserVo userVo = BeanUtil.toBean(item, SysUserVo.class);
            userVo.setPassword(item.getPasswordAes());
            List<SysUserRole> roleList = userRoleService.list(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, item.getUserId()));
            if (CollectionUtils.isNotEmpty(roleList)){
                List<SysRole> sysRoles = sysRoleService.listByIds(roleList.stream().map(SysUserRole::getRoleId).collect(Collectors.toList()));
                userVo.setRoleIds(sysRoles.stream().map(SysRole::getRoleId).collect(Collectors.toList()));
                userVo.setRoleName(sysRoles.stream().map(x -> x.getRoleName()).collect(Collectors.joining(",")));
            }
            return userVo;
        }).collect(Collectors.toList());

        Page<SysUserVo> result = new Page<>();
        result.setTotal(page.getTotal());
        result.setRecords(userVos);
        result.setSize(page.getSize());
        return result;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean editUser(SysUserBo bo) {
        SysUser user = BeanUtil.toBean(bo, SysUser.class);
        updateById(user);
        //用户角色关联关系
        userRoleService.remove(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, user.getUserId()));
        List<SysUserRole> userRoleList = bo.getRoleIds().stream().map(item -> {
            SysUserRole sysUserRole = new SysUserRole();
            sysUserRole.setUserId(user.getUserId());
            sysUserRole.setRoleId(item);
            return sysUserRole;
        }).collect(Collectors.toList());

        return userRoleService.saveBatch(userRoleList);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delUser(Long userId) {
        SysUser user = getById(userId);
        if (ObjectUtils.isNull(user)){
            throw new CustomException("用户不存在！");
        }
        userRoleService.remove(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, user.getUserId()));
        removeById(userId);
        return true;
    }

    @Override
    public SysUserVo userDetail(Long userId) {
        SysUser user = getById(userId);
        SysUserVo vo = BeanUtil.toBean(user, SysUserVo.class);
        vo.setPassword(user.getPasswordAes());
        List<SysUserRole> list = userRoleService.list(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
        if (CollectionUtils.isNotEmpty(list)){
            vo.setRoleIds(list.stream().map(SysUserRole::getRoleId).collect(Collectors.toList()));
        }
        return vo;
    }

    @Override
    public SysUserVo getUserPermission(Long userId) {
        SysUser sysUser = getById(userId);
        if (ObjectUtils.isNull(sysUser)){
            throw new CustomException("用户获取有误");
        }
        SysUserVo vo = BeanUtil.toBean(sysUser, SysUserVo.class);
        if (sysUser.getUserName().equals("admin")){
            vo.setButtonL(Arrays.asList("*:*:*"));
            return vo;
        }
        List<SysUserRole> list = userRoleService.list(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
        if (CollectionUtils.isNotEmpty(list)){
            List<Long> roleIds = list.stream().map(SysUserRole::getRoleId).collect(Collectors.toList());
            vo.setRoleIds(roleIds);
            //用户菜单权限
            List<SysRoleMenu> menus = sysRoleMenuService.list(new LambdaQueryWrapper<SysRoleMenu>().in(SysRoleMenu::getRoleId, roleIds));
            if (CollectionUtils.isNotEmpty(menus)){
                List<SysMenu> sysMenus = sysMenuService.listByIds(menus.stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList()));
                if (CollectionUtils.isNotEmpty(sysMenus)){
                    List<String> perms = sysMenus.stream().filter(x -> StringUtils.isNotBlank(x.getPerms())).map(SysMenu::getPerms).collect(Collectors.toList());
                    vo.setButtonL(perms);
                }
            }
        }
        return vo;
    }

    @Override
    public List<SysMenuVo> getUserMenu(Long userId) {
        SysUser sysUser = getById(userId);
        if (ObjectUtils.isNull(sysUser)){
            throw new CustomException("用户获取有误");
        }
        if ("admin".equals(sysUser.getUserName())){
            List<SysMenu> sysMenus = sysMenuService.list();
            List<SysMenuVo> sysMenuVos = new ArrayList<>();
            for (SysMenu menu : sysMenus) {
                if (menu.getParentId() == null || menu.getParentId() == 0) {
                    // 找到顶级节点
                    SysMenuVo vo = BeanUtil.toBean(menu, SysMenuVo.class);
                    vo.setChildren(getChildren(menu, sysMenus));
                    sysMenuVos.add(vo);
                }
            }
            return sysMenuVos;
        }
        List<SysUserRole> list = userRoleService.list(new LambdaQueryWrapper<SysUserRole>().eq(SysUserRole::getUserId, userId));
        if (CollectionUtils.isEmpty(list)){
            return new ArrayList<>();
        }
        List<Long> roleIds = list.stream().map(SysUserRole::getRoleId).collect(Collectors.toList());
        //用户菜单权限
        List<SysRoleMenu> menus = sysRoleMenuService.list(new LambdaQueryWrapper<SysRoleMenu>().in(SysRoleMenu::getRoleId, roleIds));
        if (CollectionUtils.isEmpty(menus)){
            return new ArrayList<>();
        }
        List<SysMenu> sysMenus = sysMenuService.listByIds(menus.stream().map(SysRoleMenu::getMenuId).collect(Collectors.toList()));
        List<SysMenuVo> sysMenuVos = new ArrayList<>();
        for (SysMenu menu : sysMenus) {
            if (menu.getParentId() == null || menu.getParentId() == 0) {
                // 找到顶级节点
                SysMenuVo vo = BeanUtil.toBean(menu, SysMenuVo.class);
                vo.setChildren(getChildren(menu, sysMenus));
                sysMenuVos.add(vo);
            }
        }
        return sysMenuVos;
    }

    @Override
    public void initAdmin() {
        SysUser admin = getOne(new LambdaQueryWrapper<SysUser>().eq(SysUser::getAccount, "admin"));
        if (ObjectUtils.isNotNull(admin)){
            throw new CustomException("admin用户已存在");
        }
        SysUser entity = new SysUser();
        entity.setAccount("admin");
        entity.setUserName("admin");
        entity.setPassword(SecurityUtils.encryptPassword("admin123"));
        entity.setPasswordAes("admin123");
        entity.setCreateTime(DateUtils.getNowTime());
        entity.setUpdateTime(DateUtils.getNowTime());
        save(entity);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean editPassword(UserPwdBo bo) {
        if (!bo.getNewPwd().equals(bo.getAffirmPwd())){
            throw new CustomException("二次輸入的密碼不一樣");
        }
        SysUser user = SecurityUtils.getLoginUser().getUser();
        if (ObjectUtils.isNull(user)){
            throw new CustomException("用戶獲取失敗");
        }
        if (!user.getPasswordAes().equals(bo.getOldPwd())){
            throw new CustomException("舊密碼輸入有誤");
        }
        user.setPassword(SecurityUtils.encryptPassword(bo.getAffirmPwd()));
        user.setPasswordAes(bo.getAffirmPwd());
        return updateById(user);
    }

    private List<SysMenuVo> getChildren(SysMenu parent, List<SysMenu> sysMenus) {
        List<SysMenuVo> children = new ArrayList<>();
        for (SysMenu menu : sysMenus) {
            if (parent.getMenuId().equals(menu.getParentId())) {
                // 递归设置子菜单的子菜单
                SysMenuVo vo = BeanUtil.toBean(menu, SysMenuVo.class);
                vo.setChildren(getChildren(menu, sysMenus));
                children.add(vo);
            }
        }
        return children;

    }
}