package com.ruoyi.system.service.impl;

import com.ruoyi.common.basic.PageInfo;
import com.ruoyi.common.core.domain.entity.SysMenu;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.system.domain.SysRoleMenu;
import com.ruoyi.system.dto.SysRoleManageAddRequest;
import com.ruoyi.system.dto.SysRoleManageDeleteRequest;
import com.ruoyi.system.dto.SysRoleManageDetailRequest;
import com.ruoyi.system.dto.SysRoleManageEditRequest;
import com.ruoyi.system.dto.SysRoleManagePageRequest;
import com.ruoyi.system.mapper.SysMenuMapper;
import com.ruoyi.system.mapper.SysRoleMapper;
import com.ruoyi.system.mapper.SysRoleMenuMapper;
import com.ruoyi.system.mapper.SysUserRoleMapper;
import com.ruoyi.system.service.ISysRoleManageService;
import com.ruoyi.system.vo.SysMenuPermissionVO;
import com.ruoyi.system.vo.SysRoleManageDetailVO;
import com.ruoyi.system.vo.SysRoleManageVO;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * 角色管理服务实现
 *
 * @author ruoyi
 */
@Service
public class SysRoleManageServiceImpl implements ISysRoleManageService
{
    @Autowired
    private SysRoleMapper roleMapper;

    @Autowired
    private SysMenuMapper menuMapper;

    @Autowired
    private SysRoleMenuMapper roleMenuMapper;

    @Autowired
    private SysUserRoleMapper userRoleMapper;

    @Override
    public PageInfo<SysRoleManageVO> pageList(SysRoleManagePageRequest request)
    {
        SysRoleManagePageRequest query = request == null ? new SysRoleManagePageRequest() : request;
        query.setRoleName(StringUtils.trim(query.getRoleName()));
        PageInfo<SysRoleManageVO> pageInfo = new PageInfo<SysRoleManageVO>(query.getPageNum(), query.getPageSize());
        List<SysRoleManageVO> list = roleMapper.selectRoleManagePage(query, pageInfo);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public SysRoleManageDetailVO detail(SysRoleManageDetailRequest request)
    {
        Long roleId = getRequiredRoleId(request == null ? null : request.getRoleId());
        SysRoleManageVO role = roleMapper.selectRoleManageById(roleId);
        if (role == null)
        {
            throw new ServiceException("角色不存在");
        }
        SysRoleManageDetailVO detail = new SysRoleManageDetailVO();
        BeanUtils.copyProperties(role, detail);
        detail.setMenuIds(menuMapper.selectMenuListByRoleId(roleId, false));
        return detail;
    }

    @Override
    @Transactional
    public int add(SysRoleManageAddRequest request, String username)
    {
        if (request == null)
        {
            throw new ServiceException("角色内容不能为空");
        }
        String roleName = getRequiredRoleName(request.getRoleName());
        ensureRoleNameUnique(null, roleName);

        SysRole role = new SysRole();
        role.setRoleName(roleName);
        role.setRemark(StringUtils.trim(request.getRemark()));
        role.setStatus(0);
        role.setCreateBy(username);
        roleMapper.insertRole(role);
        saveRoleMenus(role.getRoleId(), request.getMenuIds());
        return 1;
    }

    @Override
    @Transactional
    public int edit(SysRoleManageEditRequest request, String username)
    {
        if (request == null)
        {
            throw new ServiceException("角色内容不能为空");
        }
        Long roleId = getRequiredRoleId(request.getRoleId());
        if (SysRole.isAdmin(roleId))
        {
            throw new ServiceException("不允许操作超级管理员角色");
        }
        SysRole role = roleMapper.selectRoleById(roleId);
        if (role == null || Integer.valueOf(2).equals(role.getDelFlag()))
        {
            throw new ServiceException("角色不存在");
        }
        String roleName = getRequiredRoleName(request.getRoleName());
        ensureRoleNameUnique(roleId, roleName);

        SysRole update = new SysRole();
        update.setRoleId(roleId);
        update.setRoleName(roleName);
        update.setRemark(StringUtils.trim(request.getRemark()));
        update.setUpdateBy(username);
        roleMapper.updateRole(update);
        roleMenuMapper.deleteRoleMenuByRoleId(roleId);
        saveRoleMenus(roleId, request.getMenuIds());
        return 1;
    }

    @Override
    @Transactional
    public int delete(SysRoleManageDeleteRequest request)
    {
        List<Long> roleIds = request == null ? null : request.getRoleIds();
        if (CollectionUtils.isEmpty(roleIds))
        {
            throw new ServiceException("请选择角色");
        }
        for (Long roleId : roleIds)
        {
            Long requiredRoleId = getRequiredRoleId(roleId);
            if (SysRole.isAdmin(requiredRoleId))
            {
                throw new ServiceException("超级管理员不能删除");
            }
            SysRole role = roleMapper.selectRoleById(requiredRoleId);
            if (role == null || Integer.valueOf(2).equals(role.getDelFlag()))
            {
                throw new ServiceException("角色不存在");
            }
            if (userRoleMapper.countUserRoleByRoleId(requiredRoleId) > 0)
            {
                throw new ServiceException("仅未绑定账号情况下可删除权限组");
            }
        }
        roleMenuMapper.deleteRoleMenu(roleIds);
        return roleMapper.deleteRoleByIds(roleIds);
    }

    @Override
    public List<SysMenuPermissionVO> permissionTree()
    {
        List<SysMenu> menus = menuMapper.selectMenuList(new SysMenu());
        Map<Long, SysMenuPermissionVO> menuMap = new LinkedHashMap<Long, SysMenuPermissionVO>();
        List<SysMenuPermissionVO> roots = new ArrayList<SysMenuPermissionVO>();
        for (SysMenu menu : menus)
        {
            if ("1".equals(menu.getStatus()))
            {
                continue;
            }
            SysMenuPermissionVO item = new SysMenuPermissionVO();
            item.setMenuId(menu.getMenuId());
            item.setParentId(menu.getParentId());
            item.setMenuName(menu.getMenuName());
            item.setMenuType(menu.getMenuType());
            item.setPerms(menu.getPerms());
            item.setOrderNum(menu.getOrderNum());
            item.setChildren(new ArrayList<SysMenuPermissionVO>());
            menuMap.put(item.getMenuId(), item);
        }
        for (SysMenuPermissionVO item : menuMap.values())
        {
            SysMenuPermissionVO parent = menuMap.get(item.getParentId());
            if (parent == null)
            {
                roots.add(item);
            }
            else
            {
                parent.getChildren().add(item);
            }
        }
        return roots;
    }

    private void saveRoleMenus(Long roleId, List<Long> menuIds)
    {
        Set<Long> normalizedMenuIds = new LinkedHashSet<Long>();
        if (!CollectionUtils.isEmpty(menuIds))
        {
            normalizedMenuIds.addAll(menuIds);
        }
        if (normalizedMenuIds.isEmpty())
        {
            return;
        }

        Set<Long> existingMenuIds = new LinkedHashSet<Long>();
        for (SysMenu menu : menuMapper.selectMenuList(new SysMenu()))
        {
            existingMenuIds.add(menu.getMenuId());
        }

        List<SysRoleMenu> roleMenus = new ArrayList<SysRoleMenu>();
        for (Long menuId : normalizedMenuIds)
        {
            if (menuId == null || !existingMenuIds.contains(menuId))
            {
                continue;
            }
            SysRoleMenu roleMenu = new SysRoleMenu();
            roleMenu.setRoleId(roleId);
            roleMenu.setMenuId(menuId);
            roleMenus.add(roleMenu);
        }
        if (!roleMenus.isEmpty())
        {
            roleMenuMapper.batchRoleMenu(roleMenus);
        }
    }

    private void ensureRoleNameUnique(Long roleId, String roleName)
    {
        Long currentRoleId = roleId == null ? -1L : roleId;
        SysRole exists = roleMapper.checkRoleNameUnique(roleName);
        if (exists != null && !currentRoleId.equals(exists.getRoleId()))
        {
            throw new ServiceException("角色名称已存在");
        }
    }

    private Long getRequiredRoleId(Long roleId)
    {
        if (roleId == null || roleId <= 0)
        {
            throw new ServiceException("角色ID不能为空");
        }
        return roleId;
    }

    private String getRequiredRoleName(String roleName)
    {
        String value = StringUtils.trim(roleName);
        if (StringUtils.isEmpty(value))
        {
            throw new ServiceException("角色名称不能为空");
        }
        if (value.length() > 30)
        {
            throw new ServiceException("角色名称不能超过30个字符");
        }
        return value;
    }
}