package cn.huge.module.rsoper.service;

import cn.huge.base.common.exception.ServiceException;
import cn.huge.base.common.utils.DateUtils;
import cn.huge.base.common.utils.IdUtils;
import cn.huge.module.client.api.impl.UtilsClientImpl;
import cn.huge.module.constant.BaseConsts;
import cn.huge.module.cust.constant.MenuBaseEnum;
import cn.huge.module.cust.constant.RoleBaseEnum;
import cn.huge.module.rsoper.dao.mapper.RsRolefunMapper;
import cn.huge.module.rsoper.domain.dto.RoleMenuTreeDTO;
import cn.huge.module.rsoper.domain.po.RsMenu;
import cn.huge.module.rsoper.domain.po.RsRole;
import cn.huge.module.rsoper.domain.po.RsRolefun;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @title: 系统角色功能权限表业务逻辑处理
 * @Description 系统角色功能权限表业务逻辑处理
 * @company hugeinfo
 * @author liyj
 * @Time 2024-09-10 15:46:25
 * @version 1.0.0
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class RsRolefunService extends ServiceImpl<RsRolefunMapper, RsRolefun>{

    @Autowired
    private RsRolefunMapper mapper;

    @Autowired
    private UtilsClientImpl utilsClient;
    @Autowired
    private RsMenuService rsMenuService;
    @Autowired
    private RsRoleService rsRoleService;

    /**
    * 更新对象
    * @param entity 对象
    */
    public void updateRsRolefun(RsRolefun entity){
        try{
            mapper.updateRsRolefun(entity);
        }catch (Exception e){
            log.error("[RsRolefunService.updateRsRolefun]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRolefunService.updateRsRolefun", e);
        }
    }

    /**
    * 条件更新对象
    * @param entity 对象
    * @param terms 条件
    */
    public void updateRsRolefunTerms(RsRolefun entity, Map<String, Object> terms){
        try{
            mapper.updateRsRolefunTerms(entity, terms);
        }catch (Exception e){
            log.error("[RsRolefunService.updateRsRolefunTerms]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRolefunService.updateRsRolefunTerms", e);
        }
    }

    /**
    * 根据编号物理删除
    * @param id 查询条件集合
    */
    public void deleteRsRolefun(String id){
        try{
            mapper.deleteRsRolefun(id);
        }catch (Exception e){
            log.error("[RsRolefunService.deleteRsRolefun]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRolefunService.deleteRsRolefun", e);
        }
    }

    /**
    * 按条件查询
    * @param terms 条件
    * @return List
    */
    public List<RsRolefun> listTerms(Map<String, Object> terms){
        return mapper.listTerms(terms);
    }

    /**
    * 按条件统计
    * @param terms 条件
    * @return long
    */
    public long countTerms(Map<String, Object> terms){
        return mapper.countTerms(terms);
    }

    /**
    * 按条件分页查询
    * @param page 分页对象
    * @param terms 条件
    * @return Page
    */
    public Page<RsRolefun> pageQuery(PageRequest page, Map<String, Object> terms){
        long total = mapper.countTerms(terms);
        List<RsRolefun> content = mapper.pageTerms(page, terms);
        return new PageImpl<RsRolefun>(content, page, total);
    }

    /**
    * 新增或更新对象
    * @param rsRolefun 实体对象
    */
    public void saveRsRolefun(RsRolefun rsRolefun){
        try{
            Date nowDate = DateUtils.getNowDate();
            // 判断是否新增
            if (IdUtils.checkNewId(rsRolefun.getId())){
                rsRolefun.setId(utilsClient.getNewTimeId());
                rsRolefun.setCreateTime(nowDate);
            }
            rsRolefun.setUpdateTime(nowDate);
            this.saveOrUpdate(rsRolefun);
        }catch (Exception e){
            log.error("[RsRolefunService.saveRsRolefun]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRolefunService.saveRsRolefun", e);
        }
    }

    /**
     * 获取角色的菜单权限
     * @param roleId
     * @return
     */
    public List<RoleMenuTreeDTO> listMenuByRoleId(String roleId){
        return mapper.listMenuByRoleId(roleId);
    }

    /**
     * 查询角色菜单权限树形结构
     * @param roleId 角色编号
     * @return List<RoleTreeBO> 树形结构
     */
    public List<RoleMenuTreeDTO> getRolefunTree(String roleId){
        try{
            List<RoleMenuTreeDTO> roleMenuTreeDTOList = mapper.listMenuByRoleId(roleId);
            List<RoleMenuTreeDTO> firstList = new ArrayList<>();
            List<RoleMenuTreeDTO> treeList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(roleMenuTreeDTOList)) {
                //第一级菜单集合
                for (RoleMenuTreeDTO roleMenuTreeDTO: roleMenuTreeDTOList) {
                    // 一级菜单parentId为root
                    if (BaseConsts.ROOT.equals(roleMenuTreeDTO.getParentId())) {
                        firstList.add(roleMenuTreeDTO);
                    }
                }
                // 为一级菜单设置子菜单，getChild是递归调用的
                for (RoleMenuTreeDTO roleMenuTreeDTO : firstList) {
                    roleMenuTreeDTO.setChildren(getChild(roleMenuTreeDTO.getValue(), roleMenuTreeDTOList));
                    treeList.add(roleMenuTreeDTO);
                }
            }
            return treeList;
        }catch (Exception e){
            log.error("[RsRolefunService.getRolefunTree]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRolefunService.getRolefunTree", e);
        }
    }

    /**
     * 递归查找子菜单
     * @param id 当前菜单id
     * @param roleMenuTreeDTOList 要查找的列表
     * @return List<TreeBO> 树形列表集合
     */
    private List<RoleMenuTreeDTO> getChild(String id, List<RoleMenuTreeDTO> roleMenuTreeDTOList) {
        // 子菜单
        List<RoleMenuTreeDTO> childList = new ArrayList<>();
        for (RoleMenuTreeDTO roleMenuTreeDTO: roleMenuTreeDTOList) {
            // 遍历所有节点，将父菜单id与传过来的id比较
            if (StringUtils.isNotBlank(roleMenuTreeDTO.getParentId())) {
                if (roleMenuTreeDTO.getParentId().equals(id)) {
                    roleMenuTreeDTO.setChildren(getChild(roleMenuTreeDTO.getValue(), roleMenuTreeDTOList));
                    childList.add(roleMenuTreeDTO);
                }
            }
        }
        return childList;
    }

    /**
     * 人工临时处理-给所有角色赋菜单权限
     */
    public void webSetFun(){
        try{
            // 查询客户中心
            QueryWrapper<RsMenu> rsMenuQueryWrapper = new QueryWrapper<>();
            rsMenuQueryWrapper.eq("menu_tag", MenuBaseEnum.MENU_APP_2.getIndex());
            RsMenu khzxMenu = rsMenuService.getOne(rsMenuQueryWrapper);
            // 给角色赋菜单权限
            List<RsRole> rsRoleList = rsRoleService.list();
            List<RsMenu> rsMenuList = rsMenuService.list();
            for (RsRole rsRole: rsRoleList){
                QueryWrapper<RsRolefun> rsRoleFunQueryWrapper = new QueryWrapper<>();
                rsRoleFunQueryWrapper.eq("role_id", rsRole.getId());
                mapper.delete(rsRoleFunQueryWrapper);
                for (RsMenu rsMenu: rsMenuList){
                    if (RoleBaseEnum.ROLE_4.getIndex().equals(rsRole.getId())){
                        if (khzxMenu.getId().equals(rsMenu.getId()) || khzxMenu.getId().equals(rsMenu.getParentId())){
                            continue;
                        }
                    }
                    RsRolefun rsRolefun = new RsRolefun();
                    rsRolefun.setId(utilsClient.getNewTimeId());
                    rsRolefun.setRoleId(rsRole.getId());
                    rsRolefun.setMenuId(rsMenu.getId());
                    mapper.insert(rsRolefun);
                }
            }
        }catch (Exception e){
            log.error("[RsRoleFunService.webSetFun]调用失败，异常信息："+e, e);
            throw new ServiceException("RsRoleFunService.webSetFun", e);
        }
    }

}