package com.qianwen.smartman.modules.system.service.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.qianwen.core.log.exception.ServiceException;
import com.qianwen.core.secure.BladeUser;
import com.qianwen.core.secure.utils.AuthUtil;
import com.qianwen.core.tool.constant.BladeConstant;
import com.qianwen.core.tool.node.ForestNodeMerger;
import com.qianwen.core.tool.support.Kv;
import com.qianwen.core.tool.utils.Func;
import com.qianwen.core.tool.utils.StringUtil;
import com.qianwen.smartman.common.constant.CommonConstant;
import com.qianwen.smartman.common.enums.MenuCategoryEnum;
import com.qianwen.smartman.modules.system.dto.MenuDTO;
import com.qianwen.smartman.modules.system.entity.Menu;
import com.qianwen.smartman.modules.system.entity.RoleMenu;
import com.qianwen.smartman.modules.system.entity.RoleScope;
import com.qianwen.smartman.modules.system.entity.TopMenuSetting;
import com.qianwen.smartman.modules.system.mapper.MenuMapper;
import com.qianwen.smartman.modules.system.service.IMenuService;
import com.qianwen.smartman.modules.system.service.IRoleMenuService;
import com.qianwen.smartman.modules.system.service.IRoleScopeService;
import com.qianwen.smartman.modules.system.service.ITopMenuSettingService;
import com.qianwen.smartman.modules.system.vo.MenuVO;
import com.qianwen.smartman.modules.system.wrapper.MenuWrapper;

@Service
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements IMenuService {
    private static final String PARENT_ID = "parentId";
    private static final Integer MENU_CATEGORY = 1;
    private final IRoleMenuService roleMenuService;
    private final IRoleScopeService roleScopeService;
    private final ITopMenuSettingService topMenuSettingService;


    public MenuServiceImpl(final IRoleMenuService roleMenuService, final IRoleScopeService roleScopeService, final ITopMenuSettingService topMenuSettingService) {
        this.roleMenuService = roleMenuService;
        this.roleScopeService = roleScopeService;
        this.topMenuSettingService = topMenuSettingService;
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> lazyList(Long parentId, Map<String, Object> param) {
        if (Func.isEmpty(Func.toStr(param.get(PARENT_ID)))) {
            parentId = null;
        }
        return ((MenuMapper) this.baseMapper).lazyList(parentId, param);
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> lazyMenuList(Long parentId, Map<String, Object> param) {
        if (Func.isEmpty(Func.toStr(param.get(PARENT_ID)))) {
            parentId = null;
        }
        return ((MenuMapper) this.baseMapper).lazyMenuList(parentId, param);
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> routes(String roleId, Long topMenuId) {
        List<Menu> roleMenus;
        if (StringUtil.isBlank(roleId)) {
            return null;
        }
        List<Menu> allMenus = ((MenuMapper) this.baseMapper).allMenu();
        if (AuthUtil.isAdministrator() && Func.isEmpty(topMenuId)) {
            roleMenus = allMenus;
        } else if (!AuthUtil.isAdministrator()) {
            roleMenus = ((MenuMapper) this.baseMapper).roleMenuByRoleId(Func.toLongList(roleId));
        } else {
            List<Menu> roleIdMenus = ((MenuMapper) this.baseMapper).roleMenuByRoleId(Func.toLongList(roleId));
            List<Menu> routes = new LinkedList<>(roleIdMenus);
            roleIdMenus.forEach(roleMenu -> {
                recursion(allMenus, routes, roleMenu);
            });
            List<Menu> topIdMenus = ((MenuMapper) this.baseMapper).roleMenuByTopMenuId(topMenuId);
            roleMenus = topIdMenus.stream().filter(x -> {
                return routes.stream().anyMatch(route -> {
                    return route.getId().longValue() == x.getId().longValue();
                });
            }).collect(Collectors.toList());
        }
        return buildRoutes(allMenus, roleMenus);
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> routesExt(String roleId, Long topMenuId) {
        if (StringUtil.isBlank(roleId)) {
            return null;
        }
        List<Menu> allMenus = ((MenuMapper) this.baseMapper).allMenuExt();
        List<Menu> roleMenus = ((MenuMapper) this.baseMapper).roleMenuExt(Func.toLongList(roleId), topMenuId);
        return buildRoutes(allMenus, roleMenus);
    }

    private List<MenuVO> buildRoutes(List<Menu> allMenus, List<Menu> roleMenus) {
        List<Menu> routes = new LinkedList<>(roleMenus);
        roleMenus.forEach(roleMenu -> {
            recursion(allMenus, routes, roleMenu);
        });
        routes.sort(Comparator.comparing((v0) -> {
            return v0.getSort();
        }));
        MenuWrapper menuWrapper = new MenuWrapper();
        List<Menu> collect = routes.stream().filter(x -> {
            return Func.equals(x.getCategory(), Integer.valueOf(MenuCategoryEnum.APP.getStatus())) || Func.equals(x.getCategory(), Integer.valueOf(MenuCategoryEnum.MENU.getStatus()));
        }).collect(Collectors.toList());
        return menuWrapper.listNodeVO(collect);
    }

    private void recursion(List<Menu> allMenus, List<Menu> routes, Menu roleMenu) {
        Optional<Menu> menu = allMenus.stream().filter(x -> {
            return Func.equals(x.getId(), roleMenu.getParentId());
        }).findFirst();
        if (menu.isPresent() && !routes.contains(menu.get())) {
            routes.add(menu.get());
            recursion(allMenus, routes, menu.get());
        }
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> buttons(String roleId) {
        List<Menu> buttons = AuthUtil.isAdministrator() ? ((MenuMapper) this.baseMapper).allButtons() : ((MenuMapper) this.baseMapper).buttons(Func.toLongList(roleId));
        MenuWrapper menuWrapper = new MenuWrapper();
        return menuWrapper.listNodeVO(buttons);
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> tree() {
        return ForestNodeMerger.merge(((MenuMapper) this.baseMapper).tree());
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantTree(BladeUser user) {
        return ForestNodeMerger.merge(user.getTenantId().equals("000000") ? ((MenuMapper) this.baseMapper).grantTree() : ((MenuMapper) this.baseMapper).grantTreeByRole(Func.toLongList(user.getRoleId())));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantTreeByCategory(BladeUser user, List<Integer> categoryList) {
        return ForestNodeMerger.merge(user.getTenantId().equals("000000") ? ((MenuMapper) this.baseMapper).grantTreeByCategory(categoryList) : ((MenuMapper) this.baseMapper).grantTreeByRole(Func.toLongList(user.getRoleId())));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantTopTree(BladeUser user) {
        return ForestNodeMerger.merge(user.getTenantId().equals("000000") ? ((MenuMapper) this.baseMapper).grantTopTree() : ((MenuMapper) this.baseMapper).grantTopTreeByRole(Func.toLongList(user.getRoleId())));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantDataScopeTree(BladeUser user) {
        return ForestNodeMerger.merge(user.getTenantId().equals("000000") ? ((MenuMapper) this.baseMapper).grantDataScopeTree() : ((MenuMapper) this.baseMapper).grantDataScopeTreeByRole(Func.toLongList(user.getRoleId())));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantApiScopeTree(BladeUser user) {
        return ForestNodeMerger.merge(user.getTenantId().equals("000000") ? ((MenuMapper) this.baseMapper).grantApiScopeTree() : ((MenuMapper) this.baseMapper).grantApiScopeTreeByRole(Func.toLongList(user.getRoleId())));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<String> roleTreeKeys(String roleIds) {
    	List<RoleMenu> roleMenus = this.roleMenuService.list(Wrappers.<RoleMenu>query().lambda().in(RoleMenu::getRoleId, Func.toLongList(roleIds)));
    	/*
        List<RoleMenu> roleMenus = this.roleMenuService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getRoleId();
        }, Func.toLongList(roleIds)));*/
        return roleMenus.stream().map(roleMenu -> {
            return Func.toStr(roleMenu.getMenuId());
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<String> topTreeKeys(String topMenuIds) {
    	List<TopMenuSetting> settings = this.topMenuSettingService.list(Wrappers.<TopMenuSetting>query().lambda().in(TopMenuSetting::getTopMenuId, Func.toLongList(topMenuIds)));
    	/*
        List<TopMenuSetting> settings = this.topMenuSettingService.list((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getTopMenuId();
        }, Func.toLongList(topMenuIds)));*/
        return settings.stream().map(setting -> {
            return Func.toStr(setting.getMenuId());
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<String> dataScopeTreeKeys(String roleIds) {
    	List<RoleScope> roleScopes = this.roleScopeService.list(Wrappers.<RoleScope>query().lambda().eq(RoleScope::getScopeCategory, CommonConstant.DATA_SCOPE_CATEGORY).in(RoleScope::getRoleId, Func.toLongList(roleIds)));
    	/*
        List<RoleScope> roleScopes = this.roleScopeService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getScopeCategory();
        }, CommonConstant.DATA_SCOPE_CATEGORY)).in((v0) -> {
            return v0.getRoleId();
        }, Func.toLongList(roleIds)));*/
        return roleScopes.stream().map(roleScope -> {
            return Func.toStr(roleScope.getScopeId());
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<String> apiScopeTreeKeys(String roleIds) {
    	List<RoleScope> roleScopes = this.roleScopeService.list(Wrappers.<RoleScope>query().lambda().eq(RoleScope::getScopeCategory, CommonConstant.API_SCOPE_CATEGORY).in(RoleScope::getRoleId, Func.toLongList(roleIds)));
    	/*
        List<RoleScope> roleScopes = this.roleScopeService.list((Wrapper) ((LambdaQueryWrapper) Wrappers.query().lambda().eq((v0) -> {
            return v0.getScopeCategory();
        }, CommonConstant.API_SCOPE_CATEGORY)).in((v0) -> {
            return v0.getRoleId();
        }, Func.toLongList(roleIds)));*/
        return roleScopes.stream().map(roleScope -> {
            return Func.toStr(roleScope.getScopeId());
        }).collect(Collectors.toList());
    }

    @Override // org.springblade.modules.system.service.IMenuService
    @Cacheable(cacheNames = {"blade:menu"}, key = "'auth:routes:' + #user.roleId")
    public List<Kv> authRoutes(BladeUser user) {
        List<MenuDTO> routes = ((MenuMapper) this.baseMapper).authRoutes(Func.toLongList(user.getRoleId()));
        List<Kv> list = new ArrayList<>();
        routes.forEach(route -> {
            list.add(Kv.create().set(route.getPath(), Kv.create().set("authority", Func.toStrArray(route.getAlias()))));
        });
        return list;
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public boolean removeMenu(String ids) {
    	Long cnt = this.baseMapper.selectCount(Wrappers.<Menu>query().lambda().in(Menu::getParentId, Func.toLongList(ids)));
    	/*
        Long cnt = ((MenuMapper) this.baseMapper).selectCount((Wrapper) Wrappers.query().lambda().in((v0) -> {
            return v0.getParentId();
        }, Func.toLongList(ids)));*/
        if (cnt.longValue() > 0) {
            throw new ServiceException("请先删除子节点!");
        }
        return removeByIds(Func.toLongList(ids));
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public boolean submit(Menu menu) {
        Menu parentMenu;
        
        LambdaQueryWrapper<Menu> menuQueryWrapper = Wrappers.lambdaQuery();
        
        if (menu.getId() == null) {
        	menuQueryWrapper.eq(Menu::getCode, menu.getCode())
        	.or(wrapper -> wrapper.eq(Menu::getName, menu.getName()).eq(Menu::getCategory, MENU_CATEGORY).eq(Menu::getBelongApplication, menu.getBelongApplication()));
        	/*
            ((LambdaQueryWrapper) lambdaQuery.eq((v0) -> {
                return v0.getCode();
            }, menu.getCode())).or(wrapper -> {
                LambdaQueryWrapper lambdaQueryWrapper = (LambdaQueryWrapper) ((LambdaQueryWrapper) ((LambdaQueryWrapper) wrapper.eq((v0) -> {
                    return v0.getName();
                }, menu.getName())).eq((v0) -> {
                    return v0.getCategory();
                }, MENU_CATEGORY)).eq((v0) -> {
                    return v0.getBelongApplication();
                }, menu.getBelongApplication());
            });*/
        } else {
        	/*Menu::getBelongApplication
        	menuQueryWrapper.ne(Menu::getId, menu.getId())
        	.and(wrapper -> wrapper.eq(Menu::getCode, menu.getCode()).or(());*/
        	
        	menuQueryWrapper.ne(Menu::getId, menu.getId())
        	.and(wrapper2 -> {
                wrapper2.eq(Menu::getCode, menu.getCode()).or(o -> {
                    o.eq(Menu::getName, menu.getName())
                    .eq(Menu::getCategory, MENU_CATEGORY).eq(Menu::getBelongApplication, menu.getBelongApplication());
                });
            });
        }
        Long cnt = this.baseMapper.selectCount(menuQueryWrapper);
        if (cnt.longValue() > 0) {
            throw new ServiceException("菜单不能保存。限制条件：菜单编号不可重复；同一个应用下不可以出现同名菜单!");
        }
        if (menu.getParentId() == null && menu.getId() == null) {
            menu.setParentId(BladeConstant.TOP_PARENT_ID);
        }
        if (menu.getParentId() != null && menu.getId() == null && (parentMenu = (Menu) ((MenuMapper) this.baseMapper).selectById(menu.getParentId())) != null && parentMenu.getCategory().intValue() != 1 && parentMenu.getCategory().intValue() != 0) {
            throw new ServiceException("父节点只可选择App或者菜单类型!");
        }
        menu.setIsDeleted(0);
        return saveOrUpdate(menu);
    }

    /* JADX WARN: Multi-variable type inference failed */
    @Override // org.springblade.modules.system.service.IMenuService
    public List<String> getRoleMenuByCondition(String roleIds, List<Integer> categoryList) {
        List<String> list = new ArrayList<>();
        List<MenuVO> menuVOList = this.baseMapper.getRoleMenuByCondition(Arrays.stream(roleIds.split(",")).collect(Collectors.toList()), categoryList);
        if (Func.isNotEmpty(menuVOList)) {
            list = menuVOList.stream().map(menuVO -> {
                return Func.toStr(menuVO.getId());
            }).collect(Collectors.toList());
        }
        return list;
    }

    @Override // org.springblade.modules.system.service.IMenuService
    public List<MenuVO> grantTreeCard(BladeUser user, List<Integer> categoryList) {
    	List<MenuVO> roleMenus = new ArrayList<>();
    	
        if (AuthUtil.isAdministrator()) {
            roleMenus = ForestNodeMerger.merge(this.baseMapper.grantTreeByCategory(categoryList));
        } else {
            roleMenus = ForestNodeMerger.merge(this.baseMapper.getRoleMenuCardByCondition(Func.toStrList(user.getRoleId()), categoryList));
        }
        return roleMenus;
    }
}