package jnpf.permission.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import jnpf.base.ActionResult;
import jnpf.base.service.SuperServiceImpl;
import jnpf.constant.MsgCode;
import jnpf.constant.PermissionConst;
import jnpf.permission.entity.*;
import jnpf.permission.mapper.*;
import jnpf.permission.model.position.PosConModel;
import jnpf.permission.model.rolerelaiton.*;
import jnpf.permission.service.RoleRelationService;
import jnpf.permission.util.UserUtil;
import jnpf.util.JsonUtil;
import jnpf.util.RandomUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 用户关系
 *
 * @author JNPF开发平台组
 * @version V3.1.0
 * @copyright 引迈信息技术有限公司
 * @date 2019年9月26日 上午9:18
 */
@Service
public class RoleRelationServiceImpl extends SuperServiceImpl<RoleRelationMapper, RoleRelationEntity> implements RoleRelationService {
    @Autowired
    private UserUtil userUtil;
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private PositionMapper positionMapper;
    @Autowired
    private UserRelationMapper userRelationMapper;
    @Autowired
    private RoleMapper roleMapper;

    @Override
    public List<RoleRelationEntity> getListPage(RoleListPage pagination) {
        return this.baseMapper.getListPage(pagination);
    }

    @Override
    public List<RoleRelationUserVo> getUserPage(RoleRelationPage pagination) {
        return this.baseMapper.getUserPage(pagination);
    }

    @Override
    public List<RoleRelationOrgVo> getOrgPage(RoleRelationPage pagination) {
        return this.baseMapper.getOrgPage(pagination);
    }

    @Override
    public List<RoleRelationOrgVo> getPosPage(RoleRelationPage pagination) {
        return this.baseMapper.getPosPage(pagination);
    }

    @Override
    public List<RoleRelationEntity> getListByObjectId(String objectId, String objectType) {
        return this.baseMapper.getListByObjectId(objectId, objectType);
    }

    @Override
    public List<RoleRelationEntity> getListByObjectId(List<String> objectId, String objectType) {
        return this.baseMapper.getListByObjectId(objectId, objectType);
    }

    @Override
    public List<RoleRelationEntity> getListByRoleId(String roleId, String objectType) {
        return this.baseMapper.getListByRoleId(roleId, objectType);
    }

    @Override
    public List<RoleRelationEntity> getListByRoleId(List<String> roleId, String objectType) {
        return this.baseMapper.getListByRoleId(roleId, objectType);
    }

    @Override
    public ActionResult roleAddObjectIds(RoleRelationForm form) {
        if (CollectionUtil.isEmpty(form.getIds())) {
            return ActionResult.fail(MsgCode.SYS134.get());
        }
        String roleId = form.getRoleId();
        RoleEntity info = roleMapper.getInfo(roleId);
        if (info == null) {
            return ActionResult.fail(MsgCode.FA001.get());
        }

        String type = form.getType();
        List<String> ids = new ArrayList<>(form.getIds());
        List<String> errList1 = new ArrayList<>();
        List<String> objectIds = new ArrayList<>();

        //角色-移除数据库已有数据。
        List<RoleRelationEntity> listByRoleId = this.getListByRoleId(roleId, type);
        Set<String> roleSet = listByRoleId.stream().map(RoleRelationEntity::getObjectId).collect(Collectors.toSet());
        Set<String> adminIds = userMapper.getAdminList().stream().map(UserEntity::getId).collect(Collectors.toSet());
        ids = ids.stream().filter(t -> !roleSet.contains(t)).collect(Collectors.toList());

        //用户角色约束判断
        PosConModel posConModel = new PosConModel();
        if (Objects.equals(info.getIsCondition(), 1)) {
            posConModel = JsonUtil.getJsonToBean(info.getConditionJson(), PosConModel.class);
            posConModel.init();
        }
        if (posConModel.getNumFlag()) {
            //用户基数限制
            if (ids.size() > 0 && posConModel.getUserNum() <= roleSet.size()) {
                return ActionResult.fail(MsgCode.SYS135.get(MsgCode.PS006.get()));
            }
        }

        for (String objectId : ids) {
            if (adminIds.contains(objectId)) {
                errList1.add("超管不能添加");
                continue;
            }
            List<String> errList2 = new ArrayList<>();
            RoleRelationEntity entity = new RoleRelationEntity();
            entity.setId(RandomUtil.uuId());
            entity.setObjectId(objectId);
            entity.setRoleId(roleId);
            entity.setObjectType(type);
            //角色约束判断
            if (PermissionConst.USER.equals(type)) {
                List<RoleRelationEntity> userRoleList = this.getListByObjectId(objectId, PermissionConst.USER);
                List<String> thisUserRole = userRoleList.stream().map(RoleRelationEntity::getRoleId).collect(Collectors.toList());
                List<RoleEntity> roleList = roleMapper.getListByIds(thisUserRole);
                //用户现有角色和当前互斥
                for (RoleEntity role : roleList) {
                    if (Objects.equals(role.getIsCondition(), 1)) {
                        PosConModel conModelP = JsonUtil.getJsonToBean(role.getConditionJson(), PosConModel.class);
                        conModelP.init();
                        if (conModelP.getMutualExclusionFlag() && conModelP.getMutualExclusion().contains(roleId)) {
                            errList2.add(MsgCode.SYS137.get());
                        }
                    }
                }
                //互斥
                if (posConModel.getMutualExclusionFlag()) {
                    if (posConModel.getMutualExclusion().stream().filter(t -> thisUserRole.contains(t)).collect(Collectors.toList()).size() > 0) {
                        errList2.add(MsgCode.SYS137.get());
                    }
                }
                //先决
                if (posConModel.getPrerequisiteFlag() && !thisUserRole.containsAll(posConModel.getPrerequisite())) {
                    errList2.add(MsgCode.SYS138.get());
                }
            }
            if (errList2.size() == 0) {
                //达到用户基数限制跳出循环
                if (posConModel.getNumFlag() && posConModel.getUserNum() <= (objectIds.size() + roleSet.size())) {
                    errList1.add(MsgCode.SYS135.get(MsgCode.PS006.get()));
                    break;
                }
                objectIds.add(objectId);
                this.save(entity);
            } else {
                errList1.addAll(errList2);
            }
        }
        //修改关系-相关用户踢下线
        this.delCurUser(type, objectIds);

        if (CollectionUtil.isNotEmpty(errList1) && CollectionUtil.isNotEmpty(objectIds)) {
            return ActionResult.success(MsgCode.SYS139.get());
        } else if (CollectionUtil.isNotEmpty(errList1)) {
            return ActionResult.fail(MsgCode.DB019.get());
        }
        return ActionResult.success(MsgCode.SU018.get());
    }

    @Override
    public void delete(RoleRelationForm form) {
        List<RoleRelationEntity> list = this.baseMapper.getListByForm(form);
        if (CollectionUtil.isEmpty(list)) {
            return;
        }
        for (RoleRelationEntity item : list) {
            this.removeById(item);
        }
        //一次移除只能是用类型数据
        List<String> objectIds = list.stream().map(RoleRelationEntity::getObjectId).collect(Collectors.toList());
        //修改关系-相关用户踢下线
        this.delCurUser(form.getType(), objectIds);
    }

    @Override
    public void objectAddRoles(AddRolesForm form) {
        this.baseMapper.objectAddRoles(form);
        this.delCurUser(form.getType(), Arrays.asList(form.getObjectId()));
    }

    public void objectDeleteRoles(AddRolesForm form) {
        this.baseMapper.objectDeleteRoles(form);
        this.delCurUser(form.getType(), Arrays.asList(form.getObjectId()));
    }

    private void delCurUser(String type, List<String> objectIds) {
        //修改关系-相关用户踢下线
        List<String> userIds = new ArrayList<>();
        if (PermissionConst.USER.equals(type)) {
            userIds.addAll(objectIds);
        }
//        if (PermissionConst.ORGANIZE.equals(type)) {
//            List<OrganizeEntity> listByIds = organizeService.getListByIds(objectIds);
//            List<PositionEntity> listByOrgIds = positionService.getListByOrgIds(listByIds.stream().map(OrganizeEntity::getId).collect(Collectors.toList()));
//            List<String> positionIds = listByOrgIds.stream().map(PositionEntity::getId).collect(Collectors.toList());
//            List<UserRelationEntity> listByObjectIdAll = userRelationService.getListByObjectIdAll(positionIds);
//            userIds.addAll(listByObjectIdAll.stream().map(UserRelationEntity::getUserId).collect(Collectors.toList()));
//        }
        if (PermissionConst.POSITION.equals(type)) {
            List<PositionEntity> listByOrgIds = positionMapper.getListByIds(objectIds);
            List<String> positionIds = listByOrgIds.stream().map(PositionEntity::getId).collect(Collectors.toList());
            List<UserRelationEntity> listByObjectIdAll = userRelationMapper.getListByObjectIdAll(positionIds);
            userIds.addAll(listByObjectIdAll.stream().map(UserRelationEntity::getUserId).collect(Collectors.toList()));
        }
        if (CollectionUtil.isNotEmpty(userIds)) {
            userUtil.delCurUser(MsgCode.PS010.get(), userIds);
        }
    }
}