package com.panzhihua.service_user.service.impl;

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

import javax.annotation.Resource;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.BeanUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.panzhihua.common.constants.SecurityConstants;
import com.panzhihua.common.model.vos.MenuVO;
import com.panzhihua.common.model.vos.R;
import com.panzhihua.common.model.vos.user.MenuRoleVO;
import com.panzhihua.common.model.vos.user.RoleVO;
import com.panzhihua.common.model.vos.user.SysMenuVO;
import com.panzhihua.service_user.dao.RoleDAO;
import com.panzhihua.service_user.dao.SysMenuDAO;
import com.panzhihua.service_user.dao.SysRoleMenuDAO;
import com.panzhihua.service_user.dao.SysUserRoleDAO;
import com.panzhihua.service_user.model.dos.SysMenuDO;
import com.panzhihua.service_user.model.dos.SysRoleDO;
import com.panzhihua.service_user.model.dos.SysRoleMenuDO;
import com.panzhihua.service_user.model.dos.SysUserRoleDO;
import com.panzhihua.service_user.service.RoleService;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;

/**
 * @program: springcloud_k8s_panzhihuazhihuishequ
 * @description: 权限
 * @author: huang.hongfa weixin hhf9596 qq 959656820
 * @create: 2020-11-25 15:59
 **/
@Slf4j
@Service
public class RoleServiceImpl implements RoleService {
    @Resource
    private RoleDAO roleDAO;
    @Resource
    private SysUserRoleDAO sysUserRoleDAO;
    @Resource
    private SysMenuDAO sysMenuDAO;
    @Resource
    private SysRoleMenuDAO sysRoleMenuDAO;
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 获取平台所有的菜单按钮权限
     *
     * @return 菜单按钮权限
     */
    @Override
    public R<List<MenuVO>> getAllMenu() {
        List<MenuVO> menuVOS = roleDAO.selectAllMenuUrl();
        return R.ok(menuVOS);
    }

    /**
     * 获取某个人的所有角色
     *
     * @param username
     *            用户ID
     * @return 所有角色
     */
    @Override
    public R<List<String>> getUserRoles(String username) {
        List<String> roles = roleDAO.selectRoles(username);
        return R.ok(roles);
    }

    /**
     * 查询社区的党委角色
     *
     * @param communityId
     *            社区id
     * @return 党委角色列表
     */
    @Override
    public R listIdentity(Integer communityId) {
        List<RoleVO> roleVOS = new ArrayList<>();
        List<SysRoleDO> sysRoleDOS =
            roleDAO.selectList(new QueryWrapper<SysRoleDO>().lambda().eq(SysRoleDO::getCommunityId, communityId));
        if (!ObjectUtils.isEmpty(sysRoleDOS)) {
            sysRoleDOS.forEach(sysRoleDO -> {
                RoleVO roleVO = new RoleVO();
                BeanUtils.copyProperties(sysRoleDO, roleVO);
                roleVOS.add(roleVO);
            });
        }
        return R.ok(roleVOS);
    }

    /**
     * 角色下拉列表
     *
     * @param communityId
     *            对应社区 0 表示运营后台
     * @return 角色集合
     */
    @Override
    public R listRoleBackstage(Long communityId,Integer pageNum,Integer pageSize,String areaCode) {
        LambdaQueryWrapper<SysRoleDO> queryWrapper=new QueryWrapper<SysRoleDO>().lambda().eq(SysRoleDO::getCommunityId, communityId);
        if(com.panzhihua.common.utlis.StringUtils.isNotEmpty(areaCode)){
            queryWrapper.eq(SysRoleDO::getAreaCode,areaCode);
        }
        queryWrapper.orderByDesc(SysRoleDO::getCreateAt);
        IPage<SysRoleDO> sysRoleDOIPage=this.roleDAO.selectPage(new Page<>(pageNum,pageSize),queryWrapper);
        return R.ok(sysRoleDOIPage);
    }

    /**
     * 新增角色
     *
     * @param roleVO
     *            角色信息
     * @return 新增结果
     */
    @Override
    public R addRoleBackstage(RoleVO roleVO) {
        SysRoleDO sysRoleDO = new SysRoleDO();
        BeanUtils.copyProperties(roleVO, sysRoleDO);
        int insert = 0;
        try {
            insert = roleDAO.insert(sysRoleDO);
        } catch (Exception e) {
            e.printStackTrace();
            log.error("新增角色失败，失败原因【{}】", e.getMessage());
                return R.fail("角色已经存在");
        }
        if (insert > 0) {
            SysRoleDO roleDO = roleDAO.selectOne(new QueryWrapper<SysRoleDO>().lambda()
                .eq(SysRoleDO::getRoleKey, roleVO.getRoleKey()).eq(SysRoleDO::getCommunityId, roleVO.getCommunityId()));
            return R.ok(roleDO.getRoleId());
        }
        return R.fail();
    }

    /**
     * 删除角色
     *
     * @param roleVO
     *            角色主键
     * @return 删除结果
     */
    @Override
    public R deleteRoleBackstage(RoleVO roleVO) {
        Integer integer = sysUserRoleDAO
            .selectCount(new QueryWrapper<SysUserRoleDO>().lambda().eq(SysUserRoleDO::getRoleId, roleVO.getRoleId()));
        if (integer > 0) {
            return R.fail("该角色的关联用户数量不为0，不能删除");
        }
        int delete = roleDAO.deleteById(roleVO.getRoleId());
        if (delete == 0) {
            return R.fail("角色不存在");
        }
        return R.ok();
    }

    /**
     * 平台菜单列表
     * 
     * @param communityId
     *            社区id 0 运营平台
     * @return 菜单集合
     */
    @Override
    public R listMenuBackstage(Long communityId,String appId) {
        if("wx118de8a734d269f0".equals(appId)){
            communityId=2L;
        }
        else {
            communityId=1552661941170868228L;
        }
        List<SysMenuVO> sysMenuVOS = new ArrayList<>();
        List<SysMenuDO> sysMenuDOS =
            sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().eq(SysMenuDO::getParentId, 0)
                .eq(SysMenuDO::getCommunityId, communityId).orderByAsc(SysMenuDO::getOrderNum));
        if (!ObjectUtils.isEmpty(sysMenuDOS)) {
            sysMenuDOS.forEach(sysMenuDO -> {
                SysMenuVO sysMenuVO = new SysMenuVO();
                BeanUtils.copyProperties(sysMenuDO, sysMenuVO);
                Long menuId = sysMenuDO.getMenuId();
                List<SysMenuDO> sysMenuDOS1 = sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda()
                    .eq(SysMenuDO::getParentId, menuId).orderByAsc(SysMenuDO::getOrderNum));
                List<SysMenuVO> sysMenuVOS1 = new ArrayList<>();
                if (!ObjectUtils.isEmpty(sysMenuDOS1)) {
                    sysMenuDOS1.forEach(sysMenuDO1 -> {
                        SysMenuVO sysMenuVO1 = new SysMenuVO();
                        BeanUtils.copyProperties(sysMenuDO1, sysMenuVO1);
                        List<SysMenuDO> sysMenuDOList = sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda()
                                .eq(SysMenuDO::getParentId, sysMenuDO1.getMenuId()).orderByAsc(SysMenuDO::getOrderNum));
                        List<SysMenuVO> sysMenuVOList=new ArrayList<>();
                        sysMenuDOList.forEach(sysMenuDO2 -> {
                            SysMenuVO sysMenuVO2=new SysMenuVO();
                            BeanUtils.copyProperties(sysMenuDO2,sysMenuVO2);
                            sysMenuVOList.add(sysMenuVO2);
                        });
                        sysMenuVO1.setSysMenuVOList(sysMenuVOList);
                        sysMenuVOS1.add(sysMenuVO1);
                    });
                    sysMenuVO.setSysMenuVOList(sysMenuVOS1);
                }
                sysMenuVOS.add(sysMenuVO);
            });
        }
        return R.ok(sysMenuVOS);
    }

    /**
     * 设置角色的权限
     *
     * @param menuRoleVO
     *            用户设置的权限id
     * @return 设置结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R putMenuRole(MenuRoleVO menuRoleVO) {
        List<Long> menuIds = new ArrayList<>();
        Long roleId = menuRoleVO.getRoleId();
        if(!StringUtils.isEmpty(menuRoleVO.getRoleName())){
            SysRoleDO sysRoleDO=new SysRoleDO();
            sysRoleDO.setRoleId(roleId);
            sysRoleDO.setRoleName(menuRoleVO.getRoleName());
            this.roleDAO.updateById(sysRoleDO);
        }
        // 删除旧的
        sysRoleMenuDAO.delete(new QueryWrapper<SysRoleMenuDO>().lambda().eq(SysRoleMenuDO::getRoleId, roleId));
        // 创建新的
        Integer isAll = menuRoleVO.getIsAll();
        if (isAll.intValue() == 1) {
            menuIds = sysMenuDAO
                .selectList(
                    new QueryWrapper<SysMenuDO>().lambda().eq(SysMenuDO::getCommunityId, 2))
                .stream().map(sysMenuDO -> sysMenuDO.getMenuId()).collect(Collectors.toList());
        } else {
            menuIds = menuRoleVO.getMenuIds();
        }
        for (int i = 0; i < menuIds.size(); i++) {
            SysRoleMenuDO sysRoleMenuDO = new SysRoleMenuDO();
            sysRoleMenuDO.setMenuId(menuIds.get(i));
            sysRoleMenuDO.setRoleId(roleId);
            sysRoleMenuDAO.insert(sysRoleMenuDO);
        }
        // 清除缓存
        stringRedisTemplate.delete(SecurityConstants.ROLE_ALL);
        return R.ok();
    }

    /**
     * 用户菜单获取
     *
     * @param userId
     *            登录用户id
     * @return 用户菜单
     */
    @Override
    public R listmenu(Long userId) {
        SysUserRoleDO sysUserRoleDO =
            sysUserRoleDAO.selectOne(new QueryWrapper<SysUserRoleDO>().lambda().eq(SysUserRoleDO::getUserId, userId));
        if (ObjectUtils.isEmpty(sysUserRoleDO)) {
            return R.fail("用户未绑定角色");
        }
        Long roleId = sysUserRoleDO.getRoleId();
        List<SysRoleMenuDO> sysRoleMenuDOS =
            sysRoleMenuDAO.selectList(new QueryWrapper<SysRoleMenuDO>().lambda().eq(SysRoleMenuDO::getRoleId, roleId));
        if (ObjectUtils.isEmpty(sysRoleMenuDOS)) {
            return R.fail("用户没有任何权限");
        }
        List<Long> collect =
            sysRoleMenuDOS.stream().map(sysRoleMenuDO -> sysRoleMenuDO.getMenuId()).collect(Collectors.toList());
        List<SysMenuDO> sysMenuDOS =
            sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().in(SysMenuDO::getMenuId, collect).eq(SysMenuDO::getParentId,0));
        List<SysMenuVO> sysMenuVOS = new ArrayList<>();
        sysMenuDOS.forEach(sysMenuDO -> {
            SysMenuVO sysMenuVO = new SysMenuVO();
            List<SysMenuVO> menuVOS=new ArrayList<>();
            BeanUtils.copyProperties(sysMenuDO, sysMenuVO);
            List<SysMenuDO> sysMenuDOList=sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().eq(SysMenuDO::getParentId,sysMenuDO.getMenuId()).in(SysMenuDO::getMenuId, collect));
            sysMenuDOList.forEach(sysMenuDO1->{
                SysMenuVO sysMenuVO1 = new SysMenuVO();
                List<SysMenuVO> sysMenuVOList=new ArrayList<>();
                BeanUtils.copyProperties(sysMenuDO1, sysMenuVO1);
                List<SysMenuDO> sysMenuDOList1=sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().eq(SysMenuDO::getParentId,sysMenuDO1.getMenuId()).in(SysMenuDO::getMenuId, collect));
                sysMenuDOList1.forEach(sysMenuDO2 -> {
                    SysMenuVO sysMenuVO2=new SysMenuVO();
                    BeanUtils.copyProperties(sysMenuDO2,sysMenuVO2);
                    sysMenuVOList.add(sysMenuVO2);
                });
                sysMenuVO1.setSysMenuVOList(sysMenuVOList.stream().sorted(Comparator.comparing(SysMenuVO::getOrderNum)).collect(Collectors.toList()));
                menuVOS.add(sysMenuVO1);
            });
            sysMenuVO.setSysMenuVOList(menuVOS.stream().sorted(Comparator.comparing(SysMenuVO::getOrderNum)).collect(Collectors.toList()));
            sysMenuVOS.add(sysMenuVO);
        });
        return R.ok(sysMenuVOS.stream().sorted(Comparator.comparing(SysMenuVO::getOrderNum)).collect(Collectors.toList()));
    }

    /**
     * 获取角色的权限配置列表
     *
     * @param roleId
     *            角色id
     * @return 菜单列表
     */
    @Override
    public R listMenuBackstageByRole(Long roleId) {
        List<SysRoleMenuDO> sysRoleMenuDOS =
            sysRoleMenuDAO.selectList(new QueryWrapper<SysRoleMenuDO>().lambda().eq(SysRoleMenuDO::getRoleId, roleId));
        if (!ObjectUtils.isEmpty(sysRoleMenuDOS)) {
            List<Long> longs =
                sysRoleMenuDOS.stream().map(sysRoleMenuDO -> sysRoleMenuDO.getMenuId()).collect(Collectors.toList());
            List<SysMenuDO> sysMenuDOList=this.sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().in(SysMenuDO::getMenuId,longs).eq(SysMenuDO::getParentId,0));
            sysMenuDOList.forEach(sysMenuDO -> {
                List<SysMenuDO> sysMenuDOS=this.sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().in(SysMenuDO::getMenuId,longs).eq(SysMenuDO::getParentId,sysMenuDO.getMenuId()));
                sysMenuDOS.forEach(sysMenuDO1 -> {
                    List<SysMenuDO> sysMenuDOS1=this.sysMenuDAO.selectList(new QueryWrapper<SysMenuDO>().lambda().in(SysMenuDO::getMenuId,longs).eq(SysMenuDO::getParentId,sysMenuDO1.getMenuId()));
                    if(!sysMenuDOS1.isEmpty()){
                        longs.remove(sysMenuDO1.getMenuId());
                    }
                });
                if(!sysMenuDOS.isEmpty()){
                    longs.remove(sysMenuDO.getMenuId());
                }
            });
            return R.ok(longs);
        }
        return R.fail();
    }
}