package com.xiaopeng.maintenance.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.feignClient.account.XpOperationUserClient;
import com.xiaopeng.api.feignClient.vehicleConvoy.XpVehicleClient;
import com.xiaopeng.api.model.account.XpOperationsUser;
import com.xiaopeng.api.model.maintenance.*;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.common.core.domain.R;
import com.xiaopeng.common.core.exception.ServiceException;
import com.xiaopeng.common.core.web.page.PageInfo;
import com.xiaopeng.maintenance.constant.I18nKeyConstant;
import com.xiaopeng.maintenance.dto.HandleVehicleAccidentDto;
import com.xiaopeng.maintenance.dto.SaveRoutineDetailDto;
import com.xiaopeng.maintenance.dto.SaveVehicleAccidentDto;
import com.xiaopeng.maintenance.mapper.*;
import com.xiaopeng.maintenance.model.query.TaskPageListQuery;
import com.xiaopeng.maintenance.model.query.WorkBenchQuery;
import com.xiaopeng.maintenance.model.query.XpTaskRecordPageQuery;
import com.xiaopeng.maintenance.model.vo.*;
import com.xiaopeng.maintenance.service.XpTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 * 任务管理 服务实现类
 * </p>
 *
 * @author WuGuanFengYue
 * @since 2026-02-03
 */
@Service
public class XpTaskServiceImpl extends ServiceImpl<XpTaskMapper, XpTask> implements XpTaskService {

    @Autowired
    private XpTaskHandleDetailMapper xpTaskHandleDetailMapper;
    @Autowired
    private XpChargingRecordMapper chargingRecordMapper;
    @Autowired
    private XpVehicleRepairMapper vehicleRepairMapper;
    @Autowired
    private XpVehiclePreparationMapper vehiclePreparationMapper;
    @Autowired
    private XpVehicleDetectionMapper vehicleDetectionMapper;
    @Autowired
    private XpErrorTypeMapper errorTypeMapper;
    @Autowired
    private XpVehicleCleanMapper vehicleCleanMapper;
    @Autowired
    private XpOperationUserClient xpOperationUserClient;
    @Autowired
    private XpTaskHandleDetailRoutineMapper xpTaskHandleDetailRoutineMapper;

    @Autowired
    private XpVehicleClient xpVehicleClient;
    @Override
    public PageInfo<WorkBenchVO> workbench(WorkBenchQuery query) {
        PageInfo<WorkBenchVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<WorkBenchVO> list = this.baseMapper.workbench(pageInfo, query);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public PageInfo<TaskPageListVO> pageList(TaskPageListQuery query) {
        if (query.getDistributeType() != null) {
            LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
            switch (query.getDistributeType()) {
                case 1: // 今天
                    query.setStartTime(now.with(LocalTime.MIN).format(formatter));
                    query.setEndTime(now.with(LocalTime.MAX).format(formatter));
                    break;
                case 2: // 昨天
                    LocalDateTime yesterdayStart = now.minusDays(1).with(LocalTime.MIN);
                    LocalDateTime yesterdayEnd = now.minusDays(1).with(LocalTime.MAX);
                    query.setStartTime(yesterdayStart.format(formatter));
                    query.setEndTime(yesterdayEnd.format(formatter));
                    break;
                case 3: // 近一周
                    LocalDateTime weekAgoStart = now.minusDays(7).with(LocalTime.MIN);
                    query.setStartTime(weekAgoStart.format(formatter));
                    query.setEndTime(now.with(LocalTime.MAX).format(formatter));
                    break;
                case 4: // 近一月
                    LocalDateTime monthAgoStart = now.minusDays(30).with(LocalTime.MIN);
                    query.setStartTime(monthAgoStart.format(formatter));
                    query.setEndTime(now.with(LocalTime.MAX).format(formatter));
                    break;
                default:
                    // 默认不设置时间范围
                    break;
            }
        }
        PageInfo<TaskPageListVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<TaskPageListVO> list = this.baseMapper.pageList(pageInfo, query);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public void saveVehicleAccident(SaveVehicleAccidentDto dto, XpOperationsUser xpOperationsUser) {
        XpTask xpTask = new XpTask();
        xpTask.setTaskCode("1");
        xpTask.setTaskCategory(2);
        xpTask.setTaskTypeId(dto.getTaskTypeId());
        xpTask.setTaskUrgencyLevel(dto.getTaskUrgencyLevel());
        xpTask.setTaskDescription(dto.getTaskDescription());
        // todo 获取车辆当前位置
//        xpTask.setVehicleLocation();
//        xpTask.setVehicleId();
//        xpTask.setVehicleLon();
//        xpTask.setVehicleLat();
        xpTask.setReportUserId(xpOperationsUser.getId());
        xpTask.setReportTime(LocalDateTime.now());
        xpTask.setStatus(0);
        xpTask.setCreateBy(xpOperationsUser.getNickName());
        this.save(xpTask);
    }

    @Override
    public R<TaskAccidentDetailVO> vehicleAccidentDetail(Long id) {
        TaskAccidentDetailVO res = new TaskAccidentDetailVO();
        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setId(id);
        res.setVehicleId(vehicle.getId());
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setEndTime(task.getEndTime());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        Map<Long, List<XpErrorType>> errorType = errorTypeMapper.selectList(new LambdaQueryWrapper<XpErrorType>()
                        .in(XpErrorType::getId, Arrays.asList(task.getTaskTypeId().split(","))))
                .stream().collect(Collectors.groupingBy(XpErrorType::getParentId));
        List<XpErrorType> xpErrorTypes = errorType.get(0L);
        for (XpErrorType xpErrorType : xpErrorTypes) {
            xpErrorType.setChild(errorType.get(xpErrorType.getId()));
        }
        res.setErrorTypeList(xpErrorTypes);
        res.setStatus(task.getStatus());
        res.setTaskDescription(task.getTaskDescription());
        res.setTaskImage(task.getTaskImage());
        return R.ok(res);
    }

    @Override
    public R handleVehicleAccident(HandleVehicleAccidentDto dto, XpOperationsUser xpOperationsUser) {
        XpTask task = this.getById(dto.getId());
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }

        task.setHandleTime(LocalDateTime.now());
        task.setHandleUserId(xpOperationsUser.getId());
        task.setStatus(2);
        // 存储事故处理日志
        XpTaskHandleDetail xpTaskHandleDetail = new XpTaskHandleDetail();
        xpTaskHandleDetail.setTaskId(task.getId());
        xpTaskHandleDetail.setDeathCount(dto.getDeathCount());
        xpTaskHandleDetail.setSevereCount(dto.getSevereCount());
        xpTaskHandleDetail.setMinorCount(dto.getMinorCount());
        xpTaskHandleDetail.setResponsibilityJudgment(dto.getResponsibilityJudgment());
        xpTaskHandleDetail.setResponsibleDescription(dto.getResponsibleDescription());
        xpTaskHandleDetail.setResponsibleImage(dto.getResponsibleImage());
        xpTaskHandleDetail.setDisposalDescription(dto.getDisposalDescription());
        xpTaskHandleDetail.setDisposalImage(dto.getDisposalImage());
        xpTaskHandleDetail.setSituationDescription(dto.getSituationDescription());
        xpTaskHandleDetail.setSituationImage(dto.getSituationImage());
        xpTaskHandleDetailMapper.insert(xpTaskHandleDetail);
        return R.ok();
    }

    @Override
    public R<TaskRoutineDetailVO> vehicleRoutineDetail(Long id) {
        TaskRoutineDetailVO res = new TaskRoutineDetailVO();
        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setEndTime(task.getEndTime());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        res.setTaskDescription(task.getTaskDescription());
        res.setTaskImage(task.getTaskImage());
        return R.ok(res);
    }

    @Override
    public R<TaskChargingDetailVO> chargingDetail(Long id) {
        TaskChargingDetailVO res = new TaskChargingDetailVO();
        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setVehicleId(task.getVehicleId());
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        XpChargingRecord chargingRecord = chargingRecordMapper.selectOne(new LambdaQueryWrapper<XpChargingRecord>()
                .eq(XpChargingRecord::getTaskId, id).last("limit 1"));
        if (chargingRecord != null){
            res.setStartRemainingBattery(chargingRecord.getStartRemainingBattery());
            res.setStartChargingPicture(chargingRecord.getStartChargingPicture());
            res.setStartTime(chargingRecord.getStartTime());
            res.setEndRemainingBattery(chargingRecord.getEndRemainingBattery());
            res.setEndChargingPicture(chargingRecord.getEndChargingPicture());
            res.setEndTime(chargingRecord.getEndTime());
            res.setStartOperationsUserId(chargingRecord.getStartOperationsUserId());
            res.setEndOperationsUserId(chargingRecord.getEndOperationsUserId());
            if (chargingRecord.getStartOperationsUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getStartOperationsUserId()).getData();
                if (operationsUser != null){
                    res.setStartOperationsUserName(operationsUser.getNickName());
                }
            }
            if (chargingRecord.getEndOperationsUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(chargingRecord.getEndOperationsUserId()).getData();
                if (operationsUser != null){
                    res.setEndOperationsUserName(operationsUser.getNickName());
                }
            }
        }

        return R.ok(res);
    }

    @Override
    public R<com.xiaopeng.maintenance.vo.TaskRepairDetailVO> repairDetail(Long id) {
        com.xiaopeng.maintenance.vo.TaskRepairDetailVO res = new com.xiaopeng.maintenance.vo.TaskRepairDetailVO();


        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setVehicleId(task.getVehicleId());
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        XpVehicleRepair vehicleRepair = vehicleRepairMapper.selectOne(new LambdaQueryWrapper<XpVehicleRepair>()
                .eq(XpVehicleRepair::getTaskId, id).last("limit 1"));
        if (vehicleRepair != null){
            res.setStartTime(vehicleRepair.getStartTime());
            res.setEndTime(vehicleRepair.getEndTime());
            res.setRepairReason(vehicleRepair.getRepairReason());
            res.setStartRepairPicture(vehicleRepair.getStartRepairPicture());
            res.setRepairMoney(vehicleRepair.getRepairMoney());
            res.setRepairMoneyDetail(vehicleRepair.getRepairMoneyDetail());
            res.setSendUserId(vehicleRepair.getSendUserId());
            res.setSendTime(vehicleRepair.getSendTime());
            res.setReturnUserId(vehicleRepair.getReturnUserId());
            res.setReturnTime(vehicleRepair.getReturnTime());
            if (vehicleRepair.getReturnUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getReturnUserId()).getData();
                if (operationsUser != null){
                    res.setReturnUserName(operationsUser.getNickName());
                }
            }
            if (vehicleRepair.getSendUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleRepair.getSendUserId()).getData();
                if (operationsUser != null){
                    res.setSendUserName(operationsUser.getNickName());
                }
            }
        }

        return R.ok(res);
    }

    @Override
    public R<com.xiaopeng.maintenance.vo.TaskPreparationDetailVO> preparationDetail(Long id) {
        com.xiaopeng.maintenance.vo.TaskPreparationDetailVO res = new com.xiaopeng.maintenance.vo.TaskPreparationDetailVO();





        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setVehicleId(task.getVehicleId());
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        XpVehiclePreparation vehiclePreparation = vehiclePreparationMapper.selectOne(new LambdaQueryWrapper<XpVehiclePreparation>()
                .eq(XpVehiclePreparation::getTaskId, id).last("limit 1"));
        if (vehiclePreparation != null){
            res.setLeftFrontWheel(vehiclePreparation.getLeftFrontWheel());
            res.setRightFrontWheel(vehiclePreparation.getRightFrontWheel());
            res.setLeftRearWheel(vehiclePreparation.getLeftRearWheel());
            res.setRightRearWheel(vehiclePreparation.getRightRearWheel());
            res.setHeadLight(vehiclePreparation.getHeadLight());
            res.setTurnSignal(vehiclePreparation.getTurnSignal());
            res.setBrakeLight(vehiclePreparation.getBrakeLight());
            res.setFogLight(vehiclePreparation.getFogLight());
            res.setBodyEmblem(vehiclePreparation.getBodyEmblem());
            res.setCabinCleaning(vehiclePreparation.getCabinCleaning());
            res.setLostItems(vehiclePreparation.getLostItems());
            res.setRemarks(vehiclePreparation.getRemarks());
            res.setOperationsUserId(vehiclePreparation.getOperationsUserId());
            res.setOperationsTime(vehiclePreparation.getCreateTime());
            if (vehiclePreparation.getOperationsUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehiclePreparation.getOperationsUserId()).getData();
                if (operationsUser != null){
                    res.setOperationsUserName(operationsUser.getNickName());
                }
            }
        }
        return R.ok(res);
    }

    @Override
    public R<com.xiaopeng.maintenance.vo.TaskDetectionDetailVO> detectionDetail(Long id) {
        com.xiaopeng.maintenance.vo.TaskDetectionDetailVO res = new com.xiaopeng.maintenance.vo.TaskDetectionDetailVO();







        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setVehicleId(task.getVehicleId());
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        XpVehicleDetection vehicleDetection = vehicleDetectionMapper.selectOne(new LambdaQueryWrapper<XpVehicleDetection>()
                .eq(XpVehicleDetection::getTaskId, id).last("limit 1"));
        if (vehicleDetection != null){
            res.setNetworkDetection(vehicleDetection.getNetworkDetection());
            res.setVersionVerification(vehicleDetection.getVersionVerification());
            res.setCommunicationSelfCheck(vehicleDetection.getCommunicationSelfCheck());
            res.setRemoteSelfCheck(vehicleDetection.getRemoteSelfCheck());
            res.setCollisionPrevention(vehicleDetection.getCollisionPrevention());
            res.setSensorSelfCheck(vehicleDetection.getSensorSelfCheck());
            res.setSensorCleaning(vehicleDetection.getSensorCleaning());
            res.setSensorCleaningPicture(vehicleDetection.getSensorCleaningPicture());
            res.setInteractiveScreen(vehicleDetection.getInteractiveScreen());
            res.setInteractiveScreenPicture(vehicleDetection.getInteractiveScreenPicture());
            res.setHelpButton(vehicleDetection.getHelpButton());
            res.setHelpButtonPicture(vehicleDetection.getHelpButtonPicture());
            res.setPaymentFunction(vehicleDetection.getPaymentFunction());
            res.setPaymentFunctionPicture(vehicleDetection.getPaymentFunctionPicture());
            res.setSystemCheck(vehicleDetection.getSystemCheck());
            res.setSystemCheckPicture(vehicleDetection.getSystemCheckPicture());
            res.setCheckTime(vehicleDetection.getCheckTime());
            res.setOperationsUserId(vehicleDetection.getOperationsUserId());
            if (vehicleDetection.getOperationsUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleDetection.getOperationsUserId()).getData();
                if (operationsUser != null){
                    res.setOperationsUserName(operationsUser.getNickName());
                }
            }
        }
        return R.ok(res);
    }

    @Override
    public R saveRoutineDetail(SaveRoutineDetailDto dto, Long id) {
        XpTask task = this.getById(dto.getId());
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpTaskHandleDetailRoutine xpTaskHandleDetailRoutine = new XpTaskHandleDetailRoutine();
        xpTaskHandleDetailRoutine.setTaskId(task.getId());
        String taskTypeId = task.getTaskTypeId();
        switch (taskTypeId){
            case "6":
                xpTaskHandleDetailRoutine.setTaskType(1);
                break;
            case "7":
                xpTaskHandleDetailRoutine.setTaskType(2);

                break;
            case "8":
                xpTaskHandleDetailRoutine.setTaskType(3);

                break;
            case "9":
                xpTaskHandleDetailRoutine.setTaskType(4);
                break;
        }
        xpTaskHandleDetailRoutine.setTaskDescription(dto.getTaskDescription());
        xpTaskHandleDetailRoutine.setTaskImage(dto.getTaskImage());
        xpTaskHandleDetailRoutine.setOperationsUserId(id);
        xpTaskHandleDetailRoutineMapper.insert(xpTaskHandleDetailRoutine);
        task.setStatus(2);
        this.updateById(task);
        return null;
    }

    @Override
    public R<com.xiaopeng.maintenance.vo.TaskCleanDetailVO> cleanDetail(Long id) {
        com.xiaopeng.maintenance.vo.TaskCleanDetailVO res = new com.xiaopeng.maintenance.vo.TaskCleanDetailVO();
        XpTask task = this.getById(id);
        if (task == null){
            throw new ServiceException(
                    "任务不存在",
                    I18nKeyConstant.TASK_NOT_EXIST
            );
        }
        XpVehicle vehicle = xpVehicleClient.queryById(task.getVehicleId()).getData();
        if (vehicle == null){
            throw new ServiceException(
                    "车辆不存在",
                    I18nKeyConstant.VEHICLE_NOT_EXIST
            );
        }
        res.setVehicleId(task.getVehicleId());
        res.setId(id);
        res.setTaskUrgencyLevel(task.getTaskUrgencyLevel());
        res.setPlateNumber(vehicle.getPlateNumber());
        res.setVehicleColor(vehicle.getVehicleColor());
        res.setVehicleCode(vehicle.getVehicleCode());
        res.setVehicleLocation(task.getVehicleLocation());
        res.setCreateBy(task.getCreateBy());
        res.setCreateTime(task.getCreateTime());
        res.setTaskCode(task.getTaskCode());
        res.setTaskCategory(task.getTaskCategory());
        res.setTaskTypeId(task.getTaskTypeId());
        res.setStatus(task.getStatus());
        XpVehicleClean vehicleDetection = vehicleCleanMapper.selectOne(new LambdaQueryWrapper<XpVehicleClean>()
                .eq(XpVehicleClean::getTaskId, id).last("limit 1"));
        if (vehicleDetection != null){
            res.setTaskImage(vehicleDetection.getTaskImage());
            res.setOperationUserId(vehicleDetection.getOperationsUserId());
            if (vehicleDetection.getOperationsUserId() != null){
                XpOperationsUser operationsUser = xpOperationUserClient.queryById(vehicleDetection.getOperationsUserId()).getData();
                if (operationsUser != null){
                    res.setOperationsUserName(operationsUser.getNickName());
                }
            }
        }
        return R.ok(res);
    }

    @Override
    public R confirmArrive(Integer id) {
        XpTask task = this.getById(id);
        if (task!=null){
            task.setStatus(1);
            this.updateById(task);
        }
        return R.ok();
    }

    @Override
    public PageInfo<XpTaskRecordVO> queryTaskByVehicleId(XpTaskRecordPageQuery query) {
        return null;
    }
}