package com.monkeylessey.sys.service.impl;

import com.baomidou.mybatisplus.extension.conditions.query.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.monkeylessey.enums.general.MenuTypeEnum;
import com.monkeylessey.sys.domain.entity.SysMenu;
import com.monkeylessey.sys.domain.entity.SysOrg;
import com.monkeylessey.sys.domain.form.SysMenuForm;
import com.monkeylessey.sys.domain.query.SysMenuQuery;
import com.monkeylessey.sys.domain.tree.SysMenuTree;
import com.monkeylessey.sys.domain.tree.SysOrgTree;
import com.monkeylessey.sys.domain.vo.SysMenuVO;
import com.monkeylessey.exception.ServiceException;
import com.monkeylessey.sys.mapper.SysMenuMapper;
import com.monkeylessey.response.Result;
import com.monkeylessey.sys.service.SysMenuService;
import com.monkeylessey.framework.utils.SecurityUtil;
import com.monkeylessey.utils.TreeUtil;
import lombok.RequiredArgsConstructor;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

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

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 向培
 * @since 2022-05-14
 */
@Service
@RequiredArgsConstructor
public class SysMenuServiceImpl extends ServiceImpl<SysMenuMapper, SysMenu> implements SysMenuService {

    private final SysMenuMapper menuMapper;

    @Override
    public Result addMenu(SysMenuForm form) {
        form.checkNotBlank();
        SysMenu menuEntity = SysMenuForm.getMenuEntity(null, form);
        String s = SecurityUtil.getCurrentUserName();
        menuEntity.setCreateBy(s);
        if (Objects.isNull(menuEntity.getParentId())) {
            menuEntity.setParentId("0");
        }
        if (StringUtils.isNotBlank(form.getMenuPath())) {
            // 校验路由唯一
            List<SysMenu> menus = new LambdaQueryChainWrapper<>(baseMapper)
                    .eq(SysMenu::getMenuPath, form.getMenuPath())
                    .select(SysMenu::getMenuType)
                    .list();
            this.checkRepeat(menus, "菜单路径已存在");
        }
        if (StringUtils.isNotBlank(form.getPermission())) {
            // 校验权限唯一
            List<SysMenu> menus = new LambdaQueryChainWrapper<>(baseMapper)
                    .eq(SysMenu::getPermission, form.getPermission())
                    .select(SysMenu::getMenuType)
                    .list();
            this.checkRepeat(menus, "权限已存在");
        }

        baseMapper.insert(menuEntity);
        return Result.ok("添加成功");
    }

    @Override
    public Result editMenu(SysMenuForm form) {
        form.checkNotBlank();
        if (StringUtils.isNotBlank(form.getMenuPath())) {
            // 校验路由唯一
            List<SysMenu> menus = new LambdaQueryChainWrapper<>(baseMapper)
                    .eq(SysMenu::getMenuPath, form.getMenuPath())
                    .select(SysMenu::getMenuType, SysMenu::getMenuPath,SysMenu::getId)
                    .ne(SysMenu::getId, form.getId())
                    .list();
            // 校路由限唯一
            this.checkRepeat(menus, "菜单路径已存在");
        }
        if (StringUtils.isNotBlank(form.getPermission())) {
            // 校验权限唯一
            List<SysMenu> menus = new LambdaQueryChainWrapper<>(baseMapper)
                    .eq(SysMenu::getPermission, form.getPermission())
                    .select(SysMenu::getMenuType, SysMenu::getMenuPath,SysMenu::getId)
                    .ne(SysMenu::getId, form.getId())
                    .list();
            // 校验权限唯一
            this.checkRepeat(menus, "权限已存在");
        }
        SysMenu menuEntity = SysMenuForm.getMenuEntity(null, form);
        String s = SecurityUtil.getCurrentUserName();
        menuEntity.setUpdateBy(s);
        try {
            baseMapper.updateById(menuEntity);
            return Result.ok("修改成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("修改失败");
        }
    }

    private void checkRepeat(List<SysMenu> menus, String errMsg) {
        if (! CollectionUtils.isEmpty(menus)) {
            throw new ServiceException(errMsg);
        }
    }

    @Override
    public Result deleteMenuById(String menuId) {
        try {
            baseMapper.deleteById(menuId);
            return Result.ok("删除成功");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error("删除失败");
        }
    }

    @Override
    public Result selectMenuByPage(SysMenuQuery query) {
        List<SysMenu> menuList = new LambdaQueryChainWrapper<>(baseMapper)
                .like(StringUtils.isNotBlank(query.getMenuName()), SysMenu::getMenuName, query.getMenuName())
                .orderByAsc(SysMenu::getOrderNum)
                .list();
        List<SysMenuTree> vos = menuList.stream().map(menu -> {
            SysMenuTree vo = SysMenuTree.getVoByEntity(menu, null);
            return vo;
        }).collect(Collectors.toList());
        List<SysMenuTree> tree = TreeUtil.buildTree(vos);
        tree.sort(Comparator.comparing(SysMenuTree::getOrderNum));
        return Result.ok().data(tree).total(tree.size());
    }

    @Override
    public Result selectMenuTree(SysMenuQuery query) {
        List<SysMenu> menuList = new LambdaQueryChainWrapper<>(baseMapper)
                .like(StringUtils.isNotBlank(query.getMenuName()), SysMenu::getMenuName, query.getMenuName())
                .in(query.getExcludeBtn(), SysMenu::getMenuType, MenuTypeEnum.CATALOGUE, MenuTypeEnum.MENU)
                .orderByAsc(SysMenu::getOrderNum)
                .list();
        List<SysMenuTree> vos = menuList.stream().map(menu -> {
            SysMenuTree vo = SysMenuTree.getVoByEntity(menu, null);
            if (StringUtils.isNotBlank(query.getId()) && vo.getId().equals(query.getId())) {
                vo.setDisabled(Boolean.TRUE);
            }
            return vo;
        }).collect(Collectors.toList());
        List<SysMenuTree> tree = TreeUtil.buildTree(vos);
        tree.sort(Comparator.comparing(SysMenuTree::getOrderNum));
        return Result.ok().data(tree).total(tree.size());
    }

    @Override
    public Result selectMenuById(String menuId) {
        SysMenuVO sysMenuVO = menuMapper.selectMenuById(menuId);
        if ("0".equals(sysMenuVO.getParentId())) {
            sysMenuVO.setParentName("主目录");
        } else {
            SysMenu one = new LambdaQueryChainWrapper<>(baseMapper)
                    .select(SysMenu::getMenuName)
                    .eq(Objects.nonNull(sysMenuVO.getParentId()), SysMenu::getId, sysMenuVO.getParentId()).one();
            if (one != null) {
                sysMenuVO.setParentName(one.getMenuName());
            }
        }
        return Result.ok("").data(sysMenuVO);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result deleteMenuByIds(List<String> ids) {
        return Result.ok("操作成功").data(baseMapper.deleteBatchIds(ids));
    }

    @Override
    public Result menuList() {
        List<SysMenu> sysMenus = baseMapper.selectList(null);
        List<SysMenuVO> vos = sysMenus.stream()
                .map(menu -> SysMenuVO.getVoByEntity(menu, null))
                .collect(Collectors.toList());
        return Result.ok().data(vos);
    }

}