package com.lxzn.ucenter.service.impl;

import com.baomidou.mybatisplus.core.metadata.IPage;
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.RoleRequest;
import com.lxzn.framework.domain.ucenter.response.RoleCode;
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.RoleMapper;
import com.lxzn.ucenter.service.*;
import com.lxzn.ucenter.service.support.MenuButtonTreeWrapper;
import com.lxzn.ucenter.service.support.MenuPermissonTreeWrapper;
import com.lxzn.ucenter.service.support.ObjectButtonTreeWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
public class RoleServiceImpl extends ServiceImpl<RoleMapper, Role> implements IRoleService {

    @Autowired
    private IMenuPermissionService menuPermissionService;
    @Autowired
    private IButtonPermissionService buttonPermissionService;
    @Autowired
    private IMenuButtonPermissionService menuButtonPermissionService;
    @Autowired
    private IObjectButtonPermissionService objectButtonPermissionService;
    @Autowired
    private IMenuService menuService;
    @Autowired
    private IObjectService objectService;
    @Autowired
    private IMenuButtonService menuButtonService;
    @Autowired
    private IObjectButtonService objectButtonService;
    @Autowired
    private IButtonService buttonService;
    @Autowired
    private IUserRoleService userRoleService;

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean addRole(Role role) {
        if(role == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(role.getRoleCode()))
            ExceptionCast.cast(RoleCode.ROLE_CODE_NONE);
        if(!ValidateUtil.validateString(role.getRoleName()))
            ExceptionCast.cast(RoleCode.ROLE_NAME_NONE);
        Role en = this.getByRoleCode(role.getRoleCode());
        if(en != null)
            ExceptionCast.cast(RoleCode.ROLE_CODE_EXIST);
        return super.save(role);
    }

    @Override
    public Role getByRoleCode(String roleCode) {
        if(!ValidateUtil.validateString(roleCode))
            return null;
        List<Role> roleList = super.lambdaQuery().eq(Role::getRoleCode, roleCode).list();
        if(roleList == null || roleList.isEmpty())
            return null;
        return roleList.get(0);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignMenus(String roleId, String[] menuIds) {
        if(!ValidateUtil.validateString(roleId))
            ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
        Role role = super.getById(roleId);
        if(role == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        if(menuIds == null || menuIds.length < 1)
            ExceptionCast.cast(RoleCode.ROLE_MENU_NONE);
        List<String> ids = new ArrayList<>(menuIds.length);
        Collections.addAll(ids, menuIds);
        Collection<Menu> menuList = menuService.listByIds(ids);
        if(menuList == null || menuList.isEmpty() || menuList.size() != menuIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        boolean b = menuPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        List<MenuPermission> menuPermissions = new ArrayList<>();
        menuList.forEach(item -> {
            final MenuPermission en = new MenuPermission();
            en.setRoleId(role.getRoleId());
            en.setMenuId(item.getMenuId());
            menuPermissions.add(en);
        });
        if(!menuPermissions.isEmpty())
            return menuPermissionService.saveBatch(menuPermissions);
        return b;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignSysButton(String roleId, String[] buttonIds) {
        if(!ValidateUtil.validateString(roleId))
            ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
        Role role = super.getById(roleId);
        if(role == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        if(buttonIds == null || buttonIds.length < 1) {
            boolean b = buttonPermissionService.deleteByRoleId(roleId);
            if(!b)
                ExceptionCast.cast(CommonCode.FAIL);
            return b;
        }
        List<String> ids = new ArrayList<>(buttonIds.length);
        Collections.addAll(ids, buttonIds);
        Collection<Button> buttonList = buttonService.listByIds(ids);
        if(buttonList == null || buttonList.isEmpty() || buttonList.size() != buttonIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        boolean b = buttonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        List<ButtonPermission> buttonPermissions = new ArrayList<>();
        buttonList.forEach(item -> {
            final ButtonPermission en = new ButtonPermission();
            en.setRoleId(role.getRoleId());
            en.setButtonId(item.getButtonId());
            buttonPermissions.add(en);
        });
        if(!buttonPermissions.isEmpty())
            return buttonPermissionService.saveBatch(buttonPermissions);
        return b;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignMenuButton(String roleId, String[] menuButtonIds) {
        if(!ValidateUtil.validateString(roleId))
            ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
        Role role = super.getById(roleId);
        if(role == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        if(menuButtonIds == null || menuButtonIds.length < 1) {
            return menuButtonPermissionService.deleteByRoleId(roleId);
        }
        List<String> ids = new ArrayList<>(menuButtonIds.length);
        Collections.addAll(ids, menuButtonIds);
        Collection<MenuButton> menuButtonList = menuButtonService.listByIds(ids);
        if(menuButtonList == null || menuButtonList.isEmpty() || menuButtonList.size() != menuButtonIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        boolean b = menuButtonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        List<MenuButtonPermission> menuButtonPermissions = new ArrayList<>();
        menuButtonList.forEach(item -> {
            final MenuButtonPermission en = new MenuButtonPermission();
            en.setRoleId(role.getRoleId());
            en.setMenuId(item.getMenuId());
            en.setButtonId(item.getButtonId());
            menuButtonPermissions.add(en);
        });
        if(!menuButtonPermissions.isEmpty())
            return menuButtonPermissionService.saveBatch(menuButtonPermissions);
        return b;
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean assignObjectButton(String roleId, String[] objectButtonIds) {
        if(!ValidateUtil.validateString(roleId))
            ExceptionCast.cast(RoleCode.ROLE_ID_NONE);
        Role role = super.getById(roleId);
        if(role == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        if(objectButtonIds == null || objectButtonIds.length < 1) {
            return objectButtonPermissionService.deleteByRoleId(roleId);
        }
        List<String> ids = new ArrayList<>(objectButtonIds.length);
        Collections.addAll(ids, objectButtonIds);
        Collection<ObjectButton> objectButtonList = objectButtonService.listByIds(ids);
        if(objectButtonList == null || objectButtonList.isEmpty() || objectButtonList.size() != objectButtonIds.length)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        boolean b = objectButtonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        List<ObjectButtonPermission> objectButtonPermissions = new ArrayList<>();
        objectButtonList.forEach(item -> {
            final ObjectButtonPermission en = new ObjectButtonPermission();
            en.setRoleId(role.getRoleId());
            en.setObjectId(item.getObjectId());
            en.setButtonId(item.getButtonId());
            objectButtonPermissions.add(en);
        });
        if(!objectButtonPermissions.isEmpty())
            return objectButtonPermissionService.saveBatch(objectButtonPermissions);
        return b;
    }

    @Override
    public List<Role> getUserNonPermRole(String userId) {
        return super.getBaseMapper().getUserNonPermRole(userId);
    }

    @Override
    public List<Role> getUserPermRole(String userId) {
        return super.getBaseMapper().getUserPermRole(userId);
    }

    @Override
    public QueryPageResponseResult<Role> findPageList(int page, int size, RoleRequest roleRequest) {
        if(page < 1 || size < 1) {
            ExceptionCast.cast(CommonCode.INVALID_PAGE);
        }
        IPage<Role> pageData = new Page<>(page, size);
        LambdaQueryChainWrapper<Role> lambdaQuery = super.lambdaQuery();
        if(roleRequest != null) {
            if(ValidateUtil.validateString(roleRequest.getRoleCode())) {
                lambdaQuery.like(Role::getRoleCode, roleRequest.getRoleCode());
            }
            if(ValidateUtil.validateString(roleRequest.getRoleName())) {
                lambdaQuery.like(Role::getRoleName, roleRequest.getRoleName());
            }

            if(ValidateUtil.validateString(roleRequest.getAscStr())) {
                String[] ascArr = roleRequest.getAscStr().split(",");
                ((Page<Role>) pageData).setAsc(ascArr);
            }
            if(ValidateUtil.validateString(roleRequest.getDescStr())) {
                String[] descStr = roleRequest.getDescStr().split(",");
                ((Page<Role>) pageData).setDesc(descStr);
            }
        }
        IPage<Role> roleIPage = lambdaQuery.page(pageData);
        return new QueryPageResponseResult<>(CommonCode.SUCCESS, roleIPage);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean editRole(String id, Role role) {
        if(!ValidateUtil.validateString(id) || role == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Role en = super.getById(id);
        if(en == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        role.setRoleId(id);
        role.setRoleCode(null);
        return super.updateById(role);
    }

    @Override
    public List<CommonJsonTree> getMenuButtonTree(String roleId) {
        if(!ValidateUtil.validateString(roleId))
            return null;
        List<Menu> menuList = menuService.getLeafMenuList();
        if(menuList == null || menuList.isEmpty())
            return null;
        List<MenuButton> menuButtonList = menuButtonService.list();
        if(menuButtonList == null || menuButtonList.isEmpty())
            return null;
        Map<String, MenuButtonPermission> map = menuButtonPermissionService.getMapByRoleId(roleId);
        return MenuButtonTreeWrapper.loadTree(menuList, menuButtonList, map);
    }

    @Override
    public List<CommonJsonTree> getObjectButtonTree(String roleId) {
        if(!ValidateUtil.validateString(roleId))
            return null;
        List<ObjectBase> objectBaseList = objectService.list();
        if(objectBaseList == null || objectBaseList.isEmpty())
            return null;
        List<ObjectButton> objectButtonList = objectButtonService.list();
        if(objectButtonList == null || objectButtonList.isEmpty())
            return null;
        Map<String, ObjectButtonPermission> map = objectButtonPermissionService.getMapByRoleId(roleId);
        return ObjectButtonTreeWrapper.loadTree(objectBaseList, objectButtonList, map);
    }

    @Override
    public List<CommonJsonTree> getMenuTree(String roleId) {
        if(!ValidateUtil.validateString(roleId))
            return null;
        List<MenuExt> menuList = menuService.findAll();
        if(menuList == null || menuList.isEmpty())
            return null;
        Map<String, MenuPermission> menuPermissionMap = menuPermissionService.getMapByRoleId(roleId);
        if(menuPermissionMap == null)
            menuPermissionMap = new HashMap<>();
        return MenuPermissonTreeWrapper.loadTree(menuList, menuPermissionMap);
    }

    @Override
    @Transactional(rollbackFor = {Exception.class})
    public boolean deleteRole(String roleId) {
        if(!ValidateUtil.validateString(roleId))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Role en = super.getById(roleId);
        if(en == null)
            ExceptionCast.cast(RoleCode.ROLE_NOT_EXIST);
        List<UserRole> userRoleList = userRoleService.findByRoleId(roleId);
        if(userRoleList != null && !userRoleList.isEmpty())
            ExceptionCast.cast(RoleCode.ROLE_USER_EXIST);
        boolean b = buttonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = menuPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = menuButtonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        b = objectButtonPermissionService.deleteByRoleId(roleId);
        if(!b)
            ExceptionCast.cast(CommonCode.FAIL);
        return super.removeById(roleId);
    }
}