package jnpf.flowable.util;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.ImmutableList;
import jnpf.constant.MsgCode;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.*;
import jnpf.flowable.enums.OperatorStateEnum;
import jnpf.flowable.enums.TaskStatusEnum;
import jnpf.flowable.mapper.*;
import jnpf.flowable.model.util.FlowNature;
import jnpf.util.StringUtil;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

@Component
@RequiredArgsConstructor
public class TaskUtil {

    
    private final TaskMapper taskMapper;
    
    private final LaunchUserMapper launchUserMapper;
    
    private final CandidatesMapper candidatesMapper;
    
    private final OperatorMapper operatorMapper;
    
    private final RecordMapper recordMapper;
    
    private final CirculateMapper circulateMapper;
    
    private final CommentMapper commentMapper;
    
    private final RejectDataMapper rejectDataMapper;
    
    private final NodeRecordMapper nodeRecordMapper;
    
    private final TaskLineMapper taskLineMapper;
    
    private final RevokeMapper revokeMapper;
    
    private final TriggerTaskMapper triggerTaskMapper;
    
    private final TriggerRecordMapper triggerRecordMapper;
    
    private final EventLogMapper eventLogMapper;
    
    private final TriggerLaunchflowMapper triggerLaunchflowMapper;


    public List<TaskEntity> delete(List<String> ids, boolean isBatch) throws WorkFlowException {
        List<TaskEntity> taskList = taskMapper.getOrderStaList(ids);
        List<TaskEntity> taskStatus = taskList.stream()
                .filter(t -> TaskStatusEnum.PAUSED.getCode().equals(t.getStatus())).collect(Collectors.toList());
        if (!taskStatus.isEmpty()) {
            throw new WorkFlowException(isBatch ? taskStatus.get(0).getFullName() + MsgCode.WF113.get() : MsgCode.WF114.get());
        }
        if (!isBatch) {
            List<Integer> status = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.RECALL.getCode());
            List<TaskEntity> taskStateList = taskList.stream().filter(e -> !status.contains(e.getStatus())).collect(Collectors.toList());
            if (!taskStateList.isEmpty()) {
                throw new WorkFlowException(MsgCode.WF063.get());
            }
        }

        List<TaskEntity> child = taskList.stream()
                .filter(t -> StringUtil.isNotEmpty(t.getParentId()) && !FlowNature.PARENT_ID.equals(t.getParentId())).collect(Collectors.toList());
        if (!child.isEmpty()) {
            throw new WorkFlowException(child.get(0).getFullName() + MsgCode.WF021.get());
        }

        for (TaskEntity entity : taskList) {
            List<TriggerLaunchflowEntity> triggerList = triggerLaunchflowMapper.getTaskIds(entity.getId());
            if (!triggerList.isEmpty()) {
                throw new WorkFlowException(entity.getFullName() + MsgCode.WF157.get());
            }
        }
        delete(ids);
        return taskList;
    }

    public void delete(List<String> idList) {
        List<String> idAll = new ArrayList<>();
        taskMapper.deleTaskAll(idList, idAll);
        List<String> revokeTaskIds = revokeMapper.getByTaskId(idAll);
        idAll.addAll(revokeTaskIds);
        if (!idAll.isEmpty()) {
            QueryWrapper<TaskEntity> task = new QueryWrapper<>();
            task.lambda().in(TaskEntity::getId, idAll);
            taskMapper.deleteByIds(taskMapper.selectList(task));
            // 候选人
            QueryWrapper<CandidatesEntity> candidates = new QueryWrapper<>();
            candidates.lambda().select(CandidatesEntity::getId);
            candidates.lambda().in(CandidatesEntity::getTaskId, idAll);
            candidatesMapper.deleteByIds(candidatesMapper.selectList(candidates));
            // 发起人
            QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
            launchUser.lambda().select(LaunchUserEntity::getId);
            launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
            launchUserMapper.deleteByIds(launchUserMapper.selectList(launchUser));
            // 评论
            QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
            comment.lambda().select(CommentEntity::getId);
            comment.lambda().in(CommentEntity::getTaskId, idAll);
            commentMapper.deleteByIds(commentMapper.selectList(comment));
            // 经办
            QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
            operator.lambda().select(OperatorEntity::getId);
            operator.lambda().in(OperatorEntity::getTaskId, idAll);
            operatorMapper.deleteByIds(operatorMapper.selectList(operator));
            // 记录
            QueryWrapper<RecordEntity> recordEntityQueryWrapper = new QueryWrapper<>();
            recordEntityQueryWrapper.lambda().select(RecordEntity::getId);
            recordEntityQueryWrapper.lambda().in(RecordEntity::getTaskId, idAll);
            recordMapper.deleteByIds(recordMapper.selectList(recordEntityQueryWrapper));
            // 退回信息
            List<TaskEntity> taskList = taskMapper.selectList(task);
            List<String> rejectDataIds = taskList.stream().map(TaskEntity::getRejectDataId).collect(Collectors.toList());
            if (CollUtil.isNotEmpty(rejectDataIds)) {
                QueryWrapper<RejectDataEntity> rejectData = new QueryWrapper<>();
                rejectData.lambda().select(RejectDataEntity::getId);
                rejectData.lambda().in(RejectDataEntity::getId, rejectDataIds);
                rejectDataMapper.deleteByIds(rejectDataMapper.selectList(rejectData));
            }
            // 抄送
            QueryWrapper<CirculateEntity> circulate = new QueryWrapper<>();
            circulate.lambda().select(CirculateEntity::getId);
            circulate.lambda().in(CirculateEntity::getTaskId, idAll);
            circulateMapper.deleteByIds(circulateMapper.selectList(circulate));
            // 任务条件
            QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
            taskLine.lambda().select(TaskLineEntity::getId);
            taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
            taskLineMapper.deleteByIds(taskLineMapper.selectList(taskLine));
            // 撤销
            QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
            revoke.lambda().select(RevokeEntity::getId);
            revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
            revokeMapper.deleteByIds(revokeMapper.selectList(revoke));
            //节点流转
            QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
            nodeRecord.lambda().select(NodeRecordEntity::getId);
            nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
            nodeRecordMapper.deleteByIds(nodeRecordMapper.selectList(nodeRecord));
            //外部事件
            QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
            eventLog.lambda().select(EventLogEntity::getId);
            eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
            eventLogMapper.deleteByIds(eventLogMapper.selectList(eventLog));
            // 任务流程
            QueryWrapper<TriggerTaskEntity> triggerTask = new QueryWrapper<>();
            triggerTask.lambda().select(TriggerTaskEntity::getId);
            triggerTask.lambda().and(t -> t.in(TriggerTaskEntity::getTaskId, idAll).or().in(TriggerTaskEntity::getId, idAll));
            List<TriggerTaskEntity> list = triggerTaskMapper.selectList(triggerTask);
            List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
            if (!ids.isEmpty()) {
                triggerTaskMapper.deleteByIds(list);
                QueryWrapper<TriggerRecordEntity> triggerRecord = new QueryWrapper<>();
                triggerRecord.lambda().select(TriggerRecordEntity::getId);
                triggerRecord.lambda().in(TriggerRecordEntity::getTriggerId, ids);
                triggerRecordMapper.deleteByIds(triggerRecordMapper.selectList(triggerRecord));
                QueryWrapper<TriggerLaunchflowEntity> triggerLaunch = new QueryWrapper<>();
                triggerLaunch.lambda().select(TriggerLaunchflowEntity::getId);
                triggerLaunch.lambda().in(TriggerLaunchflowEntity::getTriggerId, ids);
                triggerLaunchflowMapper.deleteByIds(triggerLaunchflowMapper.selectList(triggerLaunch));
            }
        }
    }


    // 归档 当前流程所有人：包含流程的发起人、所有节点的审批人及抄送人员，不包含加签和转审人员；（审批人读取参与审批的人）
    public List<String> getListOfFile(String taskId) {
        List<String> resList = new ArrayList<>();
        List<OperatorEntity> operatorList = operatorMapper.getList(taskId);
        if (CollUtil.isNotEmpty(operatorList)) {
            List<Integer> status = ImmutableList.of(OperatorStateEnum.ADD_SIGN.getCode(), OperatorStateEnum.TRANSFER.getCode(),
                    OperatorStateEnum.ASSIST.getCode(), OperatorStateEnum.FUTILITY.getCode());
            List<OperatorEntity> list = operatorList.stream()
                    .filter(e -> !status.contains(e.getStatus()) && e.getHandleStatus() != null)
                    .collect(Collectors.toList());

            resList.addAll(list.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList()));
        }
        List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
        if (CollUtil.isNotEmpty(circulateList)) {
            resList.addAll(circulateList.stream().map(CirculateEntity::getUserId).collect(Collectors.toList()));
        }
        return resList.stream().distinct().collect(Collectors.toList());
    }

    // 归档 最后节点审批人：表示最后节点的审批人才有权限查看该文档（取最后节点实际参与审批的人，不包含加签和转审人员）；
    public List<String> getListOfLast(String taskId) {
        List<String> resList = new ArrayList<>();

        List<Integer> status = ImmutableList.of(OperatorStateEnum.ADD_SIGN.getCode(), OperatorStateEnum.TRANSFER.getCode(),
                OperatorStateEnum.ASSIST.getCode(), OperatorStateEnum.FUTILITY.getCode());

        QueryWrapper<OperatorEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(OperatorEntity::getTaskId, taskId)
                .ne(OperatorEntity::getHandleId, FlowNature.SYSTEM_CODE)
                .notIn(OperatorEntity::getStatus, status)
                .isNotNull(OperatorEntity::getHandleStatus).orderByDesc(OperatorEntity::getHandleTime);

        List<OperatorEntity> list = operatorMapper.selectList(queryWrapper);
        if (CollUtil.isNotEmpty(list)) {
            // 获取符合条件的最后一个审批人，通过该审批人获取节点
            OperatorEntity operator = list.get(0);
            List<OperatorEntity> operatorList = list.stream()
                    .filter(e -> ObjectUtil.equals(operator.getNodeId(), e.getNodeId()))
                    .sorted(Comparator.comparing(OperatorEntity::getHandleTime).reversed()).collect(Collectors.toList());
            if (CollUtil.isNotEmpty(operatorList)) {
                List<String> handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList());
                resList.addAll(handleIds);
            }
            List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
            if (CollUtil.isNotEmpty(circulateList)) {
                List<String> userIds = circulateList.stream().filter(e -> ObjectUtil.equals(operator.getNodeId(), e.getNodeId()))
                        .map(CirculateEntity::getUserId).collect(Collectors.toList());
                resList.addAll(userIds);
            }
        }
        return resList.stream().distinct().collect(Collectors.toList());
    }

}