package com.ruoyi.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.DataStatisticsUtils;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.domain.*;
import com.ruoyi.domain.vo.CaseStatisticsVO;
import com.ruoyi.mapper.*;
import com.ruoyi.service.*;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.web.request.*;
import com.ruoyi.web.response.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Transactional
@Service
public class TaskServiceImpl extends ServiceImpl<TaskMapper, Task>implements TaskService {

    @Autowired
    private TaskMapper taskMapper;

    @Autowired
    private ISysUserService sysUserService;

    @Autowired
    private StandardService standardService;

    @Autowired
    private TaskUserRelationService taskUserRelationService;

    @Autowired
    private TaskService taskService;

    @Autowired
    private SystemReviewTaskService systemReviewTaskService;

    @Autowired
    private CarReviewTaskService carReviewTaskService;

    @Autowired
    private SystemReviewTaskMapper systemReviewTaskMapper;

    @Autowired
    private CarReviewTaskMapper carReviewTaskMapper;

    @Autowired
    private ReviewDetailsMapper reviewDetailsMapper;

    @Autowired
    private TaskStateFacade taskStateFacade;

    @Autowired
    private TaskSampleRelationService taskSampleRelationService;

    @Autowired
    private SampleManagementMapper sampleManagementMapper;

    @Autowired
    private TaskSampleRelationMapper taskSampleRelationMapper;

    @Autowired
    private ReviewEnterpriseArchiveMapper reviewEnterpriseArchiveMapper;

    @Autowired
    private ReviewEnterpriseArchiveService reviewEnterpriseArchiveService;

    @Autowired
    private ReviewStandardService reviewStandardService;

    @Autowired
    private ReviewDetailsResultService reviewDetailsResultService;

    @Autowired
    private AutomobileEnterpriseMapper automobileEnterpriseMapper;

    @Autowired
    private ModelTestTaskService modelTestTaskService;

    @Autowired
    private TaskScenarioRelationMapper taskScenarioRelationMapper;

    @Autowired
    private TaskFileRelationService taskFileRelationService;

    @Autowired
    private ModelTestTaskMapper modelTestTaskMapper;

    @Autowired
    private TaskUserRelationMapper taskUserRelationMapper;

    @Autowired
    private TestRecordsMapper testRecordsMapper;

    @Override
    public List<Task> findList(TaskListRequest request) {
        return taskMapper.findList(request);
    }

    /**
     * 创建任务
     * @param request
     */
    @Override
    public void createTask(TaskCreateRequest request) {

        // 构建任务创建者
        LoginUser loginUser = SecurityUtils.getLoginUser();

        TaskGetInfoResponse temporaryStorageTask = taskService.getByUserId(loginUser.getUserId());
        if(temporaryStorageTask != null) {
            taskMapper.deleteById(temporaryStorageTask.getId());

            // 删除暂存任务与整车样品的信息
            List<TaskSampleRelation> sampleRelations = taskSampleRelationService.selectByTaskId(temporaryStorageTask.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE);
            if (sampleRelations != null && sampleRelations.size() != 0) {
                taskSampleRelationService.removeBatchByIds(sampleRelations);
            }

            // 删除暂存任务与零件样品的信息
            List<TaskSampleRelation> partRelationList = taskSampleRelationService.selectByTaskId(temporaryStorageTask.getId(),TaskSampleRelation.PART_VEHICLE_SAMPLE);
            if (partRelationList != null && partRelationList.size() != 0) {
                taskSampleRelationService.removeBatchByIds(partRelationList);
            }

            // 删除暂存任务与小组的信息
            List<TaskUserRelation> list = taskUserRelationService.selectQTeamMembers(temporaryStorageTask.getId());
            if (list != null && list.size() != 0) {
                taskUserRelationService.removeBatchByIds(list);
            }

            // 删除暂存任务与文件的信息
            List<TaskFileRelation> fileRelations = taskFileRelationService.findByTaskId(temporaryStorageTask.getId());
            if (fileRelations != null && fileRelations.size() != 0) {
                taskFileRelationService.removeBatchByIds(fileRelations);
            }
        }

        // TODO 任务名称验重
//        Long sum = taskMapper.findTaskName(request.getTaskName());
//        if (sum > 0) {
//            throw new ServiceException("任务名称重复，请检查", HttpStatus.ERROR);
//        } else {

            SysUser initiator = sysUserService.selectUserById(loginUser.getUserId());
            Standard standard = standardService.findListById(request.getStandardId());

            // 找到审查组长
            TaskUserRelation leader = null;
            List<TaskUserRelation> auditors = request.getAuditors();
            for(TaskUserRelation auditor : auditors) {
                if(auditor.getIsLeader() == 1) {
                    leader = auditor;
                    break;
                }
            }

            // 构建并保存任务信息
            // 总任务
            Task task = new Task();
            task.setTaskInitiatorId(loginUser.getUserId());
            task.setTaskInitiator(initiator.getNickName());
            if (initiator.getDept() != null) {
                task.setTaskInitiatorDept(initiator.getDept().getDeptName());
            }
            task.setTaskStatus(Task.TASK_STATUS_NEW);
            task.setRunStatus(Task.RUN_STATUS_RUNNABLE);
            task.setLeaderId(leader.getUserId());
            task.setLeader(leader.getName());
            task.setCreateTime(new Date());
            task.setName(standard.getName());
            task.setStandardNo(standard.getStandardNo());
            task.setFile(standard.getFile());
            setTaskList(request.getTaskList(),task);
            BeanUtils.copyBeanProp(task, request);

            if(request.getTaskList().contains(Task.SUB_TASK_GRFIS)) {
                // 保存车型审查问卷任务
                task.setCarReviewTaskId(saveCarReview(request,initiator,standard,leader));
            }
            if(request.getTaskList().contains(Task.SUB_TASK_SRAIF)) {
                // 保存体系审查任务
                task.setSystemReviewTaskId(saveSystemReview(request,initiator,standard,leader));
            }
            if (request.getTaskList().contains(Task.SUB_TASK_TRFIS)) {
                task.setModelTestTaskId(saveModelTest(request, initiator, standard, leader));
            }

            taskService.save(task);

            // 构建并保存该任务所关联的审核组信息
            saveUserRelation(auditors,task);

            // 保存关联的整车样品信息和零部件样品信息
            List<TaskSampleRelation> relations = request.getSample();
            List<TaskSampleRelation> partRelations = request.getPartSample();
            saveSampleRelation(relations,partRelations,task);

            // 保存任务关联的文件信息
            saveFileList(request.getFileList(),task);

            taskStateFacade.doCreate(task, request.getTaskList());

//        }
    }

    /**
     * 查询用户待办任务
     * @param request
     * @param userId
     * @return
     */
    @Override
    public List<TaskFindResponse> findPending(TaskFindPendingRequest request,Long userId) {
        List<TaskFindResponse> responses = taskMapper.findPending(request,userId);

        if (responses != null && responses.size() != 0) {
            // 小组成员
            List<UserNameResponse> userList = taskMapper.findByUserIdList(responses);
            setLeader(userList,responses);

            // 体系审查子任务列表
            List<SystemReviewTask> systemReviewTaskList = systemReviewTaskMapper.findByTaskList(responses);
            setSystemProgress(systemReviewTaskList,responses);

            // 车型问卷子任务列表
            List<CarReviewTask> carReviewTaskList = carReviewTaskMapper.findByTaskList(responses);
            setCarProgress(carReviewTaskList,responses);

            // 设置车型试验进度
            setModelSchedule(responses);

            // 显示下一任务节点
            for (TaskFindResponse response : responses) {
                String[] taskList = response.getTaskList().split(",");
                if (response.getPointer() < taskList.length) {
                    response.setNextSubTask(taskList[response.getPointer()]);
                } else {
                    response.setNextSubTask(taskList[taskList.length - 1]);
                }
            }

        }

        return responses;
    }

    /**
     * 已归档任务
     * @param request
     * @return
     */
    @Override
    public List<Task> findFinish(TaskFindFinishRequest request) {

        List<Task> taskList = taskMapper.findFinish(request);

        if (taskList != null && taskList.size() != 0) {

            List<UserNameResponse> responseList = taskMapper.findByFinishTaskList(taskList);

            setFinishLeader(responseList,taskList);
        }

        return taskList;
    }

    /**
     * 编辑任务
     * @param request
     */
    @Override
    public void editTask(TaskEditRequest request) {

        // TODO 任务名称验重
//        Task oldTask = taskMapper.findByName(request.getTaskName());
//        if (oldTask == null || Objects.equals(oldTask.getId(), request.getId())) {
            // 构建任务创建者
            LoginUser loginUser = SecurityUtils.getLoginUser();
            SysUser initiator = sysUserService.selectUserById(loginUser.getUserId());
            Standard standard = standardService.findListById(request.getStandardId());

            // 找到审查组长
            TaskUserRelation leader = null;
            List<TaskUserRelation> auditors = request.getAuditors();
            for(TaskUserRelation auditor : auditors) {
                if(auditor.getIsLeader() == 1) {
                    leader = auditor;
                    break;
                }
            }

            // 构建并保存任务信息
            // 总任务
            Task task = taskMapper.selectById(request.getId());

            // 小组组长是否发生变化
            changeSubLeader(task,leader);

            task.setLeaderId(leader.getUserId());
            task.setLeader(leader.getName());
            setTaskList(request.getTaskList(),task);
            BeanUtils.copyBeanProp(task, request);

            // 子任务发生变化
            changeSubTask(request,task,initiator,standard,leader);

            task.setMaxPointer(request.getTaskList().size());

            taskService.updateById(task);

            // 构建并保存该任务所关联的审核组信息
            saveUserRelation(auditors,task);

            // 判断第一个整车样品的生产企业是否变化
            judgmentSample(request);

            // 保存关联的整车样品信息和零部件样品信息
            List<TaskSampleRelation> relations = request.getSample();
            List<TaskSampleRelation> partRelations = request.getPartSample();
            saveSampleRelation(relations,partRelations,task);

            // 保存任务关联的文件信息
            saveFileList(request.getFileList(),task);
//        } else {
//            throw new ServiceException("任务名称重复，请检查", HttpStatus.ERROR);
//        }


    }

    /**
     * 删除任务
     * @param request
     */
    @Override
    public void deleteTask(TaskDeleteRequest request) {
        Task task = taskMapper.selectById(request.getId());

        systemReviewTaskMapper.deleteById(task.getSystemReviewTaskId());
        carReviewTaskMapper.deleteById(task.getCarReviewTaskId());
        modelTestTaskMapper.deleteById(task.getModelTestTaskId());

        // 小组
        List<TaskUserRelation> list = taskUserRelationService.selectQTeamMembers(task.getId());
        if (list != null && list.size() != 0) {
            taskFileRelationService.removeBatchByIds(list);
        }

        // 样品
        List<TaskSampleRelation> relationList = taskSampleRelationService.selectByTaskId(task.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE);
        if (relationList != null && relationList.size() != 0) {
            taskSampleRelationService.removeBatchByIds(relationList);
        }
        List<TaskSampleRelation> partRelationList = taskSampleRelationService.selectByTaskId(task.getId(),TaskSampleRelation.PART_VEHICLE_SAMPLE);
        if (partRelationList != null && partRelationList.size() != 0) {
            taskSampleRelationService.removeBatchByIds(partRelationList);
        }

        // 文件
        List<TaskFileRelation> fileList = taskFileRelationService.findByTaskId(task.getId());
        if (fileList != null && fileList.size() != 0) {
            taskFileRelationService.removeBatchByIds(fileList);
        }

        taskMapper.deleteById(request.getId());
    }

    /**
     * 开始任务
     * @param request
     */
    @Override
    public void startTask(TaskStartRequest request) {
        Task task = taskMapper.selectById(request.getId());
        taskStateFacade.doStart(task, request);
    }

    /**
     * 用户创建的任务
     * @param request
     * @param userId
     * @return
     */
    @Override
    public List<TaskFindResponse> findCreate(TaskFindRequest request,Long userId) {
        List<TaskFindResponse> responses = taskMapper.findByUserId(request,userId);

        if (responses != null && responses.size() != 0) {
            // 小组成员
            List<UserNameResponse> userList = taskMapper.findByUserIdList(responses);
            setLeader(userList,responses);

            // 体系审查子任务列表
            List<SystemReviewTask> systemReviewTaskList = systemReviewTaskMapper.findByTaskList(responses);
            setSystemProgress(systemReviewTaskList,responses);

            // 车型问卷子任务列表
            List<CarReviewTask> carReviewTaskList = carReviewTaskMapper.findByTaskList(responses);
            setCarProgress(carReviewTaskList,responses);

            // 设置车型试验进度
            setModelSchedule(responses);

            // 显示下一任务节点
            for (TaskFindResponse response : responses) {
                String[] taskList = response.getTaskList().split(",");
                if (response.getPointer() < taskList.length) {
                    response.setNextSubTask(taskList[response.getPointer()]);
                } else {
                    response.setNextSubTask(taskList[taskList.length - 1]);
                }
            }
        }

        return responses;
    }

    /**
     * 获取任务详情
     * @param request
     * @return
     */
    @Override
    public TaskGetInfoResponse getInfo(TaskGetInfoRequest request) {

        TaskGetInfoResponse response = new TaskGetInfoResponse();
        Task task = taskService.getById(request.getId());

        if (task != null) {
            BeanUtils.copyBeanProp(response, task);

            if (response.getTaskList().startsWith(",")) {
                String taskList = response.getTaskList().substring(1);
                response.setTaskList(taskList);
            }

            // 小组成员
            response.setAuditors(setAuditors(request.getId()));

            // 整车样品信息
            response.setCompleteVehicleSample(setSampleList(request.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE));

            // 零部件样品信息
            response.setPartVehicleSample(setSampleList(request.getId(),TaskSampleRelation.PART_VEHICLE_SAMPLE));

            // 上传的文件
            response.setFileList(taskFileRelationService.findByTaskId(request.getId()));

            return response;
        } else {
            return null;
        }

    }

    /**
     * 查询测试列表
     * @param task
     * @return
     */
    private List<Long> selectTestScenarioList(Task task) {
        List<Long> list = new ArrayList<>();
        List<String> taskList = Arrays.asList(task.getTaskList().split(","));
        if (taskList.contains(Task.SUB_TASK_TRFIS) && taskList.size() == 1
        || taskList.contains(Task.SUB_TASK_TRFIS) && taskList.contains(Task.SUB_TASK_SRAIF) && taskList.size() == 2) {
            list = taskScenarioRelationMapper
                    .selectList(new QueryWrapper<TaskScenarioRelation>().eq("task_id", task.getId()))
                    .stream()
                    .map(TaskScenarioRelation::getTestScenarioId)
                    .collect(Collectors.toList());
        }
        return list;
    }

    /**
     * 已办任务
     * @param request
     * @param userId
     * @return
     */
    @Override
    public List<Task> findUserFinish(TaskFindFinishRequest request,Long userId) {

        List<Task> taskList = taskMapper.findUserFinish(request,userId);

        if (taskList != null && taskList.size() != 0) {

            List<UserNameResponse> responseList = taskMapper.findByFinishTaskList(taskList);

            setFinishLeader(responseList,taskList);
        }

        return taskList;
    }

    /**
     * 新增暂存任务
     * @param request
     */
    @Override
    public void temporaryStorageTask(TaskCreateRequest request) {

        // TODO 任务名称验重
//        Long sum = taskMapper.findTaskName(request.getTaskName());
//        if (sum > 0) {
//            throw new ServiceException("任务名称重复，请检查", HttpStatus.ERROR);
//        } else {
            // 构建任务创建者
            LoginUser loginUser = SecurityUtils.getLoginUser();
            TaskGetInfoResponse temporaryStorageTask = taskService.getByUserId(loginUser.getUserId());
            if (temporaryStorageTask != null) {
                TaskEditRequest editRequest = new TaskEditRequest();
                BeanUtils.copyBeanProp(editRequest,request);
                editRequest.setId(temporaryStorageTask.getId());
                taskService.editTemporaryStorageTask(editRequest);
            } else {
                SysUser initiator = sysUserService.selectUserById(loginUser.getUserId());
                Standard standard = standardService.findListById(request.getStandardId());

                // 构建并保存任务信息
                // 总任务
                Task task = new Task();
                task.setTaskInitiatorId(loginUser.getUserId());
                task.setTaskInitiator(initiator.getNickName());
                if (initiator.getDept() != null) {
                    task.setTaskInitiatorDept(initiator.getDept().getDeptName());
                }
                task.setTaskStatus(Task.TASK_STATUS_TEMPORARILY);
                String joinTaskList = StringUtils.join(request.getTaskList(),",");
                if (StrUtil.isNotEmpty(joinTaskList)) {
                    task.setTaskList(joinTaskList);
                }
                BeanUtils.copyBeanProp(task, request);

                if (standard != null) {
                    task.setName(standard.getName());
                    task.setStandardNo(standard.getStandardNo());
                    task.setFile(standard.getFile());
                }

                // 找到审查组长
                TaskUserRelation leader = null;
                List<TaskUserRelation> auditors = request.getAuditors();
                if (auditors != null && auditors.size() != 0) {
                    for(TaskUserRelation auditor : auditors) {
                        if(auditor.getIsLeader() == 1) {
                            leader = auditor;
                            break;
                        }
                    }

                    // 任务组长
                    task.setLeaderId(leader.getUserId());
                    task.setLeader(leader.getName());
                }

                // 暂存
                taskService.save(task);

                // 保存任务与小组信息
                saveUserRelation(auditors,task);

                // 保存关联的整车样品信息和零部件样品信息
                List<TaskSampleRelation> relations = request.getSample();
                List<TaskSampleRelation> partRelations = request.getPartSample();
                saveSampleRelation(relations,partRelations,task);

                // 保存任务关联的文件信息
                saveFileList(request.getFileList(),task);
            }

//        }

    }

    /**
     * 编辑暂存
     * @param request
     */
    @Override
    public void editTemporaryStorageTask(TaskEditRequest request) {

        // TODO 任务名称验重
//        Task oldTask = taskMapper.findByName(request.getTaskName());
//        if (oldTask == null || Objects.equals(oldTask.getId(), request.getId())) {
            // 构建任务创建者
            LoginUser loginUser = SecurityUtils.getLoginUser();
            SysUser initiator = sysUserService.selectUserById(loginUser.getUserId());
            Standard standard = standardService.findListById(request.getStandardId());

            // 构建并保存任务信息
            // 总任务
            Task task = new Task();
            String joinTaskList = StringUtils.join(request.getTaskList(),",");
            if (StrUtil.isNotEmpty(joinTaskList)) {
                task.setTaskList(joinTaskList);
            }
            BeanUtils.copyBeanProp(task, request);

            if (standard != null) {
                task.setName(standard.getName());
                task.setStandardNo(standard.getStandardNo());
                task.setFile(standard.getFile());
            }

            // 找到审查组长
            TaskUserRelation leader = null;
            List<TaskUserRelation> auditors = request.getAuditors();
            if (auditors != null && auditors.size() != 0) {
                for(TaskUserRelation auditor : auditors) {
                    if(auditor.getIsLeader() == 1) {
                        leader = auditor;
                        break;
                    }
                }
                // 任务组长
                task.setLeaderId(leader.getUserId());
                task.setLeader(leader.getName());
            }

            // 更新暂存
            taskService.updateById(task);

            // 保存任务与小组信息
            saveUserRelation(auditors,task);


            // 保存关联的整车样品信息
            List<TaskSampleRelation> relations = request.getSample();
            List<TaskSampleRelation> partRelations = request.getPartSample();
            saveSampleRelation(relations,partRelations,task);

            // 保存任务关联的文件信息
            saveFileList(request.getFileList(),task);
//        } else {
//            throw new ServiceException("任务名称重复，请检查", HttpStatus.ERROR);
//        }

    }

    /**
     * 获取用户暂存任务
     * @param userId
     * @return
     */
    @Override
    public TaskGetInfoResponse getByUserId(Long userId) {

        TaskGetInfoResponse response = new TaskGetInfoResponse();
        Task task = taskMapper.getByUserIdTemporary(userId);

        if (task != null && task.getId() != null) {

            BeanUtils.copyBeanProp(response, task);

//            if (response.getTaskList().startsWith(",")) {
//                String taskList = response.getTaskList().substring(1);
//                response.setTaskList(taskList);
//            }

            // 小组成员
            response.setAuditors(setAuditors(task.getId()));

            // 整车样品信息
            response.setCompleteVehicleSample(setSampleList(task.getId(), TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE));

            // 零部件样品信息
            response.setPartVehicleSample(setSampleList(task.getId(), TaskSampleRelation.PART_VEHICLE_SAMPLE));

            // 上传的文件
            response.setFileList(taskFileRelationService.findByTaskId(task.getId()));

            return response;
        } else {
            return null;
        }


    }

    /**
     * 根据子任务获取总任务详情
     * @param request
     * @return
     */
    @Override
    public TaskGetInfoResponse getBySubtaskId(TaskSubGetInfoRequest request) {
        TaskGetInfoResponse response = new TaskGetInfoResponse();
        Task task = taskMapper.getBySubtaskId(request.getId());

        if (task != null) {
            BeanUtils.copyBeanProp(response, task);
            // 小组成员
            response.setAuditors(setAuditors(task.getId()));

            // 整车样品信息
            response.setCompleteVehicleSample(setSampleList(task.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE));

            // 零部件样品信息
            response.setPartVehicleSample(setSampleList(task.getId(),TaskSampleRelation.PART_VEHICLE_SAMPLE));

            return response;
        } else {
            return null;
        }

    }

    /**
     * 数据统计
     * @param request
     * @return
     */
    @Override
    public DataStatisticsResponse dataStatistics(TaskGetInfoRequest request) {

        Task task = taskMapper.selectById(request.getId());
        DataStatisticsResponse response = new DataStatisticsResponse();

        if (task.getSystemReviewTaskId() != null) {

            response.setSystemExist(true);

            systemReviewTaskService.view(task.getSystemReviewTaskId());

            SystemReviewTask systemReviewTask = systemReviewTaskMapper.selectById(task.getSystemReviewTaskId());
            // 获取最新问卷
            List<ReviewStandard> standardTree = reviewStandardService.findTree(systemReviewTask.getStandardId(), ReviewStandard.TYPE_SYSTEM);

            // 获取当前问卷答案
            List<ReviewDetailsResult> results = reviewDetailsResultService.findByTaskId(systemReviewTask.getId());

            // 体系审查
            setSystemDataStatistics(standardTree,results,response,systemReviewTask);

        } else {
            response.setSystemExist(false);
        }

        if (task.getCarReviewTaskId() != null) {

            response.setCarExist(true);

            carReviewTaskService.viewReviewTask(task.getCarReviewTaskId());

            CarReviewTask carReviewTask = carReviewTaskMapper.selectById(task.getCarReviewTaskId());

            // 获取最新问卷
            List<ReviewStandard> carStandardTree = reviewStandardService.findTree(carReviewTask.getStandardId(), ReviewStandard.TYPE_CAR);

            // 获取当前问卷答案
            List<ReviewDetailsResult> carResults = reviewDetailsResultService.findByTaskId(carReviewTask.getId());

            // 车型审查
            setCarDataStatistics(carStandardTree,carResults,response,carReviewTask);

        } else {
            response.setCarExist(false);
        }

        return response;

    }


    private void changeSubLeader(Task task, TaskUserRelation leader) {
        if (!Objects.equals(task.getLeaderId(), leader.getUserId())) {
            if (task.getSystemReviewTaskId() != null) {
                SystemReviewTask systemReviewTask = systemReviewTaskMapper.selectById(task.getSystemReviewTaskId());
                systemReviewTask.setLeaderId(leader.getUserId());
                systemReviewTask.setLeader(leader.getName());
                systemReviewTaskMapper.updateById(systemReviewTask);
            }
            if (task.getCarReviewTaskId() != null) {
                CarReviewTask carReviewTask = carReviewTaskMapper.selectById(task.getCarReviewTaskId());
                carReviewTask.setLeaderId(leader.getUserId());
                carReviewTask.setLeader(leader.getName());
                carReviewTaskMapper.updateById(carReviewTask);
            }
            if (task.getModelTestTaskId() != null) {
                ModelTestTask modelTestTask = modelTestTaskMapper.selectById(task.getModelTestTaskId());
                modelTestTask.setLeaderId(leader.getUserId());
                modelTestTask.setLeader(leader.getName());
                modelTestTaskMapper.updateById(modelTestTask);
            }
        }
    }

    private void setFinishLeader(List<UserNameResponse> responseList, List<Task> taskList) {

        if (responseList != null && responseList.size() != 0) {
            for (UserNameResponse response : responseList) {
                for (Task task : taskList) {
                    if (Objects.equals(response.getUserId(), task.getLeaderId())) {
                        task.setLeader(response.getName());
                    }
                }
            }
        }
    }

    private void setLeader(List<UserNameResponse> userList, List<TaskFindResponse> responses) {

        if (userList != null && userList.size() != 0) {
            for (UserNameResponse response : userList) {
                for (TaskFindResponse findResponse : responses) {
                    if (Objects.equals(findResponse.getLeaderId(), response.getUserId())) {
                        findResponse.setLeader(response.getName());
                    }
                }
            }
        }

    }

    private void setTaskScenario(List<TaskScenarioResponse> scenarioResponseList, List<TaskFindResponse> responses) {

        if (scenarioResponseList != null && scenarioResponseList.size() != 0) {
            for (TaskScenarioResponse response : scenarioResponseList) {
                for (TaskFindResponse findResponse : responses) {
                    if (Objects.equals(findResponse.getId(), response.getTaskId())) {
                        if (response.getNum() > 0) {
                            findResponse.setTaskScenario(true);
                        }
                    }
                }
            }
        }
    }

    private void setModelSchedule(List<TaskFindResponse> responses) {

        if (responses != null && responses.size() != 0) {

            for (TaskFindResponse response : responses) {
                if (response.getTestSchemeId() != null) {
                    // 获取任务的用例数量
                    Map<String, Object> map = new HashMap<>();
                    map.put("id", response.getTestSchemeId());
                    map.put("verbose", "BASIC");

                    //以post形式请求接口
                    String result= HttpUtil.post("https://10.12.48.78:8090/DescribeProjectTestResult", JSONObject.toJSONString(map));

                    JSONObject jsonObject = JSONObject.parseObject(result);

                    // 获取项目id
                    Integer useCaseNum = (Integer) jsonObject.get("case_count");

                    // 获取已忽略用例数
                    List<CaseStatisticsVO> statisticsVOList = jsonObject.getList("case_statistics",CaseStatisticsVO.class);

                    Integer ignoredNum = 0;

                    for (CaseStatisticsVO vo : statisticsVOList) {
                        if (Objects.equals(vo.getStatus(), "IGNORED")) {
                            ignoredNum = vo.getCount();
                            break;
                        }
                    }

                    // 任务是否有选择用例
                    response.setTaskScenario(useCaseNum > 0);

                    // 任务用例结果数量
                    Long resultNum = testRecordsMapper.countResult(response.getTestSchemeId());

                    if (Objects.equals(response.getTestStatus(), ModelTestTask.TASK_STATUS_FINISH)) {
                        response.setTest(100.0);
                    } else if (Objects.equals(response.getTestStatus(), ModelTestTask.TASK_STATUS_SIGNED)) {
                        response.setTest(90.0);
                    } else if(resultNum == null) {
                        response.setTest(0.0);
                    } else {
                        BigDecimal num = new BigDecimal((1.0 * resultNum / (useCaseNum - ignoredNum)) * 90);
                        response.setTest(num.setScale(1,BigDecimal.ROUND_UP).doubleValue());
                    }

                } else {
                    // 任务是否有选择用例
                    response.setTaskScenario(false);
                }
            }

        }
    }

    private void setModelProgress(List<ModelTestTask> modelTestTaskList, List<TaskFindResponse> responses) {

        if (modelTestTaskList != null && modelTestTaskList.size() != 0) {
            // 子任务进度列表
            List<ResultCountResponse> testResponseList = modelTestTaskMapper.testAnswerCount(responses);

            if (testResponseList != null && testResponseList.size() != 0) {
                // 设置子任务不为finish时，最大进度为90 进度为null时，改为0
                for (ResultCountResponse response : testResponseList) {
                    if (Objects.equals(response.getTaskStatus(), ModelTestTask.TASK_STATUS_FINISH)) {
                        response.setSchedule(100.0);
                    } else if (Objects.equals(response.getTaskStatus(), ModelTestTask.TASK_STATUS_SIGNED)) {
                        response.setSchedule(90.0);
                    } else if (response.getSchedule() == null) {
                        response.setSchedule(0.0);
                    } else {
                        BigDecimal num = new BigDecimal(response.getSchedule());
                        response.setSchedule(num.setScale(1,BigDecimal.ROUND_UP).doubleValue());
                    }
                }

                for (ResultCountResponse responseList : testResponseList) {
                    for (TaskFindResponse response : responses) {
                        if (responseList.getTaskId().equals(response.getModelTestTaskId())) {
                            response.setTest(responseList.getSchedule());
                        }
                    }
                }
            }

        }

    }

    private void setCarProgress(List<CarReviewTask> carReviewTaskList, List<TaskFindResponse> responses) {

        if (carReviewTaskList != null && carReviewTaskList.size() != 0) {
            // 子任务列表进度
            List<ResultCountResponse> carResponseList = reviewDetailsMapper.carAnswerCount(carReviewTaskList,CarReviewTask.TYPE);

            if (carResponseList != null && carResponseList.size() != 0) {
                // 设置子任务不为finish时，最大进度为90
                for (ResultCountResponse response : carResponseList) {
                    if (Objects.equals(response.getTaskStatus(), CarReviewTask.TASK_STATUS_FINISH)) {
                        response.setSchedule(100.0);
                    } else {
                        BigDecimal num = new BigDecimal(response.getSchedule());
                        response.setSchedule(num.setScale(1,BigDecimal.ROUND_UP).doubleValue());
                    }
                }

                for (ResultCountResponse responseList : carResponseList) {
                    for (TaskFindResponse response : responses) {
                        if (responseList.getTaskId().equals(response.getCarReviewTaskId())) {
                            response.setCarReview(responseList.getSchedule());
                        }
                    }
                }
            }
        }
    }

    private void setSystemProgress(List<SystemReviewTask> systemReviewTaskList,List<TaskFindResponse> responses) {

        if (systemReviewTaskList != null && systemReviewTaskList.size() != 0) {
            // 子任务列表进度
            List<ResultCountResponse> responseLists = reviewDetailsMapper.systemAnswerCount(systemReviewTaskList,SystemReviewTask.TYPE);

            if (responseLists != null && responseLists.size() != 0) {

                // 设置子任务不为finish时，最大进度为90
                for (ResultCountResponse response : responseLists) {
                    if (Objects.equals(response.getTaskStatus(), SystemReviewTask.STATUS_FINISH)) {
                        response.setSchedule(100.0);
                    } else {
                        BigDecimal num = new BigDecimal(response.getSchedule());
                        response.setSchedule(num.setScale(1,BigDecimal.ROUND_UP).doubleValue());
                    }
                }

                for (ResultCountResponse responseList : responseLists) {
                    for (TaskFindResponse response : responses) {
                        if (responseList.getTaskId().equals(response.getSystemReviewTaskId())) {
                            response.setSystemReview(responseList.getSchedule());
                        }
                    }
                }
            }
        }
    }

    // 按顺序设置taskList
    private void setTaskList(List<String> taskList, Task task) {
        // 定义一个比较器，按照 "sraif, grfis, trfis" 的顺序排序
        Comparator<String> customComparator = Comparator.comparingInt(str -> {
            if (str.equals(Task.SUB_TASK_SRAIF)) return 0;
            else if (str.equals(Task.SUB_TASK_GRFIS)) return 1;
            else if (str.equals(Task.SUB_TASK_TRFIS)) return 2;
            else return -1; // 处理其他情况
        });

        // 使用自定义的比较器进行排序
        List<String> sortedTaskList = taskList.stream()
                .sorted(customComparator)
                .collect(Collectors.toList());

        // 将排序后的结果用逗号连接起来存入一个字段中
        String concatenatedTasks = String.join(",", sortedTaskList);

        task.setTaskList(concatenatedTasks);
    }

    // 保存任务与小组信息
    private void saveUserRelation(List<TaskUserRelation> auditors,Task task) {
        // 构建并保存该任务所关联的审核组信息
        List<TaskUserRelation> list = taskUserRelationService.selectQTeamMembers(task.getId());
        if (list != null && list.size() != 0) {
            taskUserRelationService.removeBatchByIds(list);
        }

        if (auditors != null && auditors.size() != 0) {
            // 构建并保存该任务所关联的审核组信息
            for(TaskUserRelation auditor : auditors) {
                auditor.setTaskId(task.getId());
            }

            taskUserRelationService.saveBatch(auditors);
        }
    }

    private void saveFileList(List<TaskFileRelation> fileList,Task task) {

        List<TaskFileRelation> list = taskFileRelationService.findByTaskId(task.getId());

        if (list != null&& list.size() != 0) {
            taskFileRelationService.removeBatchByIds(list);
        }

        if (fileList != null && fileList.size() != 0 ) {
            for (TaskFileRelation relation : fileList) {
                relation.setTaskId(task.getId());
            }

            taskFileRelationService.saveBatch(fileList);
        }

    }

    // 保存任务与样品信息
    private void saveSampleRelation(List<TaskSampleRelation> relations,List<TaskSampleRelation> partRelations,Task task) {
        // 整车
        List<TaskSampleRelation> relationList = taskSampleRelationService.selectByTaskId(task.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE);
        if (relationList != null && relationList.size() != 0) {
            taskSampleRelationService.removeBatchByIds(relationList);
        }

        if (relations != null && relations.size() != 0) {
            for (TaskSampleRelation sampleRelation : relations) {
                sampleRelation.setTaskId(task.getId());
            }

            taskSampleRelationService.saveBatch(relations);
        }

        // 零件
        List<TaskSampleRelation> partRelationList = taskSampleRelationService.selectByTaskId(task.getId(),TaskSampleRelation.PART_VEHICLE_SAMPLE);
        if (partRelationList != null && partRelationList.size() != 0) {
            taskSampleRelationService.removeBatchByIds(partRelationList);
        }

        if (partRelations != null && partRelations.size() != 0) {
            for (TaskSampleRelation sampleRelation : partRelations) {
                sampleRelation.setTaskId(task.getId());
            }

            taskSampleRelationService.saveBatch(partRelations);
        }

    }

    // 判断编辑任务时，第一整车样品的生成企业有无变化
    private void judgmentSample(TaskEditRequest request) {
        // 获取传入的样品列表
        List<TaskSampleRelation> relations = request.getSample();

        // 任务与整车样品关系
        List<TaskSampleRelation> sampleRelations = taskSampleRelationMapper.selectByTaskId(request.getId(),TaskSampleRelation.COMPLETE_VEHICLE_SAMPLE);

        if (sampleRelations != null && sampleRelations.size() != 0) {
            // 获取之前的第一个企业名称
            TaskSampleRelation taskSampleRelation = sampleRelations.get(0);
            Sample oldSample = sampleManagementMapper.selectSampleManagementById(taskSampleRelation.getSampleId());
            AutomobileEnterprise oldAutomobileEnterprise = automobileEnterpriseMapper.selectAutomobileEnterpriseById(oldSample.getManufacturingEnterpriseId());

            // 获取编辑任务后的第一个企业名称
            TaskSampleRelation newTaskSampleRelation = relations.get(0);
            Sample newSample = sampleManagementMapper.selectSampleManagementById(newTaskSampleRelation.getSampleId());
            AutomobileEnterprise newAutomobileEnterprise = automobileEnterpriseMapper.selectAutomobileEnterpriseById(newSample.getManufacturingEnterpriseId());

            // 第一个企业名称不相同则修改
            if (!Objects.equals(oldAutomobileEnterprise.getEnterpriseName(), newAutomobileEnterprise.getEnterpriseName())){
                // 留档文件
                List<ReviewEnterpriseArchive> reviewEnterpriseArchiveList = reviewEnterpriseArchiveMapper.findList(request.getId());

                if (reviewEnterpriseArchiveList != null && reviewEnterpriseArchiveList.size() != 0) {
                    for (ReviewEnterpriseArchive reviewEnterpriseArchive : reviewEnterpriseArchiveList) {
                        reviewEnterpriseArchive.setEnterpriseName(newAutomobileEnterprise.getEnterpriseName());
                    }

                    reviewEnterpriseArchiveService.updateBatchById(reviewEnterpriseArchiveList);
                }

            }
        }
    }

    // 编辑任务时子任务发送变化
    private void changeSubTask(TaskEditRequest request,Task task,SysUser initiator,Standard standard,TaskUserRelation leader) {
        if (Objects.equals(task.getTaskStatus(), Task.TASK_STATUS_NEW)) {
            if(request.getTaskList().contains(Task.SUB_TASK_GRFIS) && task.getCarReviewTaskId() == null) {
                // 保存车型审查问卷任务
                TaskCreateRequest createRequest = new TaskCreateRequest();
                BeanUtils.copyBeanProp(createRequest, request);
                task.setCarReviewTaskId(saveCarReview(createRequest,initiator,standard,leader));
            }
            if ( !request.getTaskList().contains(Task.SUB_TASK_GRFIS) && task.getCarReviewTaskId() != null) {
                carReviewTaskMapper.deleteById(task.getCarReviewTaskId());
                task.setCarReviewTaskIdNull();
            }
            if(request.getTaskList().contains(Task.SUB_TASK_SRAIF) && task.getSystemReviewTaskId() == null) {
                // 保存体系审查任务
                TaskCreateRequest createRequest = new TaskCreateRequest();
                BeanUtils.copyBeanProp(createRequest, request);
                task.setSystemReviewTaskId(saveSystemReview(createRequest,initiator,standard,leader));
            }
            if ( !request.getTaskList().contains(Task.SUB_TASK_SRAIF) && task.getSystemReviewTaskId() != null) {
                systemReviewTaskMapper.deleteById(task.getSystemReviewTaskId());
                task.setSystemReviewTaskIdNull();
            }
            // 判断车型试验
            if (request.getTaskList().contains(Task.SUB_TASK_TRFIS) && ObjectUtil.isNull(task.getModelTestTaskId())) {
                // 新增
                TaskCreateRequest createRequest = new TaskCreateRequest();
                BeanUtils.copyBeanProp(createRequest, request);
                task.setModelTestTaskId(saveModelTest(createRequest,initiator,standard,leader));
                // 任务-场景
//                saveTaskScenario(task.getId(), createRequest.getTestScenarioList());
            }
            if (!request.getTaskList().contains(Task.SUB_TASK_TRFIS) && ObjectUtil.isNotNull(task.getModelTestTaskId())) {
                // 删除
                modelTestTaskService.removeById(task.getModelTestTaskId());
                task.setModelTestTaskIdNull();
                // 删除 任务-场景
//                taskScenarioRelationMapper.delete(new QueryWrapper<TaskScenarioRelation>().lambda().eq(TaskScenarioRelation::getTaskId, task.getId()));
            }
            if (request.getTaskList().contains(Task.SUB_TASK_TRFIS) &&
                !request.getTaskList().contains(Task.SUB_TASK_GRFIS) &&
                !request.getTaskList().contains(Task.SUB_TASK_SRAIF) &&
                ObjectUtil.isNotNull(task.getModelTestTaskId())
                || request.getTaskList().contains(Task.SUB_TASK_TRFIS) &&
                   !request.getTaskList().contains(Task.SUB_TASK_GRFIS) &&
                   request.getTaskList().contains(Task.SUB_TASK_SRAIF) &&
                   ObjectUtil.isNotNull(task.getModelTestTaskId())
            ) {
                TaskCreateRequest createRequest = new TaskCreateRequest();
                BeanUtils.copyBeanProp(createRequest, request);
//                taskScenarioRelationMapper.delete(new QueryWrapper<TaskScenarioRelation>().lambda().eq(TaskScenarioRelation::getTaskId, task.getId()));
//                saveTaskScenario(task.getId(), createRequest.getTestScenarioList());
            }
        }
    }


    private void setSystemDataStatistics(List<ReviewStandard> standards, List<ReviewDetailsResult> results,DataStatisticsResponse response,SystemReviewTask systemReviewTask) {
        Map<Long, ReviewDetailsResult> resultMap = results.stream().collect(Collectors.toMap(ReviewDetailsResult::getReviewDetailsId, Function.identity(), (v1, v2) -> v1));

        if (Objects.equals(systemReviewTask.getTaskStatus(), SystemReviewTask.STATUS_NEW)) {
            response.setSystemStandards(DataStatisticsUtils.calculateStandards(standards));
            response.setSystemDetails(DataStatisticsUtils.calculateDetails(standards));
        } else {
            response.setSystemStandards(systemReviewTask.getStandards());
            response.setSystemDetails(systemReviewTask.getDetails());
        }

        response.setSystemStandardsPassNum(DataStatisticsUtils.calculateStandardsPass(standards, resultMap));
        response.setSystemStandardsNoPassNum(DataStatisticsUtils.calculateStandardsNoPass(standards, resultMap));
        response.setSystemStandardsUnderNum(response.getSystemStandards() -response.getSystemStandardsPassNum() - response.getSystemStandardsNoPassNum());
        BigDecimal standardPass = new BigDecimal((response.getSystemStandardsPassNum() / (double) response.getSystemStandards())*100);
        response.setSystemStandardsPass(standardPass.setScale(1,BigDecimal.ROUND_UP).doubleValue());
        response.setSystemDetailsPassNum(DataStatisticsUtils.calculateDetailsPass(standards, resultMap));
        response.setSystemDetailsNoPassNum(DataStatisticsUtils.calculateDetailsNoPass(standards, resultMap));
        response.setSystemDetailsUnderNum(response.getSystemDetails() - response.getSystemDetailsPassNum() - response.getSystemDetailsNoPassNum());
        BigDecimal detailsPass = new BigDecimal((response.getSystemDetailsPassNum() / (double) response.getSystemDetails())*100);
        response.setSystemDetailsPass(detailsPass.setScale(1,BigDecimal.ROUND_UP).doubleValue());

    }

    private void setCarDataStatistics(List<ReviewStandard> standards, List<ReviewDetailsResult> results,DataStatisticsResponse response,CarReviewTask carReviewTask) {
        Map<Long, ReviewDetailsResult> resultMap = results.stream().collect(Collectors.toMap(ReviewDetailsResult::getReviewDetailsId, Function.identity(), (v1, v2) -> v1));

        if (Objects.equals(carReviewTask.getTaskStatus(), CarReviewTask.TASK_STATUS_NEW)) {
            response.setCarStandards(DataStatisticsUtils.calculateStandards(standards));
            response.setCarDetails(DataStatisticsUtils.calculateDetails(standards));
        } else {
            response.setCarStandards(carReviewTask.getStandards());
            response.setCarDetails(carReviewTask.getDetails());
        }
        response.setCarStandardsPassNum(DataStatisticsUtils.calculateStandardsPass(standards, resultMap));
        response.setCarStandardsNoPassNum(DataStatisticsUtils.calculateStandardsNoPass(standards, resultMap));
        response.setCarStandardsUnderNum(response.getCarStandards() -response.getCarStandardsPassNum() - response.getCarStandardsNoPassNum());
        BigDecimal standardPass = new BigDecimal((response.getCarStandardsPassNum() / (double) response.getCarStandards())*100);
        response.setCarStandardsPass(standardPass.setScale(1,BigDecimal.ROUND_UP).doubleValue());
        response.setCarDetailsPassNum(DataStatisticsUtils.calculateDetailsPass(standards, resultMap));
        response.setCarDetailsNoPassNum(DataStatisticsUtils.calculateDetailsNoPass(standards, resultMap));
        response.setCarDetailsUnderNum(response.getCarDetails() - response.getCarDetailsPassNum() - response.getCarDetailsNoPassNum());
        BigDecimal detailsPass = new BigDecimal((response.getCarDetailsPassNum() / (double) response.getCarDetails())*100);
        response.setCarDetailsPass(detailsPass.setScale(1,BigDecimal.ROUND_UP).doubleValue());

    }

    public List<TaskUserRelation> setAuditors ( Long id) {

        // 小组成员
        List<TaskUserRelation> relation = taskUserRelationService.selectQTeamMembers(id);

        if(relation != null && relation.size() != 0) {

            // 小组成员姓名、部门
            List<UserNameResponse> userList = taskMapper.findByRelation(relation);

            for (UserNameResponse response : userList) {
                for (TaskUserRelation taskUserRelation : relation) {
                    if (Objects.equals(response.getUserId(), taskUserRelation.getUserId())) {
                        taskUserRelation.setName(response.getName());
                        taskUserRelation.setDeptName(response.getDeptName());
                    }
                }
            }

            // 小组成员状态
            List<TaskUserRelation> relationList = taskUserRelationMapper.findByIdList(relation);

            for ( TaskUserRelation userRelation : relationList) {
                for (TaskUserRelation taskUserRelation : relation) {
                    if (Objects.equals(userRelation.getUserId(), taskUserRelation.getUserId())) {
                        taskUserRelation.setStatus(userRelation.getStatus());
                    }
                }
            }
        }

        return relation;
    }

    public List<Sample> setSampleList(Long id,String type) {
        // 样品信息
        List<TaskSampleRelation> relationList = taskSampleRelationService.selectByTaskId(id,type);
        if (relationList != null && relationList.size() != 0) {
            List<Sample> SampleList = sampleManagementMapper.findByIdList(relationList,id);
            return SampleList;
        } else {
            return null;
        }


    }

    public Long saveSystemReview(TaskCreateRequest request,SysUser initiator,Standard standard,TaskUserRelation leader) {

        // 构建并保存任务信息
        SystemReviewTask task = new SystemReviewTask()
                .setTaskNo(request.getTaskNo())
                .setTaskInitiator(initiator.getNickName())
                .setTaskStatus(SystemReviewTask.STATUS_NEW)
                .setLeaderId(leader.getUserId())
                .setLeader(leader.getName())
                .setCreateTime(new Date())
                .setStandardId(standard.getId())
                .setName(standard.getName())
                .setStandardNo(standard.getStandardNo())
                .setFile(standard.getFile());

        if (initiator.getDept() != null) {
            task.setTaskInitiatorDept(initiator.getDept().getDeptName());
        }

        systemReviewTaskService.save(task);
        return task.getId();
    }

    public Long saveCarReview(TaskCreateRequest request,SysUser initiator,Standard standard,TaskUserRelation leader) {

        List<String> taskList = request.getTaskList();

        // 构建并保存任务信息
        CarReviewTask task = new CarReviewTask()
                .setTaskNo(request.getTaskNo())
                .setTaskInitiator(initiator.getNickName())
                .setTaskStatus(CarReviewTask.TASK_STATUS_NEW)
                .setLeaderId(leader.getUserId())
                .setLeader(leader.getName())
                .setCreateTime(new Date())
                .setStandardId(standard.getId())
                .setName(standard.getName())
                .setStandardNo(standard.getStandardNo())
                .setFile(standard.getFile());

        if (initiator.getDept() != null) {
            task.setTaskInitiatorDept(initiator.getDept().getDeptName());
        }

        carReviewTaskService.save(task);
        return task.getId();
    }

    /**
     * 保存车型试验任务
     * @param request
     * @param initiator
     * @param standard
     * @param leader
     * @return
     */
    public Long saveModelTest(TaskCreateRequest request,SysUser initiator,Standard standard,TaskUserRelation leader) {

        // 构建并保存任务信息
        ModelTestTask modelTestTask = ModelTestTask.builder()
                .taskNo(request.getTaskNo())
                .taskInitiator(initiator.getNickName())
                .taskStatus(ModelTestTask.TASK_STATUS_NEW)
                .leaderId(leader.getUserId())
                .leader(leader.getName())
                .createTime(DateUtils.getNowDate())
                .standardId(standard.getId())
                .name(standard.getName())
                .standardNo(standard.getStandardNo())
                .build();

        if (initiator.getDept() != null) {
            modelTestTask.setTaskInitiatorDept(initiator.getDept().getDeptName());
        }

        modelTestTaskService.save(modelTestTask);
        return modelTestTask.getId();
    }

    /**
     * 保存任务-测试场景中间表数据
     * @param taskId 总任务ID
     * @param testScenarioList 测试场景集合
     */
    private void saveTaskScenario(Long taskId, List<Long> testScenarioList) {
        if (CollUtil.isNotEmpty(testScenarioList)) {
            for (Long sceneId : testScenarioList) {
                TaskScenarioRelation taskScenario = TaskScenarioRelation.builder()
                        .taskId(taskId)
                        .testScenarioId(sceneId)
                        .build();
                taskScenarioRelationMapper.insert(taskScenario);
            }
        }
    }

}