package com.ruoyi.postCheck.service.impl;

import java.util.*;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.baomidou.mybatisplus.extension.conditions.query.QueryChainWrapper;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.constant.PostListEnum;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.enums.DeptCode;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.spring.SpringUtils;
import com.ruoyi.postCheck.domain.*;
import com.ruoyi.postCheck.mapper.PostListInfoMapper;
import com.ruoyi.postCheck.service.IPostCheckedService;
import com.ruoyi.postCheck.service.IPostListInfoService;
import com.ruoyi.postCheck.util.excel.ExcelParsePostCheck;
import com.ruoyi.postCheck.util.excel.ExcelParsePostList;
import com.ruoyi.system.domain.SysPost;
import com.ruoyi.system.service.ISysDeptService;
import com.ruoyi.system.service.ISysPostService;
import com.ruoyi.system.service.ISysUserService;
import org.apache.commons.lang3.ArrayUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.stream.Collectors;

import com.ruoyi.common.utils.StringUtils;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.postCheck.mapper.PostListMapper;
import com.ruoyi.postCheck.service.IPostListService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.util.CollectionUtils;

/**
 * 岗检责任制清单Service业务层处理
 *
 * @author csg
 * @date 2023-12-20
 */
@Service
public class PostListServiceImpl extends ServiceImpl<PostListMapper, PostList> implements IPostListService {
    @Autowired
    private PostListMapper postListMapper;
    @Autowired
    private PostListInfoMapper postListInfoMapper;

    @Autowired
    private IPostListInfoService postListInfoService;

    @Autowired
    private ISysPostService sysPostService;
    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private ISysDeptService sysDeptService;

//    防止循环注入
//    @Autowired
//    private IPostCheckedService postCheckedService;

    /**
     * 查询岗检责任制清单
     *
     * @param id 岗检责任制清单主键
     * @return 岗检责任制清单
     */
    @Override
    public PostList selectPostListById(Long id) {
        PostList data = postListMapper.selectPostListById(id);
        if (data != null) {
//            Long dataId = data.getId();
            PostListInfo info = new PostListInfo();
            info.setPostListId(id);
            List<PostListInfo> infoList = postListInfoService.selectPostListInfoList(info);
            data.setChildren(infoList);
        }
        return data;
    }

    /**
     * 查询岗检责任制清单列表
     *
     * @param postList 岗检责任制清单
     * @return 岗检责任制清单
     */
    @Override
    public List<PostList> selectPostListList(PostList postList) {

        //清单编制菜单查询时提交的是待审核，后台转化状态为：待提交、待审核、审核中、驳回
        Integer status = postList.getStatus();
        if (status != null && status == PostListEnum.STATUS_WAIT.getValue()) {
            postList.setStatus(null);
            List<Integer> statusList = new ArrayList<>(4);
            statusList.add(PostListEnum.STATUS_WAIT_SUBMIT.getValue());
            statusList.add(PostListEnum.STATUS_WAIT.getValue());
            statusList.add(PostListEnum.STATUS_ING.getValue());
            statusList.add(PostListEnum.STATUS_BACK.getValue());
            postList.setStatusList(statusList);
        }
        List<PostList> postLists = postListMapper.selectPostListList(postList);

        //查询详情
        if (!CollectionUtils.isEmpty(postLists)) {
            List<Long> postListIds = postLists.stream().map(PostList::getId).collect(Collectors.toList());
            LambdaQueryWrapper<PostListInfo> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(PostListInfo::getPostListId, postListIds);
            queryWrapper.orderByAsc(PostListInfo::getId);
            List<PostListInfo> postListInfoList = postListInfoService.list(queryWrapper);
            //详情分组
            Map<Long, List<PostListInfo>> postListInfoListGroupMap = postListInfoList.stream().collect(Collectors.groupingBy(PostListInfo::getPostListId));
            //设置详情
            for (PostList data : postLists) {
                data.setChildren(postListInfoListGroupMap.get(data.getId()));
            }
        }

        return postLists;
    }

    /**
     * 新增岗检责任制清单
     *
     * @param postList 岗检责任制清单
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int insertPostList(PostList postList) {
        postList.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
        postList.setStatus(PostListEnum.STATUS_WAIT_SUBMIT.getValue());//待提交
        postList.setCreateDefault();

        if (postList.getCreationDate() == null)
            postList.setCreationDate(new Date());//编制时间
        if (postList.getRevisionDate() == null)
            postList.setRevisionDate(new Date());//修订时间

        Long deptId = postList.getDeptId();
        //版本控制
        SysDept sysDept = sysDeptService.selectDeptById(deptId);
        SysPost sysPost = sysPostService.selectPostById(postList.getPostId());
        postList.setDeptName(sysDept.getDeptName());
        postList.setPostName(sysPost.getPostName());

        String ancestors = sysDept.getAncestors();
        if (ancestors.startsWith("0,")) {

            ancestors = ancestors.substring(2) + "," + deptId;
        }

        postList.setRemark(ancestors);//部门祖级结构（不含根0，含自己ID）前端做修改时的部门回显
        int rows = postListMapper.insertPostList(postList);

        //新增责任制清单明细
        insertPostListInfo(postList);

        //TODO 更新业务职责的状态=待审核：只要部门修改数据，人力资源都需要重新审核单据
        //1、按区域类型+主表id批量更新明细表状态、审核人、审核时间、未通过理由
        LambdaUpdateWrapper<PostListInfo> infoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        //条件
        infoLambdaUpdateWrapper.eq(PostListInfo::getPostListId, postList.getId());
        infoLambdaUpdateWrapper.eq(PostListInfo::getType, PostListEnum.TYPE_ONE.getValue());
        //参数
        infoLambdaUpdateWrapper.set(PostListInfo::getStatus, PostListEnum.STATUS_WAIT.getValue());
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusTime, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getReason, null);
        postListInfoMapper.update(null, infoLambdaUpdateWrapper);

        return rows;
    }


    /**
     * 修改岗检责任制清单
     *
     * @param postList 岗检责任制清单
     * @return 结果
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public int updatePostList(PostList postList) {
        postList.setUpdateDefault();
        //TODO 待改造，不可以将全部删除完，哪个部门修改了删除那个部门的，其他部门的不能删除。
        //删除明细
//        postListMapper.deletePostListInfoByPostListId(postList.getId());
        //删除明细：按类型只删除本次包含的主要职责
        List<PostListInfo> children = postList.getChildren();
        Map<Integer, List<PostListInfo>> typeMapList = children.stream().collect(Collectors.groupingBy(PostListInfo::getType));
        Set<Integer> typeList = typeMapList.keySet();
        if (CollectionUtils.isEmpty(typeList)) {
            throw new BaseException("请至少设置一项“主要职责”！");
        }
        LambdaQueryWrapper<PostListInfo> deleteWrapper = new LambdaQueryWrapper<>();
        deleteWrapper.eq(PostListInfo::getPostListId, postList.getId());
        deleteWrapper.in(PostListInfo::getType, typeList);
        postListInfoMapper.delete(deleteWrapper);

        //重新添加
        insertPostListInfo(postList);

        postList.setStatus(PostListEnum.STATUS_WAIT_SUBMIT.getValue());//待提交

        //版本控制
        SysDept sysDept = sysDeptService.selectDeptById(postList.getDeptId());
        SysPost sysPost = sysPostService.selectPostById(postList.getPostId());
        postList.setDeptName(sysDept.getDeptName());
        postList.setPostName(sysPost.getPostName());

        int updateCount = postListMapper.updatePostList(postList);

        // 更新业务职责的状态=待审核：只要部门修改数据，人力资源都需要重新审核单据
        //1、按区域类型+主表id批量更新明细表状态、审核人、审核时间、未通过理由
        LambdaUpdateWrapper<PostListInfo> infoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        //条件
        infoLambdaUpdateWrapper.eq(PostListInfo::getPostListId, postList.getId());
        infoLambdaUpdateWrapper.eq(PostListInfo::getType, PostListEnum.TYPE_ONE.getValue());
        //参数
        infoLambdaUpdateWrapper.set(PostListInfo::getStatus, PostListEnum.STATUS_WAIT.getValue());
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusTime, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, null);
        infoLambdaUpdateWrapper.set(PostListInfo::getReason, null);
        postListInfoMapper.update(null, infoLambdaUpdateWrapper);

        return updateCount;
    }

    /**
     * 批量新建岗位责任制清单
     *
     * @param postList 岗检责任制清单集合，里面仅设置了，创建者用户ID：createUserId
     * @return 结果
     */
    @Override
    @Transactional
    public int batchInsertPostList(List<PostList> postList) {

        if (CollectionUtils.isEmpty(postList)) {
            throw new BaseException("未指定人员，请检查！");
        }


        for (PostList data : postList) {
            Long createUserId = data.getCreateUserId();
            if (createUserId == null) {
                throw new BaseException("指定人员的ID为空，请检查！");
            }
        }

        //从数据库查人员
        List<Long> userIdList = postList.stream().map(PostList::getCreateUserId).distinct().collect(Collectors.toList());
        List<SysUser> sysUserList = sysUserService.postUserList(null, null, null, null, null, userIdList, null);
        if (sysUserList.size() != userIdList.size()) {
            throw new BaseException("指定人员数量【" + userIdList.size() + "】数据库匹配人员数量【" + sysUserList.size() + "】，请检查！");
        }

        //将人员按岗位分组，取第一个人为制单人
        Map<Long, List<SysUser>> postUserListMap = sysUserList.stream().collect(Collectors.groupingBy(SysUser::getPostId));
        int rows = 0;
        for (Long postId : postUserListMap.keySet()) {
            List<SysUser> postUserList = postUserListMap.get(postId);
            SysUser sysUser = postUserList.get(0);
            Long deptId = sysUser.getDeptId();
            Long userId = sysUser.getUserId();
            String nickName = sysUser.getNickName();
            if (deptId == null) {
                throw new BaseException("【" + nickName + "】该人员的未配置部门，请检查！");
            }
            if (postId == null) {
                throw new BaseException("【" + nickName + "】该人员的未配置岗位，请检查！");
            }


            PostList postListData = new PostList();
            postListData.setDeptId(deptId);
            postListData.setPostId(postId);
            postListData.setCreateUserId(userId);
            postListData.setRemark("批量创建");
            //通用属性设置
            postListData.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            postListData.setCreateDefault();
            postListData.setCreationDate(new Date());//编制时间
            postListData.setRevisionDate(new Date());//修订时间
            postListData.setStatus(PostListEnum.STATUS_WAIT_SUBMIT.getValue());//待提交
            rows += postListMapper.insertPostList(postListData);
        }

        return rows;
    }

    /**
     * 批量修改岗检责任制清单
     *
     * @param postList 岗检责任制清单集合，里面仅设置了，创建者用户ID：createUserId
     * @return 结果
     */
    @Override
    public int batchUpdatePostList(List<PostList> postList) {
        if (CollectionUtils.isEmpty(postList)) {
            throw new BaseException("未指定人员，请检查！");
        }

        for (PostList data : postList) {
            Long createUserId = data.getCreateUserId();
            if (createUserId == null) {
                throw new BaseException("指定人员的ID为空，请检查！");
            }
        }

        //从数据库查人员
        List<Long> userIdList = postList.stream().map(PostList::getCreateUserId).distinct().collect(Collectors.toList());
        List<SysUser> sysUserList = sysUserService.postUserList(null, null, null, null, null, userIdList, null);
        if (sysUserList.size() != userIdList.size()) {
            throw new BaseException("指定人员数量【" + userIdList.size() + "】数据库匹配人员数量【" + sysUserList.size() + "】，请检查！");
        }

        //将人员按岗位分组，取第一个人为制单人
        Map<Long, List<SysUser>> postUserListMap = sysUserList.stream().collect(Collectors.groupingBy(SysUser::getPostId));
        for (Long postId : postUserListMap.keySet()) {
            List<SysUser> postUserList = postUserListMap.get(postId);
            SysUser sysUser = postUserList.get(0);
            Long deptId = sysUser.getDeptId();
            Long userId = sysUser.getUserId();
            String nickName = sysUser.getNickName();
            if (deptId == null) {
                throw new BaseException("【" + nickName + "】该人员的未配置部门，请检查！");
            }
            if (postId == null) {
                throw new BaseException("【" + nickName + "】该人员的未配置岗位，请检查！");
            }

            //根据岗位ID查询待审核的清单
            LambdaQueryWrapper<PostList> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(PostList::getPostId, postId);
            queryWrapper.eq(PostList::getStatus, PostListEnum.STATUS_WAIT.getValue());
            List<PostList> postListList = postListMapper.selectList(queryWrapper);
            //跳过：岗位下没有待审核清单
            if (CollectionUtils.isEmpty(postListList)) {
                continue;
            }

            //修改岗位下的清单制单人（填写人）
            for (PostList postListData : postListList) {
                postListData.setCreateUserId(userId);

                postListData.setUpdateDefault();
                postListData.setStatus(PostListEnum.STATUS_WAIT_SUBMIT.getValue());//待提交
                postListMapper.updatePostList(postListData);


                //TODO 更新业务职责的状态=待审核：只要部门修改数据，人力资源都需要重新审核单据
                //1、按区域类型+主表id批量更新明细表状态、审核人、审核时间、未通过理由
                LambdaUpdateWrapper<PostListInfo> infoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                //条件
                infoLambdaUpdateWrapper.eq(PostListInfo::getPostListId, postListData.getId());
                infoLambdaUpdateWrapper.eq(PostListInfo::getType, PostListEnum.TYPE_ONE.getValue());
                //参数
                infoLambdaUpdateWrapper.set(PostListInfo::getStatus, PostListEnum.STATUS_WAIT.getValue());
                infoLambdaUpdateWrapper.set(PostListInfo::getStatusTime, null);
                infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, null);
                infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, null);
                infoLambdaUpdateWrapper.set(PostListInfo::getReason, null);
                postListInfoMapper.update(null, infoLambdaUpdateWrapper);
            }
        }
        return 1;
    }

    /**
     * 批量删除岗检责任制清单
     *
     * @param ids 需要删除的岗检责任制清单主键
     * @return 结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public int deletePostListByIds(Long[] ids) {

        List<PostList> postListList = postListMapper.selectBatchIds(Arrays.asList(ids));
        if (ids.length <= 0 || postListList.size() != ids.length) {
            throw new BaseException("前后端记录数量匹配不一致，请刷新页面再试！");
        }

        for (PostList postList : postListList) {
            Integer status = postList.getStatus();
            if (status == PostListEnum.STATUS_PASS.getValue()) {
                throw new BaseException("已审核通过的记录不允许删除，请刷新页面再试！");
            }
        }


        postListMapper.deletePostListInfoByPostListIds(ids);
        return postListMapper.deletePostListByIds(ids);
    }

    /**
     * 删除岗检责任制清单信息
     *
     * @param id 岗检责任制清单主键
     * @return 结果
     @Transactional
     @Override public int deletePostListById(Long id) {
     postListMapper.deletePostListInfoByPostListId(id);
     return postListMapper.deletePostListById(id);
     }
     */

    /**
     * 新增岗检责任制清单明细信息
     *
     * @param postList 岗检责任制清单对象
     */
    public void insertPostListInfo(PostList postList) {
        List<PostListInfo> childrenOne = new ArrayList<>();
        List<PostListInfo> childrenTwo = new ArrayList<>();

        List<PostListInfo> children = postList.getChildren();
        Long id = postList.getId();
        if (!CollectionUtils.isEmpty(children)) {

            //设置 自动审核 区分任职资格 和其他（业务职责有效性、党建及党风廉、安全环保、合规与保密）
            for (PostListInfo postListInfo : children) {
                Integer type = postListInfo.getType();
                postListInfo.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
                postListInfo.setPostListId(id);

                postListInfo.setCreateDefault();
                postListInfo.setCreateUserId(SecurityUtils.getUserId());//创建者ID

                //自动审核：任职资格与能力素质要求
                if (type == PostListEnum.TYPE_FIVE.getValue()) {
                    postListInfo.setStatus(PostListEnum.STATUS_PASS.getValue());//状态，可能需要重新设计，五大部门按类型区分状态
                    postListInfo.setStatusTime(new Date());
                    postListInfo.setStatusByUserId(SecurityUtils.getUserId());
                    postListInfo.setStatusByUserName(SecurityUtils.getLoginUser().getUser().getNickName());
                    postListInfo.setReason("Auto");

                    childrenOne.add(postListInfo);
                }
                //其他都是待审核
                else {
                    postListInfo.setStatus(PostListEnum.STATUS_WAIT.getValue());//状态，可能需要重新设计，五大部门按类型区分状态
                    postListInfo.setStatusTime(null);
                    postListInfo.setStatusByUserId(null);
                    postListInfo.setStatusByUserName(null);
                    postListInfo.setReason(null);
                    childrenTwo.add(postListInfo);
                }
            }

            //设置排序，将任职资格放到前面
            //检查表第一列：序号:从3开始，因为前面有2项完整性、适宜性
            int serialNumber = 3;

            List<PostListInfo> list = new ArrayList<>();
            for (PostListInfo postListInfo : childrenOne) {
                //10项任职资格
                postListInfo.setSerialNumber(serialNumber++);
                list.add(postListInfo);
            }

            for (PostListInfo postListInfo : childrenTwo) {
                postListInfo.setSerialNumber(serialNumber++);
                list.add(postListInfo);
            }


            if (list.size() > 0) {
                postListMapper.batchPostListInfo(list);
            }
        }
    }


    /**
     * @param deptId 部门ID
     * @param postId 岗位ID
     * @param type   检查项目（业务职责、党建党风、安全环保……）
     * @return
     */
    @Override
    public List<PostCheckedItems> contentListByType(Long deptId, Long postId, Integer type) {

        List<PostCheckedItems> itemsList = postListMapper.contentListByType(deptId, postId, type);

        //6
        if (type == PostListEnum.TYPE_SIX.getValue()) {
            PostCheckedItems item = new PostCheckedItems();
            item.setId(610l);
            item.setChildrenTypeId(610l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("完整性"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("1.是否有岗位基本信息、岗位职责、岗位权限、工作内容、工作标准的描述；\n" +
                    "2.岗位职责是否为全要素，如业务职责、安全职责、党建职责、合规职责、党风廉政职责、保密职责等；\n" +
                    "3.是否有明确的任职或上岗条件；\n" +
                    "4.工作标准是否有定性指标、定量指标。\n" +
                    "5.是否有对应的考核内容或建立相应的考核制度，考核内容或考核制度是否明确考核频次，如月度、季度或年度考核等，是否有对应的奖励内容。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：岗位责任制清单、岗位相关考核及奖惩文件。\n" +
                    "访谈：访谈员工有关考核实施情况。");
            item.setSerialNumber(1);//序号
            itemsList.add(item);

            item = new PostCheckedItems();
            item.setId(620l);
            item.setChildrenTypeId(620l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("适宜性"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("1.职责与权限；工作内容与岗位职责、权限；工作标准与工作内容、实际工作是否匹配；\n" +
                    "2.任职或上岗条件与岗位是否匹配；\n" +
                    "3.是否对岗位责任进行审核；\n" +
                    "4.是否有人员认为岗位责任描述不适宜；\n" +
                    "5.人员实际责任是否与岗位责任相符。\n" +
                    "6.考核与奖励是否匹配；考核及奖励内容是否与岗位、实际相适宜；是否按规定开展考核奖励并留有记录；被考核人是否知晓考核原因。\n" +
                    "7.是否对岗位职责落实情况进行检查，检查是否有检查记录。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：\n" +
                    "1.抽查岗位相关工作记录、审核审批记录；\n" +
                    "2.岗位责任制清单及审核记录；\n" +
                    "3.岗位说明书及审核记录；\n" +
                    "4.岗位相关考核及奖惩文件；\n" +
                    "5.抽查岗位相关工作的考核奖惩记录是否符合实际情况；\n" +
                    "访谈：访谈岗位员工意见。");
            item.setSerialNumber(2);//序号
            itemsList.add(item);
//            return success(itemsList);
        }

        /*
        else if (type == 5) {
            PostCheckedItems item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(510l);
            item.setChildrenTypeId(510l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("政治要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("·中共党员。\n" +
                    "·政治素质好，具有较高的政治站位，具备较强的政治判断力、政治领悟力、政治执行力，牢固树立“四个意识”，坚定“四个自信”，坚决做到“两个维护”，严守政治纪律、政治规矩，严格落实中央八项规定精神，忠诚干净担当。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(520l);
            item.setChildrenTypeId(520l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("最低学历要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("大学本科");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(530l);
            item.setChildrenTypeId(530l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("最低学位要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("无");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(540l);
            item.setChildrenTypeId(540l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("工作经验"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("具有累计7年以上企业工作经历。M8/T6级及以上，在副经理（或相当层级）岗位工作2年以上；未满2年的应当在副经理（或相当层级）和岗位经理/主管工程师（或相当层级）岗位工作累计5年以上，且在副经理（或相当层级）岗位工作至少满1年。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(550l);
            item.setChildrenTypeId(550l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("职称要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("高级职称");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(560l);
            item.setChildrenTypeId(560l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("专业要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("石油主干专业、企业管理或相关专业。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(570l);
            item.setChildrenTypeId(570l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("能力要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("·具有出色的计划、控制、领导和团队管理能力\n" +
                    "·具有出色的协调管理和沟通能力\n" +
                    "·善于理解和把握国家相关政策和法律法规\n" +
                    "·具有全局管理观念和控制能力\n" +
                    "·具有优秀的系统思维能力和判断力\n" +
                    "·具有良好的社交能力\n" +
                    "·具有良好的口头表达能力与文字水平\n" +
                    "·具有满足岗位工作需要的计算机使用水平");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：个人考核情况；\n" +
                    "访谈：访谈岗位员工及其他相关员工意见。");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(580l);
            item.setChildrenTypeId(580l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("知识要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("·掌握相关的政策、法律和法规知识\n" +
                    "·熟悉企业内部运行程序和相关规章制度\n" +
                    "·掌握业务相关的管理理论");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：个人考核情况；\n" +
                    "访谈：抽查询问岗位员工相关知识，访谈其他相关员工意见。");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(590l);
            item.setChildrenTypeId(590l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("在岗时应持有证书或必须参加的培训"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("无");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：员工档案");
            itemsList.add(item);

            item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(5100l);
            item.setChildrenTypeId(5100l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("其他要求"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("具有正常履职的身体条件，心理素质良好。");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("访谈：访谈岗位员工及其他相关员工意见。");
            itemsList.add(item);
//            return success(itemsList);
        }
        */
//        itemsList = postListService.contentListByType(deptId, postId, type);
        /*else if (type == 4) {
            PostCheckedItems item = new PostCheckedItems();
            item.setId(410l);
//            item.setChildrenTypeId(410l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("党委会、董事会管理"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("抓好三重一大管理，确保党委会、董事会合规运行");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：三重一大管理制度；党委会及董事会通知、签到表、纪要等\n" +
                    "访谈：\n" +
                    "现场查看：");
            itemsList.add(0, item);


            if (!CollectionUtils.isEmpty(itemsList)) {
                PostCheckedItems checkedItems = itemsList.get(0);
                String postCheckedContent = checkedItems.getPostCheckedContent();
                if (!postCheckedContent.equals("党委会、董事会管理")) {
                    itemsList.add(0, item);
                }
            } else {
                itemsList.add(0, item);
            }
        }*/

        /*
        else if (type == 1) {
            PostCheckedItems item = new PostCheckedItems();
//            item.setId(Long.parseLong(IdWorker.getIdStr().substring(4)));
            item.setId(110l);
//            item.setChildrenTypeId(110l);
            item.setType(type); //检查项目 -> 业务职责、党建党风、安全环保……
            item.setPostCheckedContent("党委会、董事会管理"); //检查内容 -> 一级事项、……、五级事项
            item.setPostCheckedStandard("抓好三重一大管理，确保党委会、董事会合规运行");  //检查标准 ->  工作标准（work_standard）  要求2（requirement）
            item.setPostCheckedMethod("查文件：三重一大管理制度；党委会及董事会通知、签到表、纪要等\n" +
                    "访谈：\n" +
                    "现场查看：");
            itemsList.add(0, item);


            if (!CollectionUtils.isEmpty(itemsList)) {
                PostCheckedItems checkedItems = itemsList.get(0);
                String postCheckedContent = checkedItems.getPostCheckedContent();
                if (!postCheckedContent.equals("党委会、董事会管理")) {
                    itemsList.add(0, item);
                }
            } else {
                itemsList.add(0, item);
            }
        }
*/

        for (PostCheckedItems items : itemsList) {
            Long id = items.getId();
            items.setChildrenTypeId(id);
        }
        return itemsList;
//        return postListMapper.contentListByType(deptId, postId, type);
    }


    /**
     * 提交审核
     *
     * @param id
     * @return
     */
    @Override
    public int submitApprove(Long id) {
        if (id == null) {
            throw new BaseException("参数不全，请检查！");
        }
        PostList postList = postListMapper.selectById(id);

        if (postList == null) {
            throw new BaseException("记录不存在，请刷新页面，再试！");
        }
        Integer status = postList.getStatus();
        if (status != PostListEnum.STATUS_WAIT_SUBMIT.getValue()) {
            throw new BaseException("非法操作，请检查当前的状态，仅待提交时才可操作，请检查！");
        }
        postList.setStatus(PostListEnum.STATUS_WAIT.getValue());
        int updateByIdCount = 0;
        try {
            updateByIdCount = postListMapper.updateById(postList);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return updateByIdCount;
    }

    /**
     * 岗位责任制清单审核
     *
     * @param type   审核的类型（1-业务职责；2-党建及党风廉政建设职责；3-安全环保职责；4-合规保密职；5-任职资格与能力素质要求）
     * @param id     主键ID
     * @param status 状态：3-通过；4-驳回；
     * @param reason 未通过理由（驳回时必选）
     * @return
     */
    @Override
    public int approve(Integer type, Long id, Integer status, String reason) {
        if (type == null || id == null || status == null) {
            throw new BaseException("参数不全，请检查！");
        }
        if (status == PostListEnum.STATUS_BACK.getValue() && StringUtils.isBlank(reason)) {
            throw new BaseException("请填写未通过理由！");
        }

        if (status == PostListEnum.STATUS_PASS.getValue() && status == PostListEnum.STATUS_BACK.getValue()) {
            throw new BaseException("状态错误，请检查！");
        }

        //1、判断权限
        //1-业务职责（人力资源部）
        if (type == PostListEnum.TYPE_ONE.getValue()) {
            List<Long> userHaveAuthorityList = sysPostService.userHaveAuthorityList(DeptCode.DEPT_HR.getCode());
            if (!userHaveAuthorityList.contains(SecurityUtils.getUserId())) {
                throw new BaseException("当前账号无权限，请检查！【" + type + "】");
            }
        }
        //2-党建及党风廉政建设职责（党建工作部）
        else if (type == PostListEnum.TYPE_TWO.getValue()) {
            List<Long> userHaveAuthorityList = sysPostService.userHaveAuthorityList(DeptCode.DEPT_PARTY.getCode());
            if (!userHaveAuthorityList.contains(SecurityUtils.getUserId())) {
                throw new BaseException("当前账号无权限，请检查！【" + type + "】");
            }
        }
        //3-安全环保职责（健康安全环保中心）
        else if (type == PostListEnum.TYPE_THREE.getValue()) {
            List<Long> userHaveAuthorityList = sysPostService.userHaveAuthorityList(DeptCode.DEPT_HSE.getCode());
            if (!userHaveAuthorityList.contains(SecurityUtils.getUserId())) {
                throw new BaseException("当前账号无权限，请检查！【" + type + "】");
            }
        }
        //4-合规保密职责（内控法务部&办公室）
        else if (type == PostListEnum.TYPE_FOUR.getValue()) {
            List<Long> userHaveAuthorityList = sysPostService.userHaveAuthorityList(DeptCode.DEPT_ICFA.getCode());
            List<Long> userHaveAuthorityListV2 = sysPostService.userHaveAuthorityList(DeptCode.DEPT_OFFICE.getCode());
            userHaveAuthorityList.addAll(userHaveAuthorityListV2);

            if (!userHaveAuthorityList.contains(SecurityUtils.getUserId())) {
                throw new BaseException("当前账号无权限，请检查！【" + type + "】");
            }
        }
        //不需要审核，新增修改时自动审核的
        //5-任职资格与能力素质要求（不需要审核）
//        else if (type == PostListEnum.TYPE_ONE.getValue()) {
//
//        }
        else {
            throw new BaseException("类型错误，请检查！");
        }


        //2、判断人力资源最后审核 & 全部是驳回时设置为驳回状态，都为审核中
        if (type == PostListEnum.TYPE_ONE.getValue()) {
            boolean allStatusBack = false;
            //通过
            if (status == PostListEnum.STATUS_PASS.getValue()) {
                //查询其他类型 待审核 & 驳回 的记录
                LambdaQueryWrapper<PostListInfo> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(PostListInfo::getPostListId, id);
                queryWrapper.in(PostListInfo::getType, PostListEnum.TYPE_TWO.getValue(), PostListEnum.TYPE_THREE.getValue(), PostListEnum.TYPE_FOUR.getValue());//类型（1-业务职责；2-党建及党风廉政建设职责；3-安全环保职责；4-合规保密职；5-任职资格与能力素质要求）
                queryWrapper.in(PostListInfo::getStatus, PostListEnum.STATUS_WAIT.getValue(), PostListEnum.STATUS_BACK.getValue());//分区域审核-状态：1-待审核；3-通过；4-驳回；
                queryWrapper.groupBy(PostListInfo::getType);
                List<PostListInfo> postListInfoList = postListInfoMapper.selectList(queryWrapper);
                if (!CollectionUtils.isEmpty(postListInfoList)) {
                    Set<Integer> typeSet = postListInfoList.stream().map(t -> t.getType()).collect(Collectors.toSet());
                    String typeView = "";
                    for (Integer typeIng : typeSet) {
                        typeView += PostListEnum.getTypeView(typeIng) + "；";
                    }
                    throw new BaseException("以下部门还未审核，请检查！" + typeView);
                }
            }
            //驳回
            else {
//                boolean allStatusBack = true;
                //查询其他类型 待审核 & 通过 的记录
                LambdaQueryWrapper<PostListInfo> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(PostListInfo::getPostListId, id);
                queryWrapper.in(PostListInfo::getType, PostListEnum.TYPE_TWO.getValue(), PostListEnum.TYPE_THREE.getValue(), PostListEnum.TYPE_FOUR.getValue());//类型（1-业务职责；2-党建及党风廉政建设职责；3-安全环保职责；4-合规保密职；5-任职资格与能力素质要求）
                queryWrapper.in(PostListInfo::getStatus, PostListEnum.STATUS_WAIT.getValue(), PostListEnum.STATUS_PASS.getValue());//分区域审核-状态：1-待审核；3-通过；4-驳回；
                queryWrapper.groupBy(PostListInfo::getType);
                List<PostListInfo> postListInfoListV2 = postListInfoMapper.selectList(queryWrapper);
                //全部驳回
                if (CollectionUtils.isEmpty(postListInfoListV2)) {
                    allStatusBack = true;
                }
                //部分驳回
                else {
                    allStatusBack = false;
                }
            }

            //人力资源审核通过 其他部门都审核通过时 将主单据修改为 审核通过
            //人力资源审核驳回 其他部门部分审核通过、部分驳回时 将主单据修改为 审核中
            //人力资源审核驳回 其他部门都驳回时 将主单据修改为 驳回
            LambdaUpdateWrapper<PostList> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
            lambdaUpdateWrapper.eq(PostList::getId, id);
            if (status == PostListEnum.STATUS_PASS.getValue()) {

//                3、岗位责任制清单要引入版本号，例如：2024-1、2014-2以岗位为单位进行编码累加
//                4、一个岗位如果已经有一个清单审核完成了，新增和修改时，都需要保存上一版本，创建一个新的版本
                PostList postList = postListMapper.selectById(id);
                Long deptId = postList.getDeptId();
                Long postId = postList.getPostId();
                if (deptId == null || postId == null) {
                    throw new BaseException("单据的部门ID和岗位ID为空，请检查！");
                }
                String versionNo = getVersionNoMax(deptId, postId);

                lambdaUpdateWrapper.set(PostList::getStatus, PostListEnum.STATUS_PASS.getValue());
                lambdaUpdateWrapper.set(PostList::getVersionNo, versionNo);

                //岗检责任制清单人力资源审核通过，自动生成全要素岗检检查表
                boolean flag = false;
                try {
                    flag = SpringUtils.getBean(IPostCheckedService.class).autoCreateCheckedTypeAll(id);
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new BaseException("生成全要素岗位检查表失败，请检查！" + e.getMessage());
                }
                if (!flag) {
                    throw new BaseException("生成全要素岗位检查表失败，请检查！");
                }

            } else {
                if (allStatusBack) {
                    lambdaUpdateWrapper.set(PostList::getStatus, PostListEnum.STATUS_BACK.getValue());
                } else {
                    lambdaUpdateWrapper.set(PostList::getStatus, PostListEnum.STATUS_WAIT.getValue());
                }
            }
            postListMapper.update(null, lambdaUpdateWrapper);
        }
        //非人力资源审核，将外层状态设置为审核中
        else {
            LambdaUpdateWrapper<PostList> lambdaUpdateWrapper = new LambdaUpdateWrapper<>();
            lambdaUpdateWrapper.eq(PostList::getId, id);
            lambdaUpdateWrapper.set(PostList::getStatus, PostListEnum.STATUS_WAIT.getValue());
            postListMapper.update(null, lambdaUpdateWrapper);

        }


        //1、按区域类型+主表id批量更新明细表状态、审核人、审核时间、未通过理由
        LambdaUpdateWrapper<PostListInfo> infoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        //条件
        infoLambdaUpdateWrapper.eq(PostListInfo::getPostListId, id);
        infoLambdaUpdateWrapper.eq(PostListInfo::getType, type);
        //参数
        infoLambdaUpdateWrapper.set(PostListInfo::getStatus, status);
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusTime, new Date());

        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, SecurityUtils.getUserId());
        infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, SecurityUtils.getLoginUser().getUser().getNickName());

        //通过-参数
        if (status == PostListEnum.STATUS_PASS.getValue()) {
//            infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, SecurityUtils.getUserId());
//            infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, SecurityUtils.getLoginUser().getUser().getNickName());
            infoLambdaUpdateWrapper.set(PostListInfo::getReason, null);
        }
        //驳回-参数
        else if (status == PostListEnum.STATUS_BACK.getValue()) {
//            infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserId, null);
//            infoLambdaUpdateWrapper.set(PostListInfo::getStatusByUserName, null);
            infoLambdaUpdateWrapper.set(PostListInfo::getReason, reason);
        }
        int updateCount = postListInfoMapper.update(null, infoLambdaUpdateWrapper);
        if (updateCount == 0) {
            throw new BaseException("更新状态失败，请稍后重试！");
        }

        return updateCount;
    }


    /**
     * 查询当前可用的版本号
     *
     * @param deptId
     * @param postId
     * @return
     */
    private String getVersionNoMax(Long deptId, Long postId) {
        LambdaQueryWrapper<PostList> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PostList::getDeptId, deptId);
        queryWrapper.eq(PostList::getPostId, postId);
        queryWrapper.eq(PostList::getStatus, PostListEnum.STATUS_PASS.getValue());
        List<PostList> postListList = postListMapper.selectList(queryWrapper);

        Set<Integer> versionNoSet = new TreeSet<>();
        versionNoSet.add(0);

        if (!CollectionUtils.isEmpty(postListList)) {
//                    versionNo =  "-1";
//                } else {
            List<String> versionList = postListList.stream().map(PostList::getVersionNo).collect(Collectors.toList());

            for (String versionNoDB : versionList) {
                if (StringUtils.isNotBlank(versionNoDB)) {
//                            versionNoSet.add(0);
//                        } else {
                    String[] versionNoArr = versionNoDB.split("-");
                    versionNoSet.add(versionNoArr.length == 2 ? Integer.parseInt(versionNoArr[1]) : 0);
                }
            }

        }
        Integer versionNoMax = Collections.max(versionNoSet);
        String versionNo = DateUtils.dateTimeNow(DateUtils.YYYY) + "-" + ++versionNoMax;
        return versionNo;
    }


    /**
     * 批量导入清单表Excel表格
     *
     * @param fileNameList 数组：前端上传文件接口返回的相对路径（含文件名称）
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchImport(String[] fileNameList) throws Exception {
//文件上传接口返回信息
//        {
//            "msg": "操作成功",
//                "fileName": "/upload/2024/01/29/gh_reserve_and_info_template(1)_20240129224542A003.xls",
//                "code": 200,
//                "newFileName": "gh_reserve_and_info_template(1)_20240129224542A003.xls",
//                "url": "http://39.106.66.72:8080/upload/2024/01/29/gh_reserve_and_info_template(1)_20240129224542A003.xls",
//                "originalFilename": "gh_reserve_and_info_template(1).xls"
//        }
        if (ArrayUtils.isEmpty(fileNameList)) {
            throw new BaseException("您未上传文件，请检查！");
        }

        //遍历解析文件并入库
        String localPath = RuoYiConfig.getProfile();
        for (int i = 0; i < fileNameList.length; i++) {
            //前端上传传的文件相对路径（含文件名称）
            String resource = fileNameList[i];
            // 文件绝对磁盘路径（含文件名称）
            String downloadPath = localPath + resource;
            // 文件名称
            String downloadName = StringUtils.substringAfterLast(downloadPath, "/");
            ExcelParsePostList excelParsePostCheck = new ExcelParsePostList();
            PostList postListData = excelParsePostCheck.parseFile(downloadPath, downloadName);

            //匹配数据：部门 + 岗位
            String deptName = postListData.getDeptName();
            String postName = postListData.getPostName();
            SysDept deptParam = new SysDept();
            deptParam.setDeptName(deptName);
            List<SysDept> deptList = sysDeptService.selectDeptListByCondition(deptParam);
            if (CollectionUtils.isEmpty(deptList)) {
                throw new BaseException("【" + downloadName + "】" + "文件中【" + deptName + "】部门名称不存在，请检查！");
            } else if (deptList.size() != 1) {
                throw new BaseException("【" + downloadName + "】" + "文件中【" + deptName + "】部门名称不唯一，查到" + deptList.size() + "个，请检查！");
            }

            //查询岗位
            Long deptId = deptList.get(0).getDeptId();
            List<SysPost> postList = sysPostService.selectByNameAndDeptId(deptId, postName);
//            SysPost postParam = new SysPost();
//            postParam.setDeptId(deptId);//部门ID
//            postParam.setPostName(postName);//岗位名称
//            List<SysPost> postList = sysPostService.selectPostList(postParam);
            if (CollectionUtils.isEmpty(postList)) {
                throw new BaseException("【" + downloadName + "】" + "文件中（" + deptName + "）部门下【" + postName + "】岗位不存在，请检查！");
            } else if (postList.size() != 1) {
                throw new BaseException("【" + downloadName + "】" + "文件中（" + deptName + "）部门下【" + postName + "】岗位不唯一，查到" + postList.size() + "个，请检查！");
            }

            postListData.setDeptId(deptId);
            postListData.setPostId(postList.get(0).getPostId());


//            System.out.println("============================格式化开始==========================================");
//            System.out.println("岗位责任制清单批量导入");
//            System.out.println(JSON.toJSONString(postListData, JSONWriter.Feature.PrettyFormat, JSONWriter.Feature.WriteMapNullValue));
//            System.out.println("============================格式化结束==========================================");


            //4、入库
            IPostListService thisBean = SpringUtils.getBean(IPostListService.class);//获取代理对象保证事务传递
            int insertPostCheckedCount = thisBean.insertPostList(postListData);
            if (insertPostCheckedCount <= 0) {
                throw new BaseException(downloadName + "文件入库失败，请稍后重试！插入条数：" + insertPostCheckedCount);
            }
        }
    }
}
