package com.yuanchu.limslaboratory.service.impl;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yuanchu.limslaboratory.exception.AuthException;
import com.yuanchu.limslaboratory.mapper.MenuMapper;
import com.yuanchu.limslaboratory.mapper.RoleManageMapper;
import com.yuanchu.limslaboratory.pojo.Menu;
import com.yuanchu.limslaboratory.pojo.RoleInfo;
import com.yuanchu.limslaboratory.pojo.RoleMenu;
import com.yuanchu.limslaboratory.pojo.dto.GetAllRoleAndMenuByConditionPageDto;
import com.yuanchu.limslaboratory.pojo.dto.RoleAndMenuDto;
import com.yuanchu.limslaboratory.pojo.dto.RoleInfoDto;
import com.yuanchu.limslaboratory.pojo.dto.UpdateRoleMenuDto;
import com.yuanchu.limslaboratory.service.RoleManagerService;
import com.yuanchu.limslaboratory.utils.ArrayListUtil;
import com.yuanchu.limslaboratory.utils.JsonUtil;
import com.yuanchu.limslaboratory.utils.MyUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * @Author 张宾
 * @Date 2023/8/23
 */
@Service
@Slf4j
public class RoleManagerServiceImpl implements RoleManagerService {

    @Resource
    private MenuMapper menuMapper;

    @Resource
    private RoleManageMapper roleManageMapper;

    @Override
    public Object getMenusTree() {
        List<Menu> menus = menuMapper.getMenuList();
        return menus.stream()
                .filter(t -> t.getParentId() == 0)
                .peek((menu) -> menu.setChildren(this.getEnumChildren(menu, menus)))
                .collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addRoleInfo(RoleInfoDto dto) {
        //新增角色
        //System.out.println(dto);
        LocalDateTime createTime = DateUtil.toLocalDateTime(DateUtil.date());
        RoleInfo role=new RoleInfo();
        long nextId = IdUtil.getSnowflake().nextId();
        role.setId(nextId);
        role.setName(dto.getRoleName());
        role.setCreateTime(createTime);
        int insert = roleManageMapper.insertRole(role);
        List<Map<String, Object>>addBranch=new ArrayList<>();
        reverseTree(dto.getMenuData(),addBranch);
        List<RoleMenu> roleMenuList =new ArrayList<>();
        addBranch.forEach(item->{
            roleMenuList.add(new RoleMenu(null,nextId,
                    Long.valueOf(String.valueOf(item.get("id")))
                    ,Boolean.valueOf(String.valueOf(item.get("selected")))
                    ,Boolean.valueOf(String.valueOf(item.get("added")))
                    ,Boolean.valueOf(String.valueOf(item.get("deleted")))
                    ,Boolean.valueOf(String.valueOf(item.get("updated")))
                    ,createTime
            ));
        });
        roleMenuList.add(new RoleMenu(null,nextId,39L,true,false,false,false,createTime));
        //roleMenuAddList.forEach(System.out::println);
        int i = roleManageMapper.insertBatchRoleMenu(roleMenuList);
        return insert>0&&i>0;
    }

    @Override
    public boolean assertRepeat(String roleName) {
        List<RoleInfo> assertName = roleManageMapper.getAssertName(roleName);
        return assertName.size()<1;
    }

    @Override
    public Map<String, Object> getAllRoleAndMenuInfo(GetAllRoleAndMenuByConditionPageDto dto) {
        dto.setCurrentPage((dto.getCurrentPage()-1)*dto.getCurrentPage());
        List<RoleAndMenuDto> roleAndMenuDtos = roleManageMapper.selectAllRoleAndMenu(dto);
        roleAndMenuDtos.forEach(r->{
            List<RoleMenu>roleMenuList=r.getRoleMenuList();
            List<RoleMenu> collect = roleMenuList.stream()
                    .filter(t -> t.getParentId() == 0)
                    .peek((menu) -> menu.setChildren(this.getRoleMenuChildren(menu, roleMenuList)))
                    .collect(Collectors.toList());
            r.setRoleMenuList(collect);
        });
        //roleAndMenuDtos.forEach(r->{
        //    r.getRoleMenuList().forEach(System.out::println);
        //});
        Map<String, Object>result=new HashMap<>(3);
        result.put("list",roleAndMenuDtos);
        int size = roleManageMapper.getRoleInfoByName(dto.getName()).size();
        result.put("total",size);
        return result;
    }

    @Override
    public boolean deleteRole(Long id) {
        return roleManageMapper.updateRoleState(id)>0&&roleManageMapper.updateRoleMenuStateByRoleId(id)>0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean updateRoleMenu(UpdateRoleMenuDto dto) {
        //修改role表信息
        UpdateWrapper<RoleInfo>updateWrapper=new UpdateWrapper<>();
        updateWrapper.lambda()
                        .set(RoleInfo::getName,dto.getRoleName())
                .set(RoleInfo::getUpdateTime,DateUtil.toLocalDateTime(DateUtil.date()))
                                .eq(RoleInfo::getId,dto.getRoleId());
        int update = roleManageMapper.update(null, updateWrapper);
        List<RoleMenu> roleMenuByRoleId = roleManageMapper.getRoleMenuByRoleId(dto.getRoleId());
        if (roleMenuByRoleId.size()>1){
            //删除role_menu信息
            update = roleManageMapper.deleteRoleMenuByRoleId(dto.getRoleId());
        }
        //添加最新选择、
        dto.getMenuData().forEach(l->{
            l.setRoleId(dto.getRoleId());
            l.setCreateTime(DateUtil.toLocalDateTime(DateUtil.date()));
            l.setUpdateTime(DateUtil.toLocalDateTime(DateUtil.date()));
        });
        List<RoleMenu> collect = dto.getMenuData().stream().filter(l -> l.getAdded() == false && l.getDeleted() == false && l.getSelected() == false && l.getUpdated() == false).collect(Collectors.toList());
        List<RoleMenu> roleMenuList = ArrayListUtil.compareNotEqualListBySingleValue(dto.getMenuData(), collect);
        if(roleMenuList.size()>0){
            return update>0&&roleManageMapper.insertBatchRoleMenu(roleMenuList)>0;
        }else {
            return update>0;
        }
    }

    @Override
    public RoleAndMenuDto getRoleAndMenuByRole(Long roleId) {
        return roleManageMapper.selectAllRoleAndMenuByRoleId(roleId);
    }

    @Override
    public List<Map<String, Object>> getUserListRole() {
        return roleManageMapper.getUserListRole();
    }

    @Override
    public Map<String, Object> getUrlType(String url) {
        String type=null;
        Map<String, Object> stringIntegerMap = roleManageMapper.selctInterFaceType(url);
        if(Objects.isNull(stringIntegerMap)){
            log.warn("没有====》"+url+"请求资源");
            throw new AuthException("403","没有该资源");
        }
        String of = String.valueOf(stringIntegerMap.get("type"));
        switch (of) {
            case "0":
                type="selected";
                break;
            case "1":
                type="added";
                break;
            case "2":
                type="updated";
                break;
            case "3":
                type="deleted";
                break;
            default:
                break;
        }
        stringIntegerMap.put("type",type);
        return stringIntegerMap;
    }

    @Override
    public boolean hasUrl(String type, String menuId, String roleId) {
        return roleManageMapper.hasUrl( type,  menuId,  roleId).get("num")>0L;
    }


    private List<Menu> getEnumChildren(Menu root, List<Menu> all) {
        return all.stream()
                .filter(t -> Objects.equals(t.getParentId(), root.getId()))
                .peek(g -> {
                    //找子菜单
                    g.setChildren(getEnumChildren(g, all));
                })
                .collect(Collectors.toList());
    }

    private List<RoleMenu> getRoleMenuChildren(RoleMenu root, List<RoleMenu> all) {
        return all.stream()
                .filter(t -> Objects.equals(t.getParentId(), root.getMenuId()))
                .peek(g -> {
                    //找子菜单
                    g.setChildren(getRoleMenuChildren(g, all));
                })
                .collect(Collectors.toList());
    }

    private void reverseTree(List<Map<String, Object>>tree, List<Map<String, Object>>addBranch){
        tree.forEach(t->{
            addBranch.add(t);
            if(t.get("children")!=null){
                List<Map<String, Object>> children = JsonUtil.jsonToPojo( JsonUtil.jsonToString(t.get("children")), List.class);
                addBranch.addAll(children);
            }
        });
    }
}