package jnpf.flowable.util;

import cn.hutool.core.collection.CollectionUtil;
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.NodeEnum;
import jnpf.flowable.enums.OperatorStateEnum;
import jnpf.flowable.enums.TaskStatusEnum;
import jnpf.flowable.mapper.*;
import jnpf.flowable.model.util.FlowNature;
import jnpf.flowable.service.RejectDataService;
import jnpf.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

@Component
public class VisuladeUtil {

    @Autowired
    private TaskMapper taskMapper;
    @Autowired
    private TemplateJsonMapper templateJsonMapper;
    @Autowired
    private TemplateNodeMapper templateNodeMapper;
    @Autowired
    private LaunchUserMapper launchUserMapper;
    @Autowired
    private CandidatesMapper candidatesMapper;
    @Autowired
    private OperatorMapper operatorMapper;
    @Autowired
    private RecordMapper recordMapper;
    @Autowired
    private CirculateMapper circulateMapper;
    @Autowired
    private CommentMapper commentMapper;
    @Autowired
    private RejectDataService rejectDataService;
    @Autowired
    private NodeRecordMapper nodeRecordMapper;
    @Autowired
    private TaskLineMapper taskLineMapper;
    @Autowired
    private RevokeMapper revokeMapper;
    @Autowired
    private TriggerTaskMapper triggerTaskMapper;
    @Autowired
    private TriggerRecordMapper triggerRecordMapper;
    @Autowired
    private EventLogMapper eventLogMapper;
    @Autowired
    private TemplateUseNumMapper templateUseNumMapper;


    public List<TaskEntity> delete(String id) throws Exception {
        TaskEntity entity = taskMapper.selectById(id);
        if (null == entity) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        if (TaskStatusEnum.PAUSED.getCode().equals(entity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF114.get());
        }
        List<Integer> status = ImmutableList.of(TaskStatusEnum.TO_BE_SUBMIT.getCode(), TaskStatusEnum.RECALL.getCode());
        if (!status.contains(entity.getStatus())) {
            throw new WorkFlowException(MsgCode.WF063.get());
        }
        if (StringUtil.isNotEmpty(entity.getParentId()) && !FlowNature.ParentId.equals(entity.getParentId())) {
            throw new WorkFlowException(entity.getFullName() + MsgCode.WF021.get());
        }

        List<String> idList = ImmutableList.of(entity.getId());
        this.delete(idList);
        List<TaskEntity> list = ImmutableList.of(entity);
        return list;
    }

    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.setIgnoreLogicDelete().deleteByIds(taskMapper.selectList(task));
            taskMapper.clearIgnoreLogicDelete();
            // 候选人
            QueryWrapper<CandidatesEntity> candidates = new QueryWrapper<>();
            candidates.lambda().select(CandidatesEntity::getId);
            candidates.lambda().in(CandidatesEntity::getTaskId, idAll);
            candidatesMapper.setIgnoreLogicDelete().deleteByIds(candidatesMapper.selectList(candidates));
            candidatesMapper.clearIgnoreLogicDelete();
            // 发起人
            QueryWrapper<LaunchUserEntity> launchUser = new QueryWrapper<>();
            launchUser.lambda().select(LaunchUserEntity::getId);
            launchUser.lambda().in(LaunchUserEntity::getTaskId, idAll);
            launchUserMapper.setIgnoreLogicDelete().deleteByIds(launchUserMapper.selectList(launchUser));
            launchUserMapper.clearIgnoreLogicDelete();
            // 评论
            QueryWrapper<CommentEntity> comment = new QueryWrapper<>();
            comment.lambda().select(CommentEntity::getId);
            comment.lambda().in(CommentEntity::getTaskId, idAll);
            commentMapper.setIgnoreLogicDelete().deleteByIds(commentMapper.selectList(comment));
            commentMapper.clearIgnoreLogicDelete();
            // 经办
            QueryWrapper<OperatorEntity> operator = new QueryWrapper<>();
            operator.lambda().select(OperatorEntity::getId);
            operator.lambda().in(OperatorEntity::getTaskId, idAll);
            operatorMapper.setIgnoreLogicDelete().deleteByIds(operatorMapper.selectList(operator));
            operatorMapper.clearIgnoreLogicDelete();
            // 记录
            QueryWrapper<RecordEntity> record = new QueryWrapper<>();
            record.lambda().select(RecordEntity::getId);
            record.lambda().in(RecordEntity::getTaskId, idAll);
            recordMapper.setIgnoreLogicDelete().deleteByIds(recordMapper.selectList(record));
            recordMapper.clearIgnoreLogicDelete();
            // 退回信息
            List<TaskEntity> taskList = taskMapper.selectList(task);
            List<String> rejectDataIds = taskList.stream().map(TaskEntity::getRejectDataId).collect(Collectors.toList());
            if (CollectionUtil.isNotEmpty(rejectDataIds)) {
                QueryWrapper<RejectDataEntity> rejectData = new QueryWrapper<>();
                rejectData.lambda().select(RejectDataEntity::getId);
                rejectData.lambda().in(RejectDataEntity::getId, rejectDataIds);
                rejectDataService.setIgnoreLogicDelete().removeByIds(rejectDataService.list(rejectData));
                rejectDataService.clearIgnoreLogicDelete();
            }
            // 抄送
            QueryWrapper<CirculateEntity> circulate = new QueryWrapper<>();
            circulate.lambda().select(CirculateEntity::getId);
            circulate.lambda().in(CirculateEntity::getTaskId, idAll);
            circulateMapper.setIgnoreLogicDelete().deleteByIds(circulateMapper.selectList(circulate));
            circulateMapper.clearIgnoreLogicDelete();
            // 任务条件
            QueryWrapper<TaskLineEntity> taskLine = new QueryWrapper<>();
            taskLine.lambda().select(TaskLineEntity::getId);
            taskLine.lambda().in(TaskLineEntity::getTaskId, idAll);
            taskLineMapper.setIgnoreLogicDelete().deleteByIds(taskLineMapper.selectList(taskLine));
            taskLineMapper.clearIgnoreLogicDelete();
            // 撤销
            QueryWrapper<RevokeEntity> revoke = new QueryWrapper<>();
            revoke.lambda().select(RevokeEntity::getId);
            revoke.lambda().in(RevokeEntity::getRevokeTaskId, idAll);
            revokeMapper.setIgnoreLogicDelete().deleteByIds(revokeMapper.selectList(revoke));
            revokeMapper.clearIgnoreLogicDelete();
            //节点流转
            QueryWrapper<NodeRecordEntity> nodeRecord = new QueryWrapper<>();
            nodeRecord.lambda().select(NodeRecordEntity::getId);
            nodeRecord.lambda().in(NodeRecordEntity::getTaskId, idAll);
            nodeRecordMapper.setIgnoreLogicDelete().deleteByIds(nodeRecordMapper.selectList(nodeRecord));
            nodeRecordMapper.clearIgnoreLogicDelete();
            //外部事件
            QueryWrapper<EventLogEntity> eventLog = new QueryWrapper<>();
            eventLog.lambda().select(EventLogEntity::getId);
            eventLog.lambda().in(EventLogEntity::getTaskId, idAll);
            eventLogMapper.setIgnoreLogicDelete().deleteByIds(eventLogMapper.selectList(eventLog));
            eventLogMapper.clearIgnoreLogicDelete();
            // 任务流程
            QueryWrapper<TriggerTaskEntity> triggerTask = new QueryWrapper<>();
            triggerTask.lambda().select(TriggerTaskEntity::getId);
            triggerTask.lambda().in(TriggerTaskEntity::getTaskId, idAll);
            List<TriggerTaskEntity> list = triggerTaskMapper.selectList(triggerTask);
            if (!list.isEmpty()) {
                List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
                triggerTaskMapper.setIgnoreLogicDelete().deleteByIds(list);
                triggerTaskMapper.clearIgnoreLogicDelete();
                QueryWrapper<TriggerRecordEntity> triggerRecord = new QueryWrapper<>();
                triggerRecord.lambda().select(TriggerRecordEntity::getId);
                triggerRecord.lambda().in(TriggerRecordEntity::getTriggerId, ids);
                triggerRecordMapper.setIgnoreLogicDelete().deleteByIds(triggerRecordMapper.selectList(triggerRecord));
                triggerRecordMapper.clearIgnoreLogicDelete();
            }
        }
    }


    // 归档 当前流程所有人：包含流程的发起人、所有节点的审批人及抄送人员，不包含加签和转审人员；（审批人读取参与审批的人）
    public List<String> getListOfFile(String taskId) {
        List<String> resList = new ArrayList<>();
        List<OperatorEntity> operatorList = operatorMapper.getList(taskId);
        if (CollectionUtil.isNotEmpty(operatorList)) {
            List<Integer> status = ImmutableList.of(OperatorStateEnum.AddSign.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 (CollectionUtil.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.AddSign.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 (CollectionUtil.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 (CollectionUtil.isNotEmpty(operatorList)) {
                List<String> handleIds = operatorList.stream().map(OperatorEntity::getHandleId).distinct().collect(Collectors.toList());
                resList.addAll(handleIds);
            }
            List<CirculateEntity> circulateList = circulateMapper.getList(taskId);
            if (CollectionUtil.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());
    }

    public List<String> getFormList() {
        List<String> resList = new ArrayList<>();
        List<TemplateJsonEntity> list = templateJsonMapper.getListOfEnable();
        if (CollectionUtil.isNotEmpty(list)) {
            List<String> flowIds = list.stream().map(TemplateJsonEntity::getId).distinct().collect(Collectors.toList());
            List<TemplateNodeEntity> startNodeList = templateNodeMapper.getList(flowIds, NodeEnum.start.getType());
            resList = startNodeList.stream().map(TemplateNodeEntity::getFormId).distinct().collect(Collectors.toList());
        }
        return resList;
    }


}