package com.nanjing.water.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.nanjing.water.common.ExecutedResult;
import com.nanjing.water.common.PagerResult;
import com.nanjing.water.common.model.Tuple;
import com.nanjing.water.common.util.*;
import com.nanjing.water.entity.enums.EState;
import com.nanjing.water.entity.request.ReqListSetSort;
import com.nanjing.water.entity.request.ReqSetSort;
import com.nanjing.water.entity.request.adminmenu.ReqCreateAdminMenu;
import com.nanjing.water.entity.request.adminmenu.ReqModifyAdminMenu;
import com.nanjing.water.entity.request.adminpermission.ReqCreateAdminPermission;
import com.nanjing.water.entity.request.adminpermission.ReqModifyAdminPermission;
import com.nanjing.water.entity.request.adminrole.ReqCreateAdminRole;
import com.nanjing.water.entity.request.adminrole.ReqModifyAdminRole;
import com.nanjing.water.entity.request.adminrolemenurelation.ReqSetListMenu4Role;
import com.nanjing.water.entity.response.admin.ResAdminMenuTreeAndPermission;
import com.nanjing.water.entity.response.admin.ResAdminPermission;
import com.nanjing.water.entity.response.admin.ResAdminPower;
import com.nanjing.water.entity.search.SearchAdminMenu;
import com.nanjing.water.entity.search.SearchAdminPermission;
import com.nanjing.water.entity.search.SearchAdminRole;
import com.nanjing.water.repository.impl.*;
import com.nanjing.water.repository.po.*;
import com.nanjing.water.repository.vo.AdminMenuVO;
import com.nanjing.water.repository.vo.AdminRoleVO;
import com.nanjing.water.service.cache.AdminMenuService;
import com.nanjing.water.service.cache.AdminPermissionService;
import com.nanjing.water.service.convert.AdminMenuConvert;
import com.nanjing.water.service.convert.AdminPermissionConvert;
import com.nanjing.water.service.convert.AdminRoleConvert;
import org.apache.commons.lang3.BooleanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

@Service
public class AdminPowerService extends BaseService {
    @Autowired
    private AdminMenuMapperImpl menusDao;
    @Autowired
    private AdminPermissionMapperImpl permissionDao;
    @Autowired
    private AdminRoleMapperImpl roleDao;
    @Autowired
    private AdminRoleMenuRelationMapperImpl roleMenuRelationDao;
    @Autowired
    private AdminRolePermissionRelationMapperImpl rolePermissionRelationDao;
    @Autowired
    private AdminRoleRelationMapperImpl adminRoleRelationDao;

    @Autowired
    private AdminMenuService menusService;
    @Autowired
    private AdminPermissionService permissionService;



    // 创建菜单
    public ExecutedResult<Long> createMenu(ReqCreateAdminMenu request) {
        AdminMenuPO item = AdminMenuConvert.INSTANCE.toCreate(request);
        item.setParentId(NumericUtil.tryParseLong(request.getParentId(), 0L));
        item.setTitle(ParameterUtil.dealNullStr(request.getTitle()));
        item.setLevel(1);
        item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
        item.setStatus(EState.NORMAL.getValue());
        item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
        if (item.getParentId().compareTo(0L) > 0) {
            ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getParentId());
            if (check.isFailed()) {
                return ExecutedResult.failed("父级菜单不存在: " + request.getParentId());
            }
            item.setLevel(check.getData().getLevel() + 1);
        }
        int rowCount = menusDao.insert(item);
        if (rowCount == 1) {
            // 删除菜单缓存
            menusService.removeListAllCache();
            // 删除所有权限缓存
            permissionService.removeListAllCache();
            // 删除所有用户的菜单和权限缓存
            this.removePowerAllUser();

            // 给新增的菜单添加默认权限
            permissionService.createDefaultPermission(item);
            return ExecutedResult.success(item.getId());
        }
        return ExecutedResult.failed("创建[菜单]失败。");
    }
    private ExecutedResult<AdminMenuPO> checkMenuId(Long id) {
        AdminMenuPO item = menusDao.get(id);
        if (Objects.isNull(item)) {
            return ExecutedResult.failed("[菜单]不存在: " + id);
        }
        return ExecutedResult.success(item);
    }
    protected ExecutedResult<List<AdminMenuPO>> checkMenuId(List<Long> listId) {
        // 从数据库查找测试信息
        List<AdminMenuPO> list = menusDao.getList(listId);
        if (ListUtil.isNullOrEmpty(list)) {
            return ExecutedResult.failed("[菜单]不存在." + listId);
        }
        // 数据库找到的id列表
        List<Long> listIdFind = list.stream().map(AdminMenuPO::getId).collect(Collectors.toList());
        // 数量不一致
        if (listId.size() != listIdFind.size()) {
            // 筛选数据库不存在的测试信息
            List<Long> listIdNotFound = listId.stream().filter(c -> !listIdFind.contains(c)).collect(Collectors.toList());
            if (ListUtil.isNullOrEmpty(list)) {
                return ExecutedResult.failed("[菜单]不存在." + listIdNotFound);
            }
        }
        return ExecutedResult.success(list);
    }

    // 编辑菜单
    public ExecutedResult<String> modifyMenu(ReqModifyAdminMenu request) {
        ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getId());
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminMenuPO item = AdminMenuConvert.INSTANCE.toModify(request);
        item.setTitle(ParameterUtil.dealNullStr(request.getTitle()));
        item.setParentId(NumericUtil.tryParseLong(request.getParentId(), 0L));
        item.setLevel(1);
        item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
        if (item.getParentId().compareTo(0L) > 0) {
            ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getParentId());
            if (check.isFailed()) {
                return ExecutedResult.failed("父级菜单不存在: " + request.getParentId());
            }
            item.setLevel(check.getData().getLevel() + 1);
        }
        int rowCount = menusDao.updateById(item);
        if (rowCount == 1) {
            // 删除菜单缓存
            menusService.removeListAllCache();
            // 删除所有权限缓存
            permissionService.removeListAllCache();
            // 删除所有用户的菜单和权限缓存
            this.removePowerAllUser();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("编辑[菜单]失败。");
    }

    public ExecutedResult<String> removeMenu(Long id) {
        // 验证记录是否存在
        ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        Boolean result = menusDao.deleteLogic(id);
        if (result) {
            // 删除菜单缓存
            menusService.removeListAllCache();
            // 删除所有权限缓存
            permissionService.removeListAllCache();
            // 删除所有用户的菜单和权限缓存
            this.removePowerAllUser();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("删除[菜单]失败。");
    }

    public ExecutedResult<String> removeMenuList(List<Long> listId) {
        // 验证记录是否存在
        ExecutedResult<List<AdminMenuPO>> checkExists = this.checkMenuId(listId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        Boolean result = menusDao.deleteLogic(listId);
        if (result) {
            // 删除菜单缓存
            menusService.removeListAllCache();
            // 删除所有权限缓存
            permissionService.removeListAllCache();
            // 删除所有用户的菜单和权限缓存
            this.removePowerAllUser();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("删除[菜单]失败。");
    }

    // 变更菜单状态
    public ExecutedResult<String> changeMenuStatus(Long id, EState status) {
        ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminMenuPO upd = new AdminMenuPO();
        upd.setId(id);
        upd.setStatus(status.getValue());
        int rowCount = menusDao.updateById(upd);
        if (rowCount == 1) {
            // 删除菜单缓存
            menusService.removeListAllCache();
            // 删除所有权限缓存
            permissionService.removeListAllCache();
            // 删除所有用户的菜单和权限缓存
            this.removePowerAllUser();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("修改[菜单]状态失败。");
    }

    // 获取所有层级菜单
    public ExecutedResult<List<ResAdminMenuTreeAndPermission>> getListTreeMenu() {
        List<ResAdminMenuTreeAndPermission> result = new ArrayList<>();
        LambdaQueryWrapper<AdminMenuPO> where = menusDao.query();
        where.in(AdminMenuPO::getStatus, Arrays.asList(
                EState.NORMAL.getValue()
        ));
        List<AdminMenuPO> list = menusDao.selectList(where);

        if (ListUtil.isNullOrEmpty(list)) {
            return ExecutedResult.success(result);
        }
        List<AdminMenuPO> listRoot = list.stream().filter(c -> Objects.equals(c.getLevel(), 1)).collect(Collectors.toList());
        listRoot = listRoot.stream()
                .sorted(Comparator.comparing(AdminMenuPO::getSort))
                .collect(Collectors.toList());
        if (ListUtil.isNullOrEmpty(listRoot)) {
            return ExecutedResult.success(result);
        }

        List<Long> listMenuId = list.stream()
                .map(AdminMenuPO::getId)
                .collect(Collectors.toList());
        List<AdminPermissionPO> listPermission = permissionDao.list4MenuId(listMenuId);
        Map<Long, List<AdminPermissionPO>> mapPermission = listPermission.stream()
                .collect(Collectors.groupingBy(AdminPermissionPO::getMenuId));

        for (AdminMenuPO item : listRoot) {
            ResAdminMenuTreeAndPermission view = AdminMenuConvert.INSTANCE.toTreeVo(item);
            this.fillChildMenu(view, list, mapPermission);
            this.fillPermission4Menu(view, mapPermission);
            result.add(view);
        }
        return ExecutedResult.success(result);
    }
    public void fillPermission4Menu(ResAdminMenuTreeAndPermission view, Map<Long, List<AdminPermissionPO>> mapPermission) {
        view.setPermissions(new ArrayList<>());
        if (BooleanUtils.isFalse(mapPermission.containsKey(view.getId()))) {
            return;
        }
        List<AdminPermissionPO> list = mapPermission.get(view.getId());
        view.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(list));
    }
    public void fillChildMenu(ResAdminMenuTreeAndPermission view, List<AdminMenuPO> list, Map<Long, List<AdminPermissionPO>> mapPermission) {
        List<AdminMenuPO> listChild = list.stream()
                .filter(c -> c.getParentId().equals(view.getId()))
                .collect(Collectors.toList());
        view.setChildren(new ArrayList<>());
        if (ListUtil.isNullOrEmpty(listChild)) {
            return;
        }
        listChild = listChild.stream()
                .sorted(Comparator.comparing(AdminMenuPO::getSort).reversed())
                .collect(Collectors.toList());
        for (AdminMenuPO child : listChild) {
            ResAdminMenuTreeAndPermission viewChild = AdminMenuConvert.INSTANCE.toTreeVo(child);
            this.fillChildMenu(viewChild, list, mapPermission);
            this.fillPermission4Menu(viewChild, mapPermission);
            view.getChildren().add(viewChild);
        }
    }

    // 获取指定菜单的子级菜单
    public ExecutedResult<List<AdminMenuVO>> getListChildMenu(Long parentId) {
        List<AdminMenuPO> list = menusDao.list4Parent(parentId);
        if (ListUtil.isNullOrEmpty(list)) {
            return ExecutedResult.success(new ArrayList<>());
        }
        return ExecutedResult.success(AdminMenuConvert.INSTANCE.toVo(list));
    }

    // 分页查询菜单
    public ExecutedResult<PagerResult<AdminMenuVO>> searchMenu(SearchAdminMenu request) {
        List<AdminMenuVO> result = new ArrayList<>();

        super.dealPager(request);
        request.setLastRowNo((request.getPage() - 1) * NumericUtil.tryParseLong(request.getLimit()));
        // 处理时间范围
        Tuple<String, String> createTimeRange = ParameterUtil.getTimeRange(request.getCreateTimeRange());
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem1())) {
            request.setCreateTimeStart(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem1()).getTime());
        }
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem2())) {
            request.setCreateTimeEnd(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem2()).getTime());
        }
        if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
            request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
        }

        PagerResult<AdminMenuPO> pagerResult = menusDao.search(request);

        if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
            return ExecutedResult.success(
                    new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
            );
        }
        List<AdminMenuPO> list = pagerResult.getList();
        Long lastId = 0L;
        if (ListUtil.isNotNullOrEmpty(list)) {
            lastId = list.stream().map(AdminMenuPO::getId).min(Comparator.comparing(c -> c)).get();
            result = AdminMenuConvert.INSTANCE.toVo(list);
        }
        PagerResult<AdminMenuVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
        view.setLastId(lastId);
        return ExecutedResult.success(view);
    }

    // 创建权限
    public ExecutedResult<Long> createPermission(ReqCreateAdminPermission request) {
        String sn = request.getSn();
        AdminPermissionPO find = permissionDao.get4Sn(sn);
        if (Objects.nonNull(find) && find.getId().compareTo(0L) > 0) {
            return ExecutedResult.failed("权限编码已存在。" + sn);
        }
        ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getMenuId());
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        AdminPermissionPO item = new AdminPermissionPO();
        item.setName(request.getName());
        item.setSn(request.getSn());
        item.setMenuId(request.getMenuId());
        item.setMenuId(request.getMenuId());
        item.setStatus(EState.NORMAL.getValue());
        item.setMenuUrl(ParameterUtil.dealNullStr(request.getMenuUrl()));
        item.setIcon(ParameterUtil.dealNullStr(request.getIcon()));
        item.setType(ParameterUtil.dealNullStr(request.getType()));
        item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
        int rowCount = permissionDao.insert(item);
        if (rowCount == 1) {
            // 删除权限缓存
            permissionService.removeListAllCache();
            return ExecutedResult.success(item.getId());
        }
        return ExecutedResult.failed("创建[权限]失败。");
    }

    // 编辑权限
    public ExecutedResult<String> modifyPermission(ReqModifyAdminPermission request) {
        Long id = request.getId();
        String sn = request.getSn();
        ExecutedResult<AdminPermissionPO> checkExists = this.checkPermissionId(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminPermissionPO findBySn = permissionDao.get4Sn(sn);
        if (Objects.nonNull(findBySn) && !Objects.equals(id, findBySn.getId())) {
            return ExecutedResult.failed("权限编码已存在。" + sn);
        }
        ExecutedResult<AdminMenuPO> check = this.checkMenuId(request.getMenuId());
        if (check.isFailed()) {
            return ExecutedResult.failed(check.getMsg());
        }

        AdminPermissionPO item = new AdminPermissionPO();
        item.setId(id);
        item.setSn(request.getSn());
        item.setMenuId(request.getMenuId());
        item.setName(request.getName());
        int rowCount = permissionDao.updateById(item);
        if (rowCount == 1) {
            // 删除权限缓存
            permissionService.removeListAllCache();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("编辑[权限]失败。");
    }
    private ExecutedResult<AdminPermissionPO> checkPermissionId(Long id) {
        AdminPermissionPO item = permissionDao.get(id);
        if (Objects.isNull(item)) {
            return ExecutedResult.failed("[权限]不存在: " + id);
        }
        return ExecutedResult.success(item);
    }

    // 删除权限
    public ExecutedResult<String> removePermission(Long id) {
        AdminPermissionPO find = permissionDao.get(id);
        if (null == find) {
            return ExecutedResult.failed("[权限]记录未找到。" + id);
        }
        Boolean remove = permissionDao.remove(id);
        if (remove) {
            // 删除权限缓存
            permissionService.removeListAllCache();
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("删除[权限]失败");
    }

    // 分页查询权限
    public ExecutedResult<PagerResult<ResAdminPermission>> searchPermission(SearchAdminPermission request) {
        List<ResAdminPermission> result = new ArrayList<>();

        super.dealPager(request);
        request.setLastRowNo((request.getPage() - 1) * NumericUtil.tryParseLong(request.getLimit()));
        // 处理时间范围
        Tuple<String, String> createTimeRange = ParameterUtil.getTimeRange(request.getCreateTimeRange());
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem1())) {
            request.setCreateTimeStart(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem1()).getTime());
        }
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem2())) {
            request.setCreateTimeEnd(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem2()).getTime());
        }
        if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
            request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
        }
        PagerResult<AdminPermissionPO> pagerResult = permissionDao.search(request);

        if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
            return ExecutedResult.success(
                    new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
            );
        }
        List<AdminPermissionPO> list = pagerResult.getList();
        Long lastId = 0L;
        if (ListUtil.isNotNullOrEmpty(list)) {
            lastId = list.stream().map(AdminPermissionPO::getId).min(Comparator.comparing(c -> c)).get();
            result = AdminPermissionConvert.INSTANCE.toDetail(list);
        }
        PagerResult<ResAdminPermission> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
        view.setLastId(lastId);
        return ExecutedResult.success(view);
    }

    // 创建角色
    public ExecutedResult<Long> createRole(ReqCreateAdminRole request) {
        AdminRolePO item = AdminRoleConvert.INSTANCE.toCreate(request);
        item.setDescription(ParameterUtil.dealNullStr(request.getDescription()));
        item.setStatus(EState.NORMAL.getValue());
        item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
        item.setCreateTime(LocalDateTimeUtil.nowTimeStamp());
        int rowCount = roleDao.insert(item);
        if (rowCount == 1) {
            return ExecutedResult.success(item.getId());
        }
        return ExecutedResult.failed("创建[角色]失败。");
    }

    // 编辑角色
    public ExecutedResult<String> modifyRole(ReqModifyAdminRole request) {
        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(request.getId());
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminRolePO item = AdminRoleConvert.INSTANCE.toModify(request);
        item.setSort(NumericUtil.tryParseInt(request.getSort(), 0));
        item.setDescription(ParameterUtil.dealNullStr(request.getDescription()));
        int rowCount = roleDao.updateById(item);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("编辑[角色]失败。");
    }

    // 修改角色状态
    public ExecutedResult<String> changeRoleStatus(Long id, EState status) {
        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminRolePO upd = new AdminRolePO();
        upd.setId(id);
        upd.setStatus(status.getValue());
        int rowCount = roleDao.updateById(upd);
        if (rowCount == 1) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("修改[角色]状态失败。");
    }
    private ExecutedResult<AdminRolePO> checkRoleId(Long id) {
        AdminRolePO item = roleDao.selectById(id);
        if (Objects.isNull(item)) {
            return ExecutedResult.failed("[角色]不存在: " + id);
        }
        return ExecutedResult.success(item);
    }
    private ExecutedResult<List<AdminRolePO>> checkRoleId(List<Long> listId) {
        // 从数据库查找测试信息
        List<AdminRolePO> list = roleDao.getList(listId);
        if (ListUtil.isNullOrEmpty(list)) {
            return ExecutedResult.failed("[角色]不存在." + listId);
        }
        // 数据库找到的id列表
        List<Long> listIdFind = list.stream().map(AdminRolePO::getId).collect(Collectors.toList());
        // 数量不一致
        if (listId.size() != listIdFind.size()) {
            // 筛选数据库不存在的测试信息
            List<Long> listIdNotFound = listId.stream().filter(c -> !listIdFind.contains(c)).collect(Collectors.toList());
            if (ListUtil.isNullOrEmpty(list)) {
                return ExecutedResult.failed("[角色]不存在." + listIdNotFound);
            }
        }
        return ExecutedResult.success(list);
    }

    public ExecutedResult<String> removeRole(Long id) {
        // 验证记录是否存在
        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(id);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        Boolean result = roleDao.deleteLogic(id);
        if (BooleanUtils.isFalse(result)) {
            return ExecutedResult.failed("删除[角色]失败。");
        }
        return ExecutedResult.success();
    }

    public ExecutedResult<String> removeRoleList(List<Long> listId) {
        // 验证记录是否存在
        ExecutedResult<List<AdminRolePO>> checkExists = this.checkRoleId(listId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        Boolean result = roleDao.deleteLogic(listId);
        if (BooleanUtils.isFalse(result)) {
            return ExecutedResult.failed("删除[角色]失败。");
        }
        return ExecutedResult.success();
    }

    // 分页查询角色
    public ExecutedResult<PagerResult<AdminRoleVO>> searchRole(SearchAdminRole request) {
        List<AdminRoleVO> result = new ArrayList<>();

        super.dealPager(request);
        request.setLastRowNo((request.getPage() - 1) * NumericUtil.tryParseLong(request.getLimit()));
        // 处理时间范围
        Tuple<String, String> createTimeRange = ParameterUtil.getTimeRange(request.getCreateTimeRange());
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem1())) {
            request.setCreateTimeStart(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem1()).getTime());
        }
        if (StringUtil.isNotNullOrEmpty(createTimeRange.getItem2())) {
            request.setCreateTimeEnd(LocalDateTimeUtil.getTimeStamp(createTimeRange.getItem2()).getTime());
        }
        if (NumericUtil.tryParseInt(request.getStatus(), 0).compareTo(0) < 1 && ListUtil.isNullOrEmpty(request.getListStatus())) {
            request.setListStatus(Arrays.asList(EState.NORMAL.getValue(), EState.DISABLED.getValue()));
        }

        PagerResult<AdminRolePO> pagerResult = roleDao.search(request);

        if (NumericUtil.tryParseLong(pagerResult.getTotal()).compareTo(0L) < 1) {
            return ExecutedResult.success(
                    new PagerResult<>(request.getLimit(), request.getPage(), 0L, new ArrayList<>())
            );
        }
        List<AdminRolePO> list = pagerResult.getList();
        Long lastId = 0L;
        if (ListUtil.isNotNullOrEmpty(list)) {
            lastId = list.stream().map(AdminRolePO::getId).min(Comparator.comparing(c -> c)).get();
            result = AdminRoleConvert.INSTANCE.toVo(list);
        }
        PagerResult<AdminRoleVO> view = new PagerResult<>(request.getLimit(), request.getPage(), pagerResult.getTotal(), result);
        view.setLastId(lastId);
        return ExecutedResult.success(view);
    }

    // 设置角色菜单权限列表
    public ExecutedResult<String> setListMenu4Role(ReqSetListMenu4Role request) {
        Long roleId = request.getId();
        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(roleId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminRolePO find = checkExists.getData();
        Long now = LocalDateTimeUtil.nowTimeStamp();

        //找到角色已有的菜单列表
        List<AdminRoleMenuRelationPO> listOld = roleMenuRelationDao.list4Role(roleId);
        listOld = ParameterUtil.dealNull(listOld);
        List<Long> listOldMenuId = listOld.stream()
                .map(AdminRoleMenuRelationPO::getMenuId)
                .collect(Collectors.toList());

        //现在设置的菜单id列表
        List<Long> listMenuId = ParameterUtil.dealNull(request.getListMenu());

        //找到所有菜单
        List<Long> listAllId = new ArrayList<>(listOldMenuId);
        listAllId.addAll(listMenuId);
        ListUtil.repeat(listAllId);
        List<AdminMenuPO> listMenu = menusDao.getList(listAllId);
        Map<Long, AdminMenuPO> mapMenu = listMenu.stream()
                .collect(Collectors.toMap(AdminMenuPO::getId, c -> c));

        //找到新增菜单列表(新菜单列表的元素，不存在于已有的菜单列表中)
        List<Long> listNew = listMenuId.stream()
                .filter(c -> !listOldMenuId.contains(c))
                .collect(Collectors.toList());
        //找到删除菜单列表(已有菜单列表的元素，不存在于新菜单列表)
        List<Long> listRemove = listOldMenuId.stream()
                .filter(c -> !listMenuId.contains(c))
                .collect(Collectors.toList());

        //批量新增
        if(BooleanUtils.isFalse(listNew.isEmpty())) {
            List<AdminRoleMenuRelationPO> list = listNew.stream()
                    .map(c -> {
                        AdminRoleMenuRelationPO item = new AdminRoleMenuRelationPO();
                        item.setRoleId(roleId);
                        item.setMenuId(c);
                        item.setCreateTime(now);
                        return item;
                    }).collect(Collectors.toList());
            Boolean addList = roleMenuRelationDao.addList(list);
            if(BooleanUtils.isFalse(addList)) {
                return ExecutedResult.failed("给角色“" + roleId + "”新增菜单失败。" + listNew);
            }
        }
        //批量删除
        if(BooleanUtils.isFalse(listRemove.isEmpty())) {
            List<Long> listId = listOld.stream()
                    .filter(c -> listRemove.contains(c.getMenuId()))
                    .map(AdminRoleMenuRelationPO::getId).collect(Collectors.toList());
            Boolean removeList = roleMenuRelationDao.remove(listId);
            if(BooleanUtils.isFalse(removeList)) {
                return ExecutedResult.failed("删除角色“" + roleId + "”已有菜单失败。" + listRemove);
            }
        }



        //找到角色已有的权限列表
        List<AdminRolePermissionRelationPO> listOldPermission = rolePermissionRelationDao.list4Role(roleId);
        listOldPermission = ParameterUtil.dealNull(listOldPermission);
        List<Long> listOldPermissionId = listOldPermission.stream()
                .map(AdminRolePermissionRelationPO::getPermissionId)
                .collect(Collectors.toList());

        //现在设置的权限id列表
        List<Long> listPermissionId = ParameterUtil.dealNull(request.getListPermission());

        //找到所有权限
        List<Long> listAllPermissionId = new ArrayList<>(listOldPermissionId);
        listAllPermissionId.addAll(listPermissionId);
        ListUtil.repeat(listAllPermissionId);
        List<AdminPermissionPO> listPermission = permissionDao.getList(listAllPermissionId);
        Map<Long, AdminPermissionPO> mapPermission = listPermission.stream()
                .collect(Collectors.toMap(AdminPermissionPO::getId, c -> c));

        //找到新增权限列表(新权限列表的元素，不存在于已有的菜单列表中)
        List<Long> listNewPermission = listPermissionId.stream()
                .filter(c -> !listOldPermissionId.contains(c))
                .collect(Collectors.toList());
        //找到删除权限列表(已有权限列表的元素，不存在于新菜单列表)
        List<Long> listRemovePermission = listOldPermissionId.stream()
                .filter(c -> !listPermissionId.contains(c))
                .collect(Collectors.toList());

        //批量新增
        if(BooleanUtils.isFalse(listNewPermission.isEmpty())) {
            List<AdminRolePermissionRelationPO> list = listNewPermission.stream()
                    .map(c -> {
                        AdminRolePermissionRelationPO item = new AdminRolePermissionRelationPO();
                        item.setRoleId(roleId);
                        item.setPermissionId(c);
                        item.setCreateTime(now);
                        return item;
                    }).collect(Collectors.toList());
            Boolean addList = rolePermissionRelationDao.addList(list);
            if(BooleanUtils.isFalse(addList)) {
                return ExecutedResult.failed("给角色“" + roleId + "”新增权限失败。" + listNewPermission);
            }
        }
        //批量删除
        if(BooleanUtils.isFalse(listRemovePermission.isEmpty())) {
            List<Long> listId = listOldPermission.stream()
                    .filter(c -> listRemovePermission.contains(c.getPermissionId()))
                    .map(AdminRolePermissionRelationPO::getId).collect(Collectors.toList());
            Boolean removeList = rolePermissionRelationDao.remove(listId);
            if(BooleanUtils.isFalse(removeList)) {
                return ExecutedResult.failed("删除角色“" + roleId + "”已有权限失败。" + listRemovePermission);
            }
        }
        return ExecutedResult.success();
    }

    // 获取角色菜单权限列表
    public ExecutedResult<ResAdminPower> getListMenu4Role(Long roleId) {
        ResAdminPower result = new ResAdminPower();
        result.setMenus(new ArrayList<>());
        result.setPermissions(new ArrayList<>());

        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(roleId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }
        AdminRolePO find = checkExists.getData();
        //找到角色已有的菜单列表
        List<AdminRoleMenuRelationPO> listMenu4Role = roleMenuRelationDao.list4Role(roleId);
        if (ListUtil.isNotNullOrEmpty(listMenu4Role)) {
            List<Long> listOldMenuId = listMenu4Role.stream()
                    .map(AdminRoleMenuRelationPO::getMenuId)
                    .collect(Collectors.toList());
            List<AdminMenuPO> listMenu = menusDao.getList(listOldMenuId);
            if (ListUtil.isNotNullOrEmpty(listMenu)) {
                result.setMenus(AdminMenuConvert.INSTANCE.toVo(listMenu));
            }
        }
        //找到角色已有的权限列表
        List<AdminRolePermissionRelationPO> listPermission4Role = rolePermissionRelationDao.list4Role(roleId);
        if (ListUtil.isNotNullOrEmpty(listPermission4Role)) {
            List<Long> listPermissionId = listPermission4Role.stream()
                    .map(AdminRolePermissionRelationPO::getPermissionId)
                    .collect(Collectors.toList());
            List<AdminPermissionPO> listPermission = permissionDao.getList(listPermissionId);
            if (ListUtil.isNotNullOrEmpty(listPermission)) {
                result.setPermissions(AdminPermissionConvert.INSTANCE.toDetail(listPermission));
            }
        }
        return ExecutedResult.success(result);
    }

    protected List<AdminPermissionPO> getListPermission4Role(List<Long> listRoleId) {
        List<AdminRolePermissionRelationPO> listPermissionRel = rolePermissionRelationDao.list4Role(listRoleId);
        if (ListUtil.isNullOrEmpty(listPermissionRel)) {
            return new ArrayList<>();
        }
        List<AdminPermissionPO> listPermission = permissionService.listAllWithCache();
        if (ListUtil.isNullOrEmpty(listPermission)) {
            return new ArrayList<>();
        }
        // 筛选状态
        listPermission = listPermission.stream()
                .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                .collect(Collectors.toList());
        List<Long> listPermissionId = listPermissionRel.stream()
                .map(AdminRolePermissionRelationPO::getPermissionId)
                .collect(Collectors.toList());
        return listPermission.stream()
                .filter(c -> listPermissionId.contains(c.getId()))
                .collect(Collectors.toList());
    }

    protected List<AdminMenuPO> getListMenu4Role(List<Long> listRoleId) {
        List<AdminRoleMenuRelationPO> listRoleMenu = roleMenuRelationDao.list4Role(listRoleId);
        if (ListUtil.isNullOrEmpty(listRoleMenu)) {
            return new ArrayList<>();
        }
        List<AdminMenuPO> listMenu = menusService.listAllWithCache();
        if (ListUtil.isNullOrEmpty(listMenu)) {
            return new ArrayList<>();
        }
        // 筛选状态
        listMenu = listMenu.stream()
                .filter(c -> Objects.equals(c.getStatus(), EState.NORMAL.getValue()))
                .collect(Collectors.toList());
        List<Long> listMenuId = listRoleMenu.stream().map(AdminRoleMenuRelationPO::getMenuId)
                .collect(Collectors.toList());
        return listMenu.stream()
                .filter(c -> listMenuId.contains(c.getId()))
                .collect(Collectors.toList());
    }

    /**
     * 删除指定用户的菜单和权限缓存
     * @param userId 用户id
     */
    protected void removePower4User(Long userId) {
        menusService.removeUserMenuCache(userId);
        permissionService.removeUserCache(userId);
    }
    /**
     * 删除所有用户的菜单和权限缓存
     */
    protected void removePowerAllUser() {
        menusService.removeAllUserMenuCache();
        permissionService.removeAllUserCache();
    }

    public ExecutedResult<String> setMenuSort(ReqSetSort request) {
        // 验证记录是否存在
        ExecutedResult<AdminMenuPO> checkExists = this.checkMenuId(request.getId());
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        AdminMenuPO item = new AdminMenuPO();
        item.setId(request.getId());
        item.setSort(request.getSort());

        int rowCount = menusDao.updateById(item);
        if (rowCount != 1) {
            return ExecutedResult.failed("[测试信息]设置排序值失败。");
        }
        return ExecutedResult.success();
    }

    public ExecutedResult<String> listSetMenuSort(ReqListSetSort request) {
        // id列表
        List<Long> listId = request.getList().stream().map(ReqSetSort::getId).collect(Collectors.toList());
        // 验证记录是否存在
        ExecutedResult<List<AdminMenuPO>> checkExists = this.checkMenuId(listId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        List<AdminMenuPO> listUpdate = request.getList().stream()
                .map(c -> {
                    AdminMenuPO item = new AdminMenuPO();
                    item.setId(c.getId());
                    item.setSort(c.getSort());
                    return item;
                })
                .collect(Collectors.toList());
        Boolean result = menusDao.modifyList(listUpdate);
        if (result) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("[测试信息]设置排序值失败");
    }

    public ExecutedResult<String> setRoleSort(ReqSetSort request) {
        // 验证记录是否存在
        ExecutedResult<AdminRolePO> checkExists = this.checkRoleId(request.getId());
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        AdminRolePO item = new AdminRolePO();
        item.setId(request.getId());
        item.setSort(request.getSort());

        int rowCount = roleDao.updateById(item);
        if (rowCount != 1) {
            return ExecutedResult.failed("[角色]设置排序值失败。");
        }
        return ExecutedResult.success();
    }

    public ExecutedResult<String> listSetRoleSort(ReqListSetSort request) {
        // id列表
        List<Long> listId = request.getList().stream().map(ReqSetSort::getId).collect(Collectors.toList());
        // 验证记录是否存在
        ExecutedResult<List<AdminRolePO>> checkExists = this.checkRoleId(listId);
        if (checkExists.isFailed()) {
            return ExecutedResult.failed(checkExists.getMsg());
        }

        List<AdminRolePO> listUpdate = request.getList().stream()
                .map(c -> {
                    AdminRolePO item = new AdminRolePO();
                    item.setId(c.getId());
                    item.setSort(c.getSort());
                    return item;
                })
                .collect(Collectors.toList());
        Boolean result = roleDao.modifyList(listUpdate);
        if (result) {
            return ExecutedResult.success();
        }
        return ExecutedResult.failed("[角色]设置排序值失败");
    }
}