package com.xiaopeng.vehicleConvoy.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xiaopeng.api.dto.vehicleConvoy.VehicleTemperatureDto;
import com.xiaopeng.api.feignClient.operation.XpElectronicClient;
import com.xiaopeng.api.feignClient.order.XpOrderClient;
import com.xiaopeng.api.model.operation.XpElectronicFence;
import com.xiaopeng.api.model.order.XpOrder;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicle;
import com.xiaopeng.api.model.vehicleConvoy.XpVehicleAnnualRecord;
import com.xiaopeng.api.vo.operation.ElectronicFenceDetailVo;
import com.xiaopeng.api.vo.vehicleConvoy.VehicleTemperatureVo;
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandEnum;
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandParamVo;
import com.xiaopeng.api.vo.vehicleConvoy.VehiclesCommandVo;
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.common.security.utils.SecurityUtils;
import com.xiaopeng.vehicleConvoy.constant.I18nKeyConstant;
import com.xiaopeng.vehicleConvoy.mapper.XpVehicleMapper;
import com.xiaopeng.vehicleConvoy.model.dto.*;
import com.xiaopeng.vehicleConvoy.model.importExcel.XpVehicleImportExcel;
import com.xiaopeng.vehicleConvoy.model.query.*;
import com.xiaopeng.vehicleConvoy.service.IXpVehicleAnnualRecordService;
import com.xiaopeng.vehicleConvoy.service.IXpVehicleService;
import com.xiaopeng.vehicleConvoy.util.VehicleControlUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.i18n.LocaleContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 车辆管理 服务实现类
 * </p>
 *
 * @author mitao
 * @since 2026-02-03
 */
@Slf4j
@Service
public class XpVehicleServiceImpl extends ServiceImpl<XpVehicleMapper, XpVehicle> implements IXpVehicleService {

    @Autowired
    private VehicleControlUtil vehicleControlUtil;

    @Autowired
    private XpOrderClient xpOrderClient;

    @Autowired
    private XpElectronicClient xpElectronicClient;

    @Autowired
    private IXpVehicleAnnualRecordService xpVehicleAnnualRecordService;

    @Override
    public List<XpVehicle> listByIds(List<Long> ids) {
        if (CollectionUtils.isEmpty(ids)) {
            return new ArrayList<>();
        }
        return super.listByIds(ids);
    }

    @Override
    public List<XpVehicle> listAvailableVehicles() {
        // 构建查询条件
        LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();

        // 必要条件：可改派车辆的4个核心条件
        wrapper.ne(XpVehicle::getStatus, 3)  // 状态不是保险/年检过期
               .isNotNull(XpVehicle::getStatus)
               .eq(XpVehicle::getOperatingStatus, 1)  // 运营中
               .eq(XpVehicle::getAcceptOrTest, 1)  // 接单模式
               .eq(XpVehicle::getAcceptOrTestStatus, 1);  // 开始接单

        // 排序：按电量降序、入库时间降序
        wrapper.orderByDesc(XpVehicle::getCurrentElectricity)
               .orderByDesc(XpVehicle::getWarehousingTime);

        // 执行查询
        return this.list(wrapper);
    }

    @Override
    public PageInfo<XpVehicle> pageList(VehicleMapQuery query) {
        PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<XpVehicle> list = this.baseMapper.pageList(pageInfo, query);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<XpVehicle> listByPlateNumber(String plateNumber) {
        if (StringUtils.isBlank(plateNumber)) {
            return Collections.emptyList();
        }

        return lambdaQuery().like(XpVehicle::getPlateNumber, plateNumber).list();
    }

    @Override
    public List<XpVehicle> listByFenceId(Long fenceId) {
        if (fenceId == null) {
            return Collections.emptyList();
        }
        return lambdaQuery().eq(XpVehicle::getElectronicId, fenceId).eq(XpVehicle::getOperatingStatus,1).eq(XpVehicle::getState,0).list();
    }

    @Override
    public Integer unlock(UnlockAppletDTO dto) {
        // 查询订单
        XpOrder xpOrder = xpOrderClient.queryOrderById(dto.getOrderId()).getData();
        if(Objects.isNull(xpOrder)){
            throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
        }
        XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
        if(Objects.isNull(xpVehicle)){
            throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
        }
        // 车门解锁、后备箱解锁
        VehiclesCommandVo vehiclesCommandVo = new VehiclesCommandVo();
        vehiclesCommandVo.setUid(xpOrder.getAppUserId());
        vehiclesCommandVo.setVin(xpVehicle.getVehicleVin());
        if("door".equals(dto.getDoorType())){
            vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.DOOR_UNLOCK);
        }else {
            vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.DOOR_TRUNK_OPEN);
        }
        try{
            String result = vehicleControlUtil.vehiclesCommand(vehiclesCommandVo);
            log.info("车辆控制结果：{}", result);
            return 1;
        }catch (Exception e){
            log.error("车辆控制异常：{}", e.getMessage());
            return 0;
        }
    }

    @Override
    public Integer setTemperature(SetTemperatureDTO dto) {
        // 查询订单
        XpOrder xpOrder = xpOrderClient.queryOrderById(dto.getOrderId()).getData();
        if(Objects.isNull(xpOrder)){
            throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
        }
        XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
        if(Objects.isNull(xpVehicle)){
            throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
        }
        // 设定温度
        VehiclesCommandVo vehiclesCommandVo = new VehiclesCommandVo();
        vehiclesCommandVo.setUid(xpOrder.getAppUserId());
        vehiclesCommandVo.setVin(xpVehicle.getVehicleVin());
        vehiclesCommandVo.setCommandCode(VehiclesCommandEnum.HVAC_TEMP_SET);
        VehiclesCommandParamVo vehiclesCommandParamVo = new VehiclesCommandParamVo();
        vehiclesCommandParamVo.setDegree(dto.getTargetTemperature());
        vehiclesCommandVo.setExtParam(vehiclesCommandParamVo);
        try{
            String result = vehicleControlUtil.vehiclesCommand(vehiclesCommandVo);
            log.info("车辆控制结果：{}", result);
            return 1;
        }catch (Exception e){
            log.error("车辆控制异常：{}", e.getMessage());
            return 0;
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void addVehicle(VehicleAddDTO dto) {
        // DTO转实体
        XpVehicle xpVehicle = new XpVehicle();
        BeanUtil.copyProperties(dto, xpVehicle);

        // 设置默认值：在库车辆
        xpVehicle.setVehicleType(1);
        // 新增时状态为待完善
        xpVehicle.setStatus(1);
        // 设置入库时间
        xpVehicle.setWarehousingTime(LocalDateTime.now());
        xpVehicle.setCreateBy(SecurityUtils.getLoginUser().getSysUser().getNickName());
        this.save(xpVehicle);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void editVehicle(VehicleEditDTO dto) {
        // DTO转实体
        XpVehicle xpVehicle = new XpVehicle();
        BeanUtil.copyProperties(dto, xpVehicle);

        xpVehicle.setUpdateBy(SecurityUtils.getLoginUser().getSysUser().getNickName());
        this.updateById(xpVehicle);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void improveInfo(VehicleImproveInfoDTO dto) {
        // 校验已填写的时间字段是否在有效范围内
        validateTimeFields(dto);

        // DTO转实体
        XpVehicle xpVehicle = new XpVehicle();
        BeanUtil.copyProperties(dto, xpVehicle);

        // 更新保险、年检、运营资质等信息
        this.updateById(xpVehicle);
        // 查询更新后的完整信息
        XpVehicle vehicle = this.getById(dto.getId());
        if (vehicle == null) {
            return;
        }

        if (Integer.valueOf(2).equals(dto.getSaveType())) {
            // 保存并开始运营：校验保险、年检、运营区域、运营资质是否完善
            validateForOperation(vehicle);
            // 校验通过，直接转为运营状态
            vehicle.setStatus(2);
            vehicle.setVehicleType(2);
            vehicle.setOperatingStatus(1);
            this.updateById(vehicle);
        } else {
            // 仅保存：如果信息完善则状态改为待运营
            if (isInfoComplete(vehicle)) {
                vehicle.setStatus(2);
                this.updateById(vehicle);
            }
        }
        //保存年检记录
        XpVehicleAnnualRecord xpVehicleAnnualRecord = BeanUtil.copyProperties(dto, XpVehicleAnnualRecord.class, "id");
        xpVehicleAnnualRecord.setVehicleId(dto.getId());
        xpVehicleAnnualRecord.setCreateBy(SecurityUtils.getLoginUser().getSysUser().getCreateBy());
        xpVehicleAnnualRecordService.save(xpVehicleAnnualRecord);
    }

    /**
     * 校验已填写的时间字段是否在有效范围内（未过期）
     */
    private void validateTimeFields(VehicleImproveInfoDTO dto) {
        LocalDateTime now = LocalDateTime.now();
        List<String> expiredItems = new ArrayList<>();
        Locale locale = LocaleContextHolder.getLocale();

        if (dto.getAnnualInspectionDate() != null && dto.getAnnualInspectionDate().isBefore(now)) {
            if (locale.equals(Locale.CHINESE)) {
                expiredItems.add("年检到期时间");
            } else {
                expiredItems.add("Annual inspection expiration date");
            }
        }
        if (dto.getInsuranceEndTime() != null && dto.getInsuranceEndTime().isBefore(now)) {
            if (locale.equals(Locale.CHINESE)) {
                expiredItems.add("保险到期时间");
            } else {
                expiredItems.add("Insurance expiration date");
            }
        }
        if (dto.getQualificationExpireTime() != null && dto.getQualificationExpireTime().isBefore(now)) {
            if (locale.equals(Locale.CHINESE)) {
                expiredItems.add("运营资质到期时间");
            } else {
                expiredItems.add("Operation qualification expiration date");
            }
        }

        if (!expiredItems.isEmpty()) {
            String detail;
            if (locale.equals(Locale.CHINESE)) {
                detail = String.join("、", expiredItems);
            } else {
                detail = String.join("; ", expiredItems);
            }
            throw new ServiceException("以下时间已过期，请填写有效日期：" + detail,
                    I18nKeyConstant.VEHICLE_TIME_EXPIRED, new Object[]{detail});
        }
    }

    /**
     * 校验车辆运营前置条件
     */
    private void validateForOperation(XpVehicle vehicle) {
        List<String> missingItems = new ArrayList<>();
        Locale locale = LocaleContextHolder.getLocale();

        // 校验保险信息
        if (StringUtils.isBlank(vehicle.getInsuranceCompany())
                || StringUtils.isBlank(vehicle.getInsurancePhone())
                || vehicle.getInsuranceEndTime() == null
                || StringUtils.isBlank(vehicle.getPolicyInformation())) {
            if (locale.equals(Locale.CHINESE)) {
                missingItems.add("保险信息");
            } else {
                missingItems.add("Insurance information");
            }
        }

        // 校验年检信息
        if (vehicle.getAnnualInspectionDate() == null
                || StringUtils.isBlank(vehicle.getInspectionAttachments())) {
            if (locale.equals(Locale.CHINESE)) {
                missingItems.add("年检信息");
            } else {
                missingItems.add("Annual inspection information");
            }
        }

        // 校验运营区域
        if (vehicle.getElectronicId() == null) {
            if (locale.equals(Locale.CHINESE)) {
                missingItems.add("运营区域");
            } else {
                missingItems.add("Operation area");
            }
        }

        // 校验运营资质
        if (StringUtils.isBlank(vehicle.getOperationQualification())
                || vehicle.getQualificationExpireTime() == null) {
            if (locale.equals(Locale.CHINESE)) {
                missingItems.add("运营资质");
            } else {
                missingItems.add("Operation qualification");
            }
        }

        if (!missingItems.isEmpty()) {
            String detail;
            if (locale.equals(Locale.CHINESE)) {
                detail = String.join("、", missingItems);
            } else {
                detail = String.join("; ", missingItems);
            }
            throw new ServiceException("以下信息未完善，无法开始运营：" + detail,
                    I18nKeyConstant.VEHICLE_OPERATION_INFO_INCOMPLETE, new Object[]{detail});
        }
    }

    /**
     * 判断车辆信息是否已完善
     */
    private boolean isInfoComplete(XpVehicle vehicle) {
        return vehicle.getAnnualInspectionDate() != null
                && StringUtils.isNotBlank(vehicle.getInsuranceCompany())
                && StringUtils.isNotBlank(vehicle.getInsurancePhone())
                && vehicle.getInsuranceEndTime() != null
                && StringUtils.isNotBlank(vehicle.getInspectionAttachments())
                && StringUtils.isNotBlank(vehicle.getPolicyInformation())
                && StringUtils.isNotBlank(vehicle.getOperationQualification())
                && vehicle.getQualificationExpireTime() != null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchOperation(String idStr) {
        if (StringUtils.isBlank(idStr)) {
            return;
        }
        List<String> ids = Arrays.asList(idStr.split(","));
        // 查询车辆完整信息
        List<XpVehicle> vehicles = this.listByIds(ids);
        LocalDateTime now = LocalDateTime.now();
        List<String> errorMessages = new ArrayList<>();

        for (XpVehicle vehicle : vehicles) {
            List<String> reasons = new ArrayList<>();
            Locale locale = LocaleContextHolder.getLocale();

            // 校验状态为待运营
            if (!Integer.valueOf(2).equals(vehicle.getStatus())) {
                if (locale.equals(Locale.CHINESE)) {
                    reasons.add("状态非待运营");
                } else {
                    reasons.add("Status is not 'Pending Operation'");
                }
            }
            // 校验年检到期时间
            if (vehicle.getAnnualInspectionDate() == null || vehicle.getAnnualInspectionDate().isBefore(now)) {
                if (locale.equals(Locale.CHINESE)) {
                    reasons.add("年检已过期");
                } else {
                    reasons.add("Annual inspection has expired");
                }
            }
            // 校验保险到期时间
            if (vehicle.getInsuranceEndTime() == null || vehicle.getInsuranceEndTime().isBefore(now)) {
                if (locale.equals(Locale.CHINESE)) {
                    reasons.add("保险已过期");
                } else {
                    reasons.add("Insurance has expired");
                }
            }
            // 校验运营资质到期时间
            if (vehicle.getQualificationExpireTime() == null || vehicle.getQualificationExpireTime().isBefore(now)) {
                if (locale.equals(Locale.CHINESE)) {
                    reasons.add("运营资质已过期");
                } else {
                    reasons.add("Operation qualification has expired");
                }
            }
            if (!reasons.isEmpty()) {
                if (locale.equals(Locale.CHINESE)) {
                    errorMessages.add("车辆[" + vehicle.getPlateNumber() + "]：" + String.join("、", reasons));
                } else {
                    errorMessages.add("Vehicles [" + vehicle.getPlateNumber() + "]: " + String.join("; ", reasons));
                }
            }
        }

        if (!errorMessages.isEmpty()) {
            String detail = String.join("；", errorMessages);
            throw new ServiceException("以下车辆不满足运营条件：" + detail,
                    I18nKeyConstant.VEHICLE_BATCH_OPERATION_CONDITION_NOT_MET, new Object[]{detail});
        }

        // 校验通过，批量转为运营状态（vehicleType: 1→2）
        LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(XpVehicle::getId, idStr)
                .set(XpVehicle::getVehicleType, 2)
                .set(XpVehicle::getOperatingStatus, 1);
        this.update(wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchStock(String idStr) {
        if (StringUtils.isBlank(idStr)) {
            return;
        }
        List<String> ids = Arrays.asList(idStr.split(","));
        // 批量将运营车辆转为在库状态（vehicleType: 2→1）
        LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(XpVehicle::getId, ids)
                .set(XpVehicle::getVehicleType, 1)
                .set(XpVehicle::getOperatingStatus, null);
        this.update(wrapper);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void batchSetElectronic(List<Long> ids, Long electronicId) {
        if (CollectionUtils.isEmpty(ids)) {
            return;
        }
        // 批量更新运营区域并设置状态为待运营
        LambdaUpdateWrapper<XpVehicle> wrapper = new LambdaUpdateWrapper<>();
        wrapper.in(XpVehicle::getId, ids)
                .set(XpVehicle::getElectronicId, electronicId)
                .set(XpVehicle::getStatus, 2);
        this.update(wrapper);
    }

    @Override
    public PageInfo<XpVehicle> vehiclePageList(VehiclePageQuery query) {
        PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
        List<XpVehicle> list = this.baseMapper.vehiclePageList(pageInfo, query);
        pageInfo.setRecords(list);
        return pageInfo;
    }

    @Override
    public List<XpVehicle> vehicleExportList(VehicleExportQuery query) {
        return this.baseMapper.vehicleExportList(query);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void importVehicles(List<XpVehicleImportExcel> importList) {
        if (CollectionUtils.isEmpty(importList)) {
            return;
        }
        List<XpVehicle> vehicleList = importList.stream().map(item -> {
            XpVehicle vehicle = new XpVehicle();
            BeanUtil.copyProperties(item, vehicle);
            // 设置默认值
            vehicle.setVehicleType(1);
            vehicle.setStatus(1);
            vehicle.setWarehousingTime(LocalDateTime.now());
            return vehicle;
        }).collect(Collectors.toList());
        this.saveBatch(vehicleList);
    }

    @Override
    public XpVehicle getVehicleDetail(Long id) {
        XpVehicle vehicle = this.getById(id);
        if (vehicle == null) {
            return null;
        }
        // 查询围栏名称
        if (vehicle.getElectronicId() != null) {
            try {
                R<ElectronicFenceDetailVo> result = xpElectronicClient.queryById(vehicle.getElectronicId());
                if (R.isSuccess(result) && result.getData() != null) {
                    vehicle.setElectronicName(result.getData().getElectronicName());
                }
            } catch (Exception e) {
                log.warn("查询围栏名称失败, electronicId={}", vehicle.getElectronicId(), e);
            }
        }
        return vehicle;
    }

    @Override
    public PageInfo<XpVehicle> operationPageList(OperationVehiclePageQuery query) {
        //1.构建分页参数
        PageInfo<XpVehicle> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());

        // 2.构建查询条件
        LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(XpVehicle::getVehicleType, 2)
                .like(StringUtils.isNotBlank(query.getVehicleCode()), XpVehicle::getVehicleCode, query.getVehicleCode())
                .like(StringUtils.isNotBlank(query.getVehicleVin()), XpVehicle::getVehicleVin, query.getVehicleVin())
                .like(StringUtils.isNotBlank(query.getPlateNumber()), XpVehicle::getPlateNumber, query.getPlateNumber())
                .eq(Objects.nonNull(query.getOperatingStatus()), XpVehicle::getOperatingStatus, query.getOperatingStatus())
                .eq(Objects.nonNull(query.getElectronicId()), XpVehicle::getElectronicId, query.getOperatingStatus());
        if (Objects.nonNull(query.getStartTime())) {
            wrapper.ge(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
        }
        if (Objects.nonNull(query.getEndTime())) {
            wrapper.le(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
        }
        wrapper.orderByDesc(XpVehicle::getCreateTime);
        //3.执行分页查询
        PageInfo<XpVehicle> page = this.page(pageInfo, wrapper);

        //4.批量查询围栏名称并填充
        Set<Long> electronicIdSet = page.getRecords().stream().map(XpVehicle::getElectronicId).collect(Collectors.toSet());
        List<XpElectronicFence> fenceList = CollUtil.isNotEmpty(electronicIdSet) ?
                xpElectronicClient.listByIds(electronicIdSet).getData() :
                Collections.emptyList();
        if (CollUtil.isNotEmpty(fenceList)) {
            Map<Long, String> fenceNameMap = fenceList.stream().collect(Collectors.toMap(XpElectronicFence::getId, XpElectronicFence::getElectronicName));
            page.getRecords().forEach(vehicle -> {
                if (vehicle.getElectronicId() != null) {
                    vehicle.setElectronicName(fenceNameMap.get(vehicle.getElectronicId()));
                }
            });
        }
        return pageInfo;
    }

    @Override
    public List<XpVehicle> operationVehicleExportList(OperationVehicleExportQuery query) {
        // 1.构建查询条件
        LambdaQueryWrapper<XpVehicle> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(XpVehicle::getVehicleType, 2)
                .like(StringUtils.isNotBlank(query.getVehicleCode()), XpVehicle::getVehicleCode, query.getVehicleCode())
                .like(StringUtils.isNotBlank(query.getVehicleVin()), XpVehicle::getVehicleVin, query.getVehicleVin())
                .like(StringUtils.isNotBlank(query.getPlateNumber()), XpVehicle::getPlateNumber, query.getPlateNumber())
                .eq(Objects.nonNull(query.getOperatingStatus()), XpVehicle::getOperatingStatus, query.getOperatingStatus())
                .eq(Objects.nonNull(query.getElectronicId()), XpVehicle::getElectronicId, query.getOperatingStatus())
                .in(CollUtil.isNotEmpty(query.getIds()), XpVehicle::getId, query.getIds());
        if (Objects.nonNull(query.getStartTime())) {
            wrapper.ge(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getStartTime(), LocalTime.MIN));
        }
        if (Objects.nonNull(query.getEndTime())) {
            wrapper.le(XpVehicle::getAnnualInspectionDate, LocalDateTime.of(query.getEndTime(), LocalTime.MAX));
        }
        wrapper.orderByDesc(XpVehicle::getCreateTime);
        //2.执行查询
        List<XpVehicle> list = this.list(wrapper);

        //3.批量查询围栏名称并填充
        Set<Long> electronicIdSet = list.stream().map(XpVehicle::getElectronicId).collect(Collectors.toSet());
        List<XpElectronicFence> fenceList = CollUtil.isNotEmpty(electronicIdSet) ?
                xpElectronicClient.listByIds(electronicIdSet).getData() :
                Collections.emptyList();
        if (CollUtil.isNotEmpty(fenceList)) {
            Map<Long, String> fenceNameMap = fenceList.stream().collect(Collectors.toMap(XpElectronicFence::getId, XpElectronicFence::getElectronicName));
            list.forEach(vehicle -> {
                if (vehicle.getElectronicId() != null) {
                    vehicle.setElectronicName(fenceNameMap.get(vehicle.getElectronicId()));
                }
            });
        }
        return list;
    }

    @Override
    public VehicleTemperatureDto queryTemperatureByOrderId(Long orderId,String uid) {
        XpOrder xpOrder = xpOrderClient.queryOrderById(orderId).getData();
        if(Objects.isNull(xpOrder)){
            throw new ServiceException("未查询到有效订单信息", I18nKeyConstant.ORDER_NOT_EXISTS);
        }
        XpVehicle xpVehicle = this.getById(xpOrder.getVehicleId());
        if(Objects.isNull(xpVehicle)){
            throw new ServiceException("未查询到有效车辆信息", I18nKeyConstant.VEHICLE_NOT_EXISTS);
        }
        try{
            VehicleTemperatureDto vehicleTemperatureDto = vehicleControlUtil.queryVehicleTemperature(uid, xpVehicle.getVehicleVin());
            log.info("查询车辆温度成功：{}",vehicleTemperatureDto);
            return vehicleTemperatureDto;
        }catch (Exception e){
            log.error("查询车辆温度失败",e);
            return new VehicleTemperatureDto();
        }
    }
}