package cn.iocoder.yudao.module.archives.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.iocoder.yudao.common.BaseConstants;
import cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils;
import cn.iocoder.yudao.module.archives.entity.Archives;
import cn.iocoder.yudao.module.archives.entity.ArchivesRole;
import cn.iocoder.yudao.module.archives.mapper.ArchivesRoleMapper;
import cn.iocoder.yudao.module.archives.service.ArchivesRoleService;
import cn.iocoder.yudao.module.archives.service.ArchivesService;
import cn.iocoder.yudao.module.archives.vo.ArchivesRoleReqVO;
import cn.iocoder.yudao.module.system.api.dict.DictDataApi;
import cn.iocoder.yudao.module.system.api.dict.dto.DictDataRespDTO;
import cn.iocoder.yudao.module.system.api.permission.PermissionApi;
import com.baomidou.dynamic.datasource.annotation.DSTransactional;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.tencentcloudapi.tci.v20190318.models.Face;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception0;

/**
 * 档案权限表 服务实现类
 * 因为档案名称采用的是字典，所以这里提供操作权限的接口，字典的CRUD在这里完成
 *
 * @author 小李
 * @date 8:58 2024/8/28
 **/
@Service
public class ArchivesRoleServiceImpl extends ServiceImpl<ArchivesRoleMapper, ArchivesRole> implements ArchivesRoleService {

    @Resource
    private DictDataApi dictDataApi;

    @Resource
    private PermissionApi permissionApi;

    @Resource
    private ArchivesService archivesService;

    /**
     * 新增和修改档案权限和档案名称
     *
     * @author 小李
     * @date 9:26 2024/8/28
     **/
    @Override
    @DSTransactional
    public void updateArchivesRoleAndDict(ArchivesRoleReqVO archivesRoleReqVO) {
        // 新增或修改字典值
        if (ObjectUtil.isNotEmpty(archivesRoleReqVO.getDataId())) {
            DictDataRespDTO dictDataRespDTO = new DictDataRespDTO();
            dictDataRespDTO.setId(archivesRoleReqVO.getDataId());
            dictDataRespDTO.setLabel(archivesRoleReqVO.getDictLabel());
            dictDataApi.updateDictData(dictDataRespDTO);
        }
        if (ObjectUtil.isEmpty(archivesRoleReqVO.getDataId())) {
            dictDataApi.addDictData(archivesRoleReqVO.getDictType(), archivesRoleReqVO.getDictLabel(), archivesRoleReqVO.getDictLabel(), 0);
            DictDataRespDTO dictData = dictDataApi.getDictData(archivesRoleReqVO.getDictType(), archivesRoleReqVO.getDictLabel());
            archivesRoleReqVO.setDataId(dictData.getId());
        }
        // 新增或修改对应权限
        ArchivesRole archivesRole = baseMapper.selectOne(new LambdaQueryWrapper<ArchivesRole>().eq(ArchivesRole::getDataId, archivesRoleReqVO.getDataId()));
        if (ObjectUtil.isNotEmpty(archivesRole)) {
            baseMapper.update(archivesRoleReqVO, new LambdaQueryWrapper<ArchivesRole>().eq(ArchivesRole::getDataId, archivesRole.getDataId()));
        }
        if (ObjectUtil.isEmpty(archivesRole)) {
            baseMapper.insert(archivesRoleReqVO);
        }
    }

    /**
     * 删除企业管理-档案名称和权限
     *
     * @param ids
     * @author 小李
     * @date 10:34 2024/8/28
     **/
    @Override
    @DSTransactional
    public void removeArchivesRoleAndDict(Long[] ids) {
        // 删除时需要判断删除的档案名称下有没有档案，有就不能删除
        Boolean flag = true;
        for (Long id : ids) {
            long count = archivesService.count(new LambdaQueryWrapper<Archives>().eq(Archives::getDataId, id));
            if (count != 0){
                flag = false;
                break;
            }
        }
        if (!flag){
            throw exception0(500, "删除档案中还有子档案，不可删除");
        }
        dictDataApi.deleteDictDataByIds(ids);
        baseMapper.delete(new LambdaQueryWrapper<ArchivesRole>().in(ArchivesRole::getDataId, ids));
    }

    /**
     * 查看档案管理名称 通过当前登录用户的角色去筛选
     *
     * @param dictType 字典类型
     * @author 小李
     * @date 11:06 2024/8/28
     **/
    @Override
    public List<ArchivesRole> listArchivesRoleAndDict(String dictType) {
        // 当前登录用户的角色信息
        Long loginUserId = SecurityFrameworkUtils.getLoginUserId();
        List<Long> roleIds = permissionApi.getRoleIdsByUserId(loginUserId);

        // 先判断查看这个是否存在
        Boolean exist = dictDataApi.exist(dictType);
        // 如果不存在就先创建
        if (!exist){
            List<DictDataRespDTO> dictDataList = dictDataApi.getDictDataList(BaseConstants.ARCHIVES_TYPE);
            DictDataRespDTO dataRespDTO = dictDataList.stream().filter(item -> item.getValue().equals(dictType)).collect(Collectors.toList()).get(0);
            dictDataApi.createDictType(dataRespDTO.getLabel(), dataRespDTO.getValue());
        }

        // 获取当前用户有查看权限的档案名称，根据dictType去查，减少数据量
        List<ArchivesRole> archivesRoles = baseMapper.selectList(new LambdaQueryWrapper<ArchivesRole>().eq(ArchivesRole::getDictType, dictType));
        List<ArchivesRole> isQuery = archivesRoles.stream().filter(item -> {
            if (ObjectUtil.isEmpty(item.getQueryRoleIds())) {
                return false;
            }
            List<Long> dataRoles = Arrays.asList(item.getQueryRoleIds().split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
            Collection<Long> flag = CollUtil.intersection(dataRoles, roleIds);
            return CollectionUtil.isNotEmpty(flag);
        }).collect(Collectors.toList());

        // 判断当前用户对有查看权限的档案名称中内容的增、删、改权限
        isQuery.stream().forEach(item -> {
            // 增加权限
            item.setIsCreated(checkPermission(item.getCreateRoleIds(), roleIds));
            // 删除权限
            item.setIsDeleted(checkPermission(item.getDeleteRoleIds(), roleIds));
            // 修改权限
            item.setIsUpdated(checkPermission(item.getUpdateRoleIds(), roleIds));
            // 下载权限
            item.setIsDownload(checkPermission(item.getDownloadRoleIds(), roleIds));
        });

        // dictLabel赋值
        List<Long> dataIds = isQuery.stream().map(item -> item.getDataId()).collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(dataIds)) {
            List<DictDataRespDTO> dictDataListById = dictDataApi.getDictDataListById(dataIds);
            Map<Long, String> map = dictDataListById.stream().collect(Collectors.toMap(DictDataRespDTO::getId, DictDataRespDTO::getLabel));
            List<ArchivesRole> result = isQuery.stream().peek(item -> item.setDictLabel(map.get(item.getDataId()))).collect(Collectors.toList());
            return result;
        }
        return isQuery;
    }

    /**
     * 判断用户是否有对应功能的权限
     *
     * @param dataRoleIds 功能角色IDs
     * @param userRoleIds 用户角色IDs
     * @author 小李
     * @date 12:07 2024/8/28
     **/
    private Boolean checkPermission(String dataRoleIds, List<Long> userRoleIds) {
        if (ObjectUtil.isEmpty(dataRoleIds)) {
            return false;
        }
        List<Long> tempRoleIds = Arrays.asList(dataRoleIds.split(",")).stream().map(Long::parseLong).collect(Collectors.toList());
        Collection<Long> flag = CollUtil.intersection(tempRoleIds, userRoleIds);
        return CollectionUtil.isNotEmpty(flag);
    }
}
