package com.ycl.listener.flowable;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ycl.common.utils.spring.SpringUtils;
import com.ycl.domain.entity.ProcessCoding;
import com.ycl.factory.FlowServiceFactory;
import com.ycl.mapper.ProcessCodingMapper;
import lombok.extern.slf4j.Slf4j;
import org.flowable.common.engine.impl.el.FixedValue;
import org.flowable.engine.HistoryService;
import org.flowable.engine.delegate.TaskListener;
import org.flowable.task.api.history.HistoricTaskInstance;
import org.flowable.task.service.delegate.DelegateTask;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.List;

import static com.ycl.common.constant.ProcessOverTimeConstants.GREEN;

/**
 * 任务监听器
 * <p>
 * create（创建）:在任务被创建且所有的任务属性设置完成后才触发
 * assignment（指派）：在任务被分配给某个办理人之后触发
 * complete（完成）：在配置了监听器的上一个任务完成时触发
 * delete（删除）：在任务即将被删除前触发。请注意任务由completeTask正常完成时也会触发
 *
 * @author Tony
 * @date 2021/4/20
 */
@Slf4j
@Component
public class FlowableOverTimeListener implements TaskListener {
    /**
     * 黄码时间
     */
    private FixedValue 黄码时长;
    /**
     * 红码时间
     */
    private FixedValue 红码时长;
    /**
     * 计时起始节点定义Id
     */
    private FixedValue 开始计时节点;

    @Override
    public void notify(DelegateTask delegateTask) {
        log.info("触发超时监听器:{}", delegateTask);
        //Flowable的bean自己管理的需要手动获取
        ProcessCodingMapper processCodingMapper = SpringUtils.getBean(ProcessCodingMapper.class);
        HistoryService historyService = SpringUtils.getBean(HistoryService.class);
        //任务id
        String taskId = delegateTask.getId();
        //流程实例id
        String processInstanceId = delegateTask.getProcessInstanceId();
        ProcessCoding processCoding = new ProcessCoding();
        processCoding.setTaskId(taskId);
        processCoding.setProcessInsId(processInstanceId);
        processCoding.setTaskDefKey(delegateTask.getTaskDefinitionKey());
        //设置状态，查询是否有这个定义节点的历史数据，取最新的一条状态码，避免定时任务还未执行的误差
        List<ProcessCoding> processCodings = processCodingMapper.selectList(new QueryWrapper<ProcessCoding>()
                .eq("process_ins_id",processInstanceId)
                .eq("task_def_key", delegateTask.getTaskDefinitionKey())
                .orderByDesc("gmt_create"));
        if(!CollectionUtils.isEmpty(processCodings)){
            processCoding.setStatus(processCodings.get(0).getStatus());
        }else {
            processCoding.setStatus(GREEN);
        }
        if (黄码时长 != null && 黄码时长.getValue(delegateTask) != null) {
            processCoding.setYellowTime(黄码时长.getValue(delegateTask).toString());
        }
        if (红码时长 != null && 红码时长.getValue(delegateTask) != null) {
            processCoding.setRedTime(红码时长.getValue(delegateTask).toString());
        }
        //设置开始节点
        if (开始计时节点 != null && 开始计时节点.getValue(delegateTask) != null) {
            String taskDefKey = 开始计时节点.getValue(delegateTask).toString();
            //开始节点从历史节点查询 取多条中最早的一条
            List<HistoricTaskInstance> list = historyService.createHistoricTaskInstanceQuery()
                    .processInstanceId(processInstanceId)
                    .taskDefinitionKey(taskDefKey)
                    .orderByHistoricTaskInstanceStartTime()
                    .asc()
                    .list();
            if (!CollectionUtils.isEmpty(list)) {
                HistoricTaskInstance hisTask = list.get(0);
                processCoding.setStartTaskId(hisTask.getId());
            } else {
                //如果为空，说明流程首次走到taskDefKey节点
                processCoding.setStartTaskId(delegateTask.getId());
            }
        }
        processCodingMapper.insert(processCoding);
        log.info("添加节点到定时器");
    }
}