package jnpf.flowable.util;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.google.common.collect.ImmutableList;
import jnpf.flowable.entity.*;
import jnpf.flowable.enums.*;
import jnpf.flowable.mapper.*;
import jnpf.flowable.model.record.ProgressModel;
import jnpf.flowable.model.record.RecordVo;
import jnpf.flowable.model.record.UserItem;
import jnpf.flowable.model.task.FlowModel;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.FlowNature;
import jnpf.permission.entity.UserEntity;
import jnpf.util.JsonUtil;
import jnpf.util.RandomUtil;
import jnpf.util.StringUtil;
import jnpf.util.UploaderUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

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

/**
 * 类的描述
 *
 * @author JNPF@YinMai Info. Co., Ltd
 * @version 5.0.x
 * @since 2024/4/26 17:05
 */
@Component
public class RecordUtil {
    @Autowired
    private ServiceUtil serviceUtil;
    @Autowired
    private RecordMapper recordMapper;
    @Autowired
    private CirculateMapper circulateMapper;
    @Autowired
    private OperatorMapper operatorMapper;
    @Autowired
    private NodeRecordMapper nodeRecordMapper;
    @Autowired
    private TriggerTaskMapper triggerTaskMapper;
    @Autowired
    private EventLogMapper eventLogMapper;


    /**
     * 获取流转记录
     *
     * @param records 流转记录集合
     */
    public List<RecordVo> getRecordList(List<RecordEntity> records) {
        return getRecordList(records, new ArrayList<>());
    }

    /**
     * 获取流转记录
     *
     * @param records 流转记录集合
     */
    public List<RecordVo> getRecordList(List<RecordEntity> records, List<TemplateNodeEntity> nodeEntities) {
        List<RecordVo> vos = new ArrayList<>();
        if (CollectionUtil.isNotEmpty(records)) {
            List<UserEntity> userList = serviceUtil.getUserName(records.stream().map(RecordEntity::getHandleId).collect(Collectors.toList()));
            for (RecordEntity record : records) {
                String nodeCode = record.getNodeCode();
                RecordVo vo = JsonUtil.getJsonToBean(record, RecordVo.class);
                UserEntity userEntity = userList.stream().filter(t -> t.getId().equals(record.getHandleId())).findFirst().orElse(null);
                vo.setUserName(userEntity != null ? userEntity.getRealName() + "/" + userEntity.getAccount() : "");
                if (userEntity != null) {
                    vo.setHeadIcon(UploaderUtil.uploaderImg(userEntity.getHeadIcon()));
                }
                // 设置流转操作人
                String handleUserId = record.getHandleUserId();
                if (StringUtil.isNotEmpty(handleUserId)) {
                    List<String> userIds = Arrays.stream(handleUserId.split(",")).collect(Collectors.toList());
                    List<UserEntity> handleUserList = serviceUtil.getUserName(userIds);
                    List<String> handleUserName = new ArrayList<>();
                    for (String userId : userIds) {
                        UserEntity user = handleUserList.stream().filter(t -> t.getId().equals(userId)).findFirst().orElse(null);
                        if (null != user) {
                            handleUserName.add(user.getRealName() + "/" + user.getAccount());
                        }
                    }
                    if (CollectionUtil.isNotEmpty(handleUserName)) {
                        vo.setHandleUserName(String.join(",", handleUserName));
                    }
                }
                if (record.getExpandField() != null) {
                    List<Map<String, Object>> expandField = JsonUtil.getJsonToListMap(record.getExpandField());
                    vo.setApprovalField(expandField);
                }
                TemplateNodeEntity templateNode = nodeEntities.stream().filter(e -> Objects.equals(nodeCode, e.getNodeCode())).findFirst().orElse(null);
                if (templateNode != null) {
                    vo.setIsOutSideNode(Objects.equals(templateNode.getNodeType(), NodeEnum.outside.getType()));
                }
                vos.add(vo);
            }
        }
        return vos;
    }

    /**
     * 进度
     *
     * @param flowModel 参数
     */
    public List<ProgressModel> getProgressList(FlowModel flowModel) {
        List<ProgressModel> progressList = new ArrayList<>();
        String opType = flowModel.getOpType();
        TaskEntity taskEntity = flowModel.getTaskEntity();
        RecordEntity recordEntity = flowModel.getRecordEntity();
        List<TemplateNodeEntity> nodeEntities = flowModel.getNodeEntityList();

        List<NodeRecordEntity> nodeRecordList = nodeRecordMapper.getList(taskEntity.getId());

        List<OperatorEntity> operatorList = operatorMapper.getList(taskEntity.getId());
        List<RecordEntity> recordList = recordMapper.getList(taskEntity.getId());
        List<EventLogEntity> eventLogList = eventLogMapper.getList(taskEntity.getId());
        List<CirculateEntity> circulateList = circulateMapper.getList(taskEntity.getId());

        List<String> userIds = new ArrayList<>();
        List<String> operatorUserIds = operatorList.stream().map(OperatorEntity::getHandleId).collect(Collectors.toList());
        List<String> recordUserIds = recordList.stream().map(RecordEntity::getHandleId).collect(Collectors.toList());
        userIds.addAll(operatorUserIds);
        userIds.addAll(recordUserIds);
        userIds = userIds.stream().distinct().collect(Collectors.toList());

        List<UserEntity> users = serviceUtil.getUserName(userIds, false);

        for (NodeRecordEntity nodeRecord : nodeRecordList) {

            TemplateNodeEntity nodeEntity = nodeEntities.stream().filter(e -> e.getNodeCode().equals(nodeRecord.getNodeCode())).findFirst().orElse(null);
            if (null == nodeEntity) {
                continue;
            }
            NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
            if (nodeModel.getType().equals(NodeEnum.subFlow.getType())) {
                continue;
            }
            ProgressModel model = new ProgressModel();
            model.setId(RandomUtil.uuId());
            model.setStartTime(nodeRecord.getCreatorTime().getTime());
            model.setNodeId(nodeRecord.getNodeId());
            model.setNodeCode(nodeRecord.getNodeCode());
            model.setNodeName(nodeRecord.getNodeName());
            model.setNodeType(NodeEnum.approver.getType());
            model.setNodeStatus(nodeRecord.getNodeStatus());
            boolean isCirculate = circulateList.stream().anyMatch(e -> e.getNodeId().equals(nodeRecord.getNodeId()));
            model.setIsCirculate(isCirculate);
            if (nodeModel.getType().equals(NodeEnum.start.getType())) {
                model.setNodeType(NodeEnum.start.getType());
                progressList.add(model);
                continue;
            }

            if (nodeModel.getType().equals(NodeEnum.outside.getType())) {
                model.setNodeType(NodeEnum.outside.getType());
                progressList.add(model);
                continue;
            }

            model.setCounterSign(nodeModel.getCounterSign());
            model.setAssigneeType(nodeModel.getAssigneeType());

            List<RecordEntity> records = recordList.stream()
                    .filter(e -> Objects.equals(e.getNodeCode(), nodeModel.getNodeId()) && Objects.equals(e.getNodeId(), nodeRecord.getNodeId()))
                    .sorted(Comparator.comparing(RecordEntity::getHandleTime).reversed()).collect(Collectors.toList());

            model.setApproverCount(records.size());

            List<UserItem> items = new ArrayList<>();
            for (int i = 0; i < records.size(); i++) {
                UserItem item = new UserItem();
                RecordEntity record = records.get(i);
                UserEntity user = users.stream().filter(e -> ObjectUtil.equals(record.getHandleId(), e.getId())).findFirst().orElse(null);
                if (user != null) {
                    item.setHeadIcon(UploaderUtil.uploaderImg(user.getHeadIcon()));
                    item.setUserId(user.getId());
                    item.setUserName(user.getRealName());
                } else {
                    item.setHeadIcon(UploaderUtil.uploaderImg(FlowNature.SYSTEM_HEAD_ICON));
                    item.setUserId(FlowNature.SYSTEM_CODE);
                    item.setUserName(FlowNature.SYSTEM_NAME);
                }
                item.setHandleType(record.getHandleType());
                items.add(item);
                if (i == 3) {
                    break;
                }
            }
            model.setApprover(items);
            // 判断是否存在任务流程
            model.setShowTaskFlow(triggerTaskMapper.existTriggerTask(taskEntity.getId(), model.getNodeId()));
            progressList.add(model);
        }

        // 当前节点
        List<Integer> status = ImmutableList.of(TaskStatusEnum.RECALL.getCode(), TaskStatusEnum.BACKED.getCode(), TaskStatusEnum.CANCEL.getCode());
        if (taskEntity.getEndTime() == null && !status.contains(taskEntity.getStatus())) {
            String currentNodeCode = taskEntity.getCurrentNodeCode();
            if (StringUtil.isNotBlank(currentNodeCode)) {
                List<String> currentCodeList = Arrays.stream(currentNodeCode.split(",")).collect(Collectors.toList());

                for (int i = 0; i < currentCodeList.size(); i++) {
                    String nodeCode = currentCodeList.get(i);

                    TemplateNodeEntity nodeEntity = nodeEntities.stream().filter(e -> e.getNodeCode().equals(nodeCode)).findFirst().orElse(null);
                    if (null == nodeEntity) {
                        continue;
                    }
                    NodeModel nodeModel = JsonUtil.getJsonToBean(nodeEntity.getNodeJson(), NodeModel.class);
                    if (nodeModel.getType().equals(NodeEnum.subFlow.getType())) {
                        continue;
                    }
                    boolean isProcessing = ObjectUtil.equals(nodeEntity.getNodeType(), NodeEnum.processing.getType());
                    boolean isOutside = ObjectUtil.equals(nodeEntity.getNodeType(), NodeEnum.outside.getType());
                    ProgressModel model = new ProgressModel();
                    model.setId(RandomUtil.uuId());

                    model.setNodeCode(nodeCode);
                    model.setNodeName(nodeModel.getNodeName());
                    model.setNodeType(isProcessing ? NodeEnum.processing.getType() : isOutside ? NodeEnum.outside.getType() : NodeEnum.approver.getType());
                    model.setNodeStatus(isProcessing ? NodeStateEnum.transact.getCode() : NodeStateEnum.approval.getCode());
                    model.setCounterSign(nodeModel.getCounterSign());
                    model.setAssigneeType(nodeModel.getAssigneeType());

                    List<OperatorEntity> operators = operatorList.stream()
                            .filter(e -> Objects.equals(e.getNodeCode(), nodeModel.getNodeId())
                                    && !(ObjectUtil.equals(e.getCompletion(), FlowNature.Action) && null == e.getHandleTime() && !ObjectUtil.equals(e.getParentId(), FlowNature.ParentId))
                                    && !Objects.equals(e.getStatus(), OperatorStateEnum.Assist.getCode())
                                    && !Objects.equals(e.getStatus(), OperatorStateEnum.Futility.getCode())
                            ).sorted(Comparator.comparing(OperatorEntity::getCreatorTime, Comparator.reverseOrder())
                                    .thenComparing(OperatorEntity::getCompletion))
                            .collect(Collectors.toList());

                    if (CollectionUtil.isNotEmpty(operators)) {
                        OperatorEntity operator = operators.get(0);
                        String nodeId = operator.getNodeId();
                        model.setStartTime(operator.getCreatorTime().getTime());
                        operators = operators.stream().filter(e -> ObjectUtil.equals(e.getNodeId(), nodeId)).collect(Collectors.toList());
                        // 触发节点选择同步，变更为等待中状态
                        if (ObjectUtil.equals(operator.getStatus(), OperatorStateEnum.Waiting.getCode())) {
                            model.setNodeStatus(NodeStateEnum.wait.getCode());
                        }
                        model.setNodeId(nodeId);
                        boolean isCirculate = circulateList.stream().anyMatch(e -> e.getNodeId().equals(nodeId));
                        model.setIsCirculate(isCirculate);
                    } else {
                        List<EventLogEntity> eventLogs = eventLogList.stream().filter(e -> Objects.equals(e.getNodeCode(), nodeCode)).sorted(Comparator.comparing(EventLogEntity::getCreatorTime, Comparator.reverseOrder())).collect(Collectors.toList());
                        if (CollectionUtil.isNotEmpty(eventLogs)) {
                            EventLogEntity eventLog = eventLogs.get(0);
                            String nodeId = eventLog.getNodeId();
                            model.setStartTime(eventLog.getCreatorTime().getTime());
                            model.setOutSideStatus(Objects.equals(eventLog.getStatus(), 0));
                            model.setErrorTip(eventLog.getResult());
                            model.setErrorData(eventLog.getData());
                            model.setNodeId(nodeId);
                            if (Objects.equals(OpTypeEnum.LaunchDetail.getType(), opType)) {
                                model.setIsRetry(true);
                            }
                            if (Objects.equals(OpTypeEnum.Done.getType(), opType)) {
                                if (recordEntity != null && Objects.equals(recordEntity.getNodeCode(), eventLog.getUpNode())) {
                                    model.setIsRetry(true);
                                }
                            }
                        }
                    }

                    List<RecordEntity> records = recordList.stream()
                            .filter(e -> Objects.equals(e.getNodeCode(), nodeModel.getNodeId()))
                            .sorted(Comparator.comparing(RecordEntity::getHandleTime).reversed()).collect(Collectors.toList());

                    List<UserItem> items = new ArrayList<>();
                    for (OperatorEntity operator : operators) {
                        UserItem item = new UserItem();
                        UserEntity user = users.stream().filter(e -> ObjectUtil.equals(operator.getHandleId(), e.getId())).findFirst().orElse(null);
                        if (user != null) {
                            item.setHeadIcon(UploaderUtil.uploaderImg(user.getHeadIcon()));
                            item.setUserId(user.getId());
                            item.setUserName(user.getRealName());
                        } else {
                            if (ObjectUtil.equals(operator.getHandleId(), FlowNature.SYSTEM_CODE)) {
                                item.setHeadIcon(FlowNature.SYSTEM_HEAD_ICON);
                                item.setUserName(FlowNature.SYSTEM_NAME);
                                item.setUserId(FlowNature.SYSTEM_CODE);
                            }
                        }

                        if (null != operator.getHandleStatus() && null != operator.getHandleTime()) {
                            item.setHandleType(operator.getHandleStatus());
                        } else {
                            RecordEntity record = records.stream().sorted(Comparator.comparing(RecordEntity::getId).reversed())
                                    .filter(e -> ObjectUtil.equals(e.getOperatorId(), operator.getId())
                                            && ObjectUtil.equals(e.getNodeId(), operator.getNodeId())
                                            && !ObjectUtil.equals(e.getStatus(), FlowNature.Invalid)
                                            && !ObjectUtil.equals(e.getHandleType(), RecordEnum.back.getCode()))
                                    .findFirst().orElse(null);
                            if (null != record) {
                                item.setHandleType(record.getHandleType());
                            } else {
                                // -1.待审  -2.未审  -3.待办理  -4.未办理（暂未用到）
                                item.setHandleType(isProcessing ? -3 : -1);
                            }
                        }
                        items.add(item);
                    }
                    model.setApproverCount(items.size());
                    items = items.stream().sorted(Comparator.comparing(UserItem::getHandleType)).collect(Collectors.toList());
                    if (items.size() > 4) {
                        items = items.subList(0, 4);
                    }
                    model.setApprover(items);
                    progressList.add(model);
                }
            }
        }

        // 添加结束节点
        if (taskEntity.getEndTime() != null) {
            ProgressModel model = new ProgressModel();
            model.setId(RandomUtil.uuId());
            model.setStartTime(taskEntity.getEndTime().getTime());
            model.setNodeType(NodeEnum.end.getType());
            model.setNodeName(FlowNature.END_NAME);
            progressList.add(model);
        }
        return progressList;
    }
}