package com.lxzn.ucenter.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.additional.query.impl.LambdaQueryChainWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.lxzn.framework.domain.ucenter.*;
import com.lxzn.framework.domain.ucenter.ext.MenuExt;
import com.lxzn.framework.domain.ucenter.request.MenuRequest;
import com.lxzn.framework.domain.ucenter.response.MenuCode;
import com.lxzn.framework.exception.ExceptionCast;
import com.lxzn.framework.model.response.CommonCode;
import com.lxzn.framework.model.response.CommonJsonTree;
import com.lxzn.framework.model.response.QueryPageResponseResult;
import com.lxzn.framework.utils.ValidateUtil;
import com.lxzn.ucenter.dao.MenuMapper;
import com.lxzn.ucenter.service.*;
import com.lxzn.ucenter.service.support.MenuTreeWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

@Service
public class MenuServiceImpl extends ServiceImpl<MenuMapper, Menu> implements IMenuService {
    @Autowired
    private IMenuButtonService menuButtonService;
    @Autowired
    private IMenuPermissionService menuPermissionService;
    @Autowired
    private IButtonService buttonService;
    @Autowired
    private IMenuButtonPermissionService menuButtonPermissionService;
    @Override
    public List<Menu> findByUserId(String userId) {
        if(!ValidateUtil.validateString(userId))
            ExceptionCast.cast(CommonCode.FAIL);
        QueryWrapper<Menu> queryWrapper = Wrappers.query();
        queryWrapper.eq("u.user_id", userId);
        List<Menu> menuList = this.getBaseMapper().findByUserId(queryWrapper);
        return menuList;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addMenu(Menu menu) {
        if(menu == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(menu.getPermCode()))
            ExceptionCast.cast(MenuCode.MENU_PERM_CODE_NONE);
        if(!ValidateUtil.validateString(menu.getMenuName()))
            ExceptionCast.cast(MenuCode.MENU_NAME_NONE);
        if(!ValidateUtil.validateString(menu.getMenuUrl()))
            ExceptionCast.cast(MenuCode.MENU_URL_NONE);
        Menu en = getByPermCode(menu.getPermCode());
        if(en != null)
            ExceptionCast.cast(MenuCode.MENU_PERM_CODE_EXIST);
        if(ValidateUtil.validateString(menu.getParentId())) {
            Menu parent = super.getById(menu.getParentId());
            if(parent == null)
                ExceptionCast.cast(MenuCode.MENU_PARENT_NOT_EXIST);
            menu.setRankLevel(parent.getRankLevel() + 1);
        }else {
            menu.setParentId(null);
            menu.setRankLevel(1);
        }
        return super.save(menu);
    }

    @Override
    public Menu getByPermCode(String permCode) {
        if(!ValidateUtil.validateString(permCode))
            return null;
        List<Menu> list = super.lambdaQuery().eq(Menu::getPermCode, permCode).list();
        if(list == null || list.isEmpty())
            return null;
        return list.get(0);
    }

    @Override
    public List<MenuExt> findAll() {
        List<MenuExt> menuExts = this.getBaseMapper().findExtAllBySingleSelect();
        return menuExts;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignButton(String menuId, List<Button> buttonList) {
        if(!ValidateUtil.validateString(menuId))
            ExceptionCast.cast(MenuCode.MENU_ID_NONE);
        Menu menu = super.getById(menuId);
        if(menu == null)
            ExceptionCast.cast(MenuCode.MENU_NOT_EXIST);
        boolean b = menuButtonService.deleteByMenuId(menuId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        if(buttonList != null && !buttonList.isEmpty()) {
            List<MenuButton> menuButtons = new ArrayList<>();
            List<String> ids = new ArrayList<>();
            buttonList.forEach(item -> {
                final MenuButton en = new MenuButton();
                en.setMenuId(menu.getMenuId());
                en.setButtonId(item.getButtonId());
                en.setButtonUrl(item.getButtonUrl());
                if(ValidateUtil.validateString(item.getButtonAlias())) {
                    en.setButtonAlias(item.getButtonAlias());
                }else {
                    en.setButtonAlias(item.getButtonName());
                }
                en.setPermCode(menu.getPermCode() + "_" + item.getButtonPerm());
                menuButtons.add(en);
                ids.add(item.getButtonId());
            });
            Collection<Button> buttons = buttonService.listByIds(ids);
            if(buttons == null || buttons.isEmpty() || buttons.size() != buttonList.size())
                ExceptionCast.cast(CommonCode.INVALID_PARAM);
            if(!menuButtons.isEmpty())
                return menuButtonService.saveBatch(menuButtons);
        }
        return b;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editMenu(String id, Menu menu) {
        if(!ValidateUtil.validateString(id) || menu == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Menu en = super.getById(id);
        if (en == null) {
            ExceptionCast.cast(MenuCode.MENU_NOT_EXIST);
        }
        menu.setMenuId(id);
        menu.setPermCode(null);
        if(ValidateUtil.validateString(menu.getParentId())) {
            if (!menu.getParentId().equals(en.getParentId())) {
                Menu parent = super.getById(menu.getParentId());
                if(parent == null)
                    ExceptionCast.cast(MenuCode.MENU_PARENT_NOT_EXIST);
                menu.setRankLevel(parent.getRankLevel() + 1);
            }
        }else {
            menu.setRankLevel(1);
        }
        return super.updateById(menu);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteMenuById(String id) {
        if(!ValidateUtil.validateString(id)) {
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        }
        Menu en = super.getById(id);
        if (en == null)
            ExceptionCast.cast(MenuCode.MENU_NOT_EXIST);
        List<Menu> list =  findSunLint(id);
        if (list != null && list.size() > 0) {
            ExceptionCast.cast(MenuCode.MENU_SUN_CODE_EXIST);
        }
        List<MenuPermission> menuPermissionList = menuPermissionService.findByMenuId(id);
        if(menuPermissionList != null && !menuPermissionList.isEmpty())
            ExceptionCast.cast(MenuCode.MENU_ROLE_EXIST);
        List<MenuButtonPermission> menuButtonPermissionList = menuButtonPermissionService.findByMenuId(id);
        if(menuButtonPermissionList != null && !menuButtonPermissionList.isEmpty())
            ExceptionCast.cast(MenuCode.MENU_ROLE_EXIST);
        boolean b = menuButtonService.deleteByMenuId(id);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return super.removeById(id);
    }

    @Override
    public List<Menu> findSunLint(String parentId) {
        if(!ValidateUtil.validateString(parentId))
            return null;
        List<Menu> list = super.lambdaQuery().eq(Menu::getParentId, parentId).list();
        if(list == null || list.isEmpty())
            return null;
        return list;
    }

    @Override
    public QueryPageResponseResult<Menu> findPageList(int page, int size, MenuRequest menuRequest) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<Menu> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<Menu> lambdaQuery = super.lambdaQuery();
        if(menuRequest != null) {
            if(ValidateUtil.validateString(menuRequest.getMenuName())) {
                lambdaQuery.eq(Menu::getMenuName, menuRequest.getMenuName());
            }
            if(ValidateUtil.validateString(menuRequest.getPermCode())) {
                lambdaQuery.like(Menu::getPermCode, menuRequest.getPermCode());
            }
            if(ValidateUtil.validateString(menuRequest.getId())) {
                lambdaQuery.eq(Menu::getParentId,menuRequest.getId());
            }
            if(ValidateUtil.validateString(menuRequest.getAscStr())) {
                String[] ascArr = menuRequest.getAscStr().split(",");
                ((Page<Menu>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(menuRequest.getDescStr())) {
                String[] descStr = menuRequest.getDescStr().split(",");
                ((Page<Menu>) pageData).setDesc(descStr);
            }
        }
        IPage<Menu> userIPage = lambdaQuery.page(pageData);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, userIPage);
    }

    @Override
    public List<CommonJsonTree> loadTree() {
        List<MenuExt> extAll = findAll();
        if(extAll == null || extAll.isEmpty())
            return null;
        return MenuTreeWrapper.loadTree(extAll);
    }

    @Override
    public List<Menu> getLeafMenuList() {
        return super.lambdaQuery().eq(Menu::getRankLevel, 3).list();
    }

}