package jnpf.flowable.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.google.common.collect.ImmutableList;
import jnpf.base.UserInfo;
import jnpf.base.service.SuperServiceImpl;
import jnpf.constant.MsgCode;
import jnpf.exception.WorkFlowException;
import jnpf.flowable.entity.*;
import jnpf.flowable.enums.*;
import jnpf.flowable.mapper.TriggerTaskMapper;
import jnpf.flowable.model.templatejson.TemplateJsonInfoVO;
import jnpf.flowable.model.templatenode.ButtonModel;
import jnpf.flowable.model.templatenode.TaskNodeModel;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.trigger.*;
import jnpf.flowable.model.util.FlowNature;
import jnpf.flowable.service.*;
import jnpf.flowable.util.TriggerUtil;
import jnpf.util.JsonUtil;
import jnpf.util.StringUtil;
import jnpf.util.UserProvider;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 类的描述
 *
 * @author JNPF@YinMai Info. Co., Ltd
 * @version 5.0.x
 * @since 2024/9/10 17:13
 */
@Service
public class TriggerTaskServiceImpl extends SuperServiceImpl<TriggerTaskMapper, TriggerTaskEntity> implements TriggerTaskService {
    @Autowired
    private TriggerRecordService triggerRecordService;
    @Autowired
    private TemplateService templateService;
    @Autowired
    private TemplateJsonService templateJsonService;
    @Autowired
    private TemplateNodeService templateNodeService;
    @Autowired
    private TriggerUtil triggerUtil;

    @Override
    public List<TriggerInfoListModel> getListByTaskId(String taskId, String nodeCode) {
        QueryWrapper<TriggerTaskEntity> queryWrapper = new QueryWrapper<>();
        if (StringUtil.isNotBlank(taskId)) {
            queryWrapper.lambda().eq(TriggerTaskEntity::getTaskId, taskId);
        }
        if (StringUtil.isNotBlank(nodeCode)) {
            queryWrapper.lambda().eq(TriggerTaskEntity::getNodeId, nodeCode);
        }
        queryWrapper.lambda().orderByDesc(TriggerTaskEntity::getStartTime);
        List<TriggerTaskEntity> list = this.list(queryWrapper);
        List<TriggerInfoListModel> modelList = new ArrayList<>();
        if (CollectionUtil.isNotEmpty(list)) {
            for (TriggerTaskEntity triggerTask : list) {
                TriggerInfoListModel model = JsonUtil.getJsonToBean(triggerTask, TriggerInfoListModel.class);
                List<TriggerRecordEntity> recordList = triggerRecordService.getList(triggerTask.getId());
                model.setRecordList(recordList);
                modelList.add(model);
            }
        }
        return modelList;
    }

    @Override
    public boolean existTriggerTask(String taskId, String nodeId) {
        if (StringUtil.isBlank(taskId) || StringUtil.isBlank(nodeId)) {
            return false;
        }
        QueryWrapper<TriggerTaskEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(TriggerTaskEntity::getTaskId, taskId)
                .eq(TriggerTaskEntity::getNodeId, nodeId);
        return this.count(queryWrapper) > 0;
    }

    @Override
    public List<TriggerTaskModel> getList(TriggerPagination pagination) {

        MPJLambdaWrapper<TriggerTaskEntity> wrapper = JoinWrappers.lambda(TriggerTaskEntity.class)
                .select(TriggerTaskEntity::getId, TriggerTaskEntity::getFullName,
                        TriggerTaskEntity::getParentId, TriggerTaskEntity::getParentTime,
                        TriggerTaskEntity::getStatus, TriggerTaskEntity::getStartTime
                )
                .selectAs(TemplateEntity::getStatus, TriggerTaskModel::getTemplateStatus)
                .selectAs(TemplateEntity::getSystemId, TriggerTaskModel::getSystemName)
                .leftJoin(TemplateJsonEntity.class, TemplateJsonEntity::getId, TriggerTaskEntity::getFlowId)
                .leftJoin(TemplateEntity.class, TemplateEntity::getId, TemplateJsonEntity::getTemplateId)
                .isNull(TriggerTaskEntity::getTaskId);

        String keyword = pagination.getKeyword();
        if (StringUtil.isNotEmpty(keyword)) {
            wrapper.and(e -> e.like(TriggerTaskEntity::getFullName, keyword)
                    .or().like(TriggerTaskEntity::getId, keyword));
        }
        if (ObjectUtil.isNotEmpty(pagination.getStartTime()) && ObjectUtil.isNotEmpty(pagination.getEndTime())) {
            wrapper.between(TriggerTaskEntity::getStartTime, new Date(pagination.getStartTime()), new Date(pagination.getEndTime()));
        }
        String systemId = pagination.getSystemId();
        if (ObjectUtil.isNotEmpty(systemId)) {
            wrapper.eq(TemplateEntity::getSystemId, systemId);
        }
        wrapper.orderByDesc(TriggerTaskEntity::getCreatorTime);

        Page<TriggerTaskModel> page = new Page<>(pagination.getCurrentPage(), pagination.getPageSize());
        Page<TriggerTaskModel> iPage = this.selectJoinListPage(page, TriggerTaskModel.class, wrapper);
        return pagination.setData(iPage.getRecords(), page.getTotal());
    }

    @Override
    public TriggerInfoModel getInfo(String id) throws WorkFlowException {
        TriggerTaskEntity triggerTask = this.getById(id);
        if (null == triggerTask) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        TriggerInfoModel model = new TriggerInfoModel();
        model.setTaskInfo(JsonUtil.getJsonToBean(triggerTask, TriggerTaskModel.class));
        TemplateJsonInfoVO jsonInfoVO = templateJsonService.getInfoVo(triggerTask.getFlowId());
        model.setFlowInfo(jsonInfoVO);
        List<TriggerRecordEntity> recordList = triggerRecordService.getList(triggerTask.getId());
        List<TaskNodeModel> nodeList = this.getNodeList(triggerTask, recordList);
        model.setNodeList(nodeList);
        recordList = recordList.stream().filter(e -> e.getStatus() != null).collect(Collectors.toList());
        model.setRecordList(recordList);
        ButtonModel btnInfo = model.getBtnInfo();
        if (ObjectUtil.equals(triggerTask.getStatus(), TaskStatusEnum.RUNNING.getCode())) {
            btnInfo.setHasCancelBtn(true);
        }
        return model;
    }

    public List<TaskNodeModel> getNodeList(TriggerTaskEntity triggerTask, List<TriggerRecordEntity> recordList) {
        List<TaskNodeModel> list = new ArrayList<>();
        if (ObjectUtil.equals(triggerTask.getStatus(), TaskStatusEnum.CANCEL.getCode())) {
            return list;
        }
        String flowId = triggerTask.getFlowId();
        List<TemplateNodeEntity> nodeEntityList = templateNodeService.getList(flowId);
        List<String> typeList = ImmutableList.of(NodeEnum.global.getType(), NodeEnum.connect.getType(), "confluence", "gateway");
        List<String> divideList = Arrays.stream(DivideRuleEnum.values()).map(DivideRuleEnum::getType).collect(Collectors.toList());
        divideList.addAll(typeList);
        for (TemplateNodeEntity node : nodeEntityList) {
            if (divideList.contains(node.getNodeType())) {
                continue;
            }
            TaskNodeModel model = new TaskNodeModel();
            NodeModel nodeModel = JsonUtil.getJsonToBean(node.getNodeJson(), NodeModel.class);
            model.setNodeName(nodeModel.getNodeName());
            model.setNodeCode(nodeModel.getNodeId());
            model.setNodeType(nodeModel.getType());

            String nodeCode = node.getNodeCode();
            if (ObjectUtil.equals(node.getNodeType(), NodeEnum.start.getType())) {
                nodeCode = FlowNature.START_CODE;
            } else if (ObjectUtil.equals(node.getNodeType(), NodeEnum.end.getType())) {
                nodeCode = FlowNature.END_CODE;
            }
            String finalNodeCode = nodeCode;
            TriggerRecordEntity record = recordList.stream().filter(e -> ObjectUtil.equals(e.getNodeCode(), finalNodeCode)).findFirst().orElse(null);
            if (null != record) {
                String type = NodeTypeEnum.current.getType();
                if (ObjectUtil.equals(record.getStatus(), TriggerRecordEnum.PASSED.getCode())) {
                    type = NodeTypeEnum.pass.getType();
                } else if (ObjectUtil.equals(record.getStatus(), TriggerRecordEnum.EXCEPTION.getCode())) {
                    type = NodeTypeEnum.exception.getType();
                }
                model.setType(type);
            }
            list.add(model);
        }
        return list;
    }

    @Override
//    @DSTransactional
    public void retry(String id) throws Exception {
        TriggerTaskEntity triggerTask = this.getById(id);
        if (null == triggerTask) {
            throw new WorkFlowException(MsgCode.FA001.get());
        }
        TemplateJsonEntity jsonEntity = templateJsonService.getInfo(triggerTask.getFlowId());
        TemplateEntity template = templateService.getInfo(jsonEntity.getTemplateId());
        if (!ObjectUtil.equals(template.getStatus(), TemplateStatueEnum.up.getCode())) {
            throw new WorkFlowException(MsgCode.WF146.get());
        }
        ExecuteModel model = new ExecuteModel();
        model.setFlowId(triggerTask.getFlowId());
        List<Map> jsonToList = JsonUtil.getJsonToList(triggerTask.getData(), Map.class);
        List<Map<String, Object>> dataList = triggerUtil.castListMap(jsonToList);
        model.setDataList(dataList);
        UserInfo userInfo = UserProvider.getUser();
        model.setUserInfo(userInfo);
        model.setParentId(triggerTask.getId());
        triggerUtil.execute(model);
    }

    @Override
    public void saveTriggerTask(TriggerTaskEntity entity) {
        this.save(entity);
    }

    @Override
    public void updateTriggerTask(TriggerTaskEntity entity) {
        this.updateById(entity);
    }

    @Override
    public void batchDelete(List<String> ids) {
        if (ids.isEmpty()) {
            return;
        }
        this.removeByIds(ids);
        triggerRecordService.delete(ids);
    }

    @Override
    public void deleteByTaskId(List<String> taskId) {
        if (CollectionUtil.isEmpty(taskId)) {
            return;
        }
        QueryWrapper<TriggerTaskEntity> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().in(TriggerTaskEntity::getTaskId, taskId);
        List<TriggerTaskEntity> list = this.list(queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            return;
        }
        List<String> ids = list.stream().map(TriggerTaskEntity::getId).collect(Collectors.toList());
        this.setIgnoreLogicDelete().removeByIds(ids);
        this.clearIgnoreLogicDelete();
        QueryWrapper<TriggerRecordEntity> wrapper = new QueryWrapper<>();
        wrapper.lambda().select(TriggerRecordEntity::getId);
        wrapper.lambda().in(TriggerRecordEntity::getTriggerId, ids);
        triggerRecordService.setIgnoreLogicDelete().removeByIds(triggerRecordService.list(wrapper));
        triggerRecordService.clearIgnoreLogicDelete();
    }

    @Override
    public boolean checkByFlowIds(List<String> flowIds) {
        if (CollectionUtil.isNotEmpty(flowIds)) {
            QueryWrapper<TriggerTaskEntity> queryWrapper = new QueryWrapper<>();
            queryWrapper.lambda().in(TriggerTaskEntity::getFlowId, flowIds);
            return this.count(queryWrapper) > 0;
        }
        return false;
    }
}