youxiw2000 / trash · Files

package com.trash.garbage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.http.HtmlUtil;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
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.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.trash.carInfo.domain.CarInfo;
import com.trash.carInfo.domain.vo.CarInfoVo;
import com.trash.carInfo.mapper.CarInfoMapper;
import com.trash.carInfo.service.impl.CarInfoServiceImpl;
import com.trash.common.core.redis.RedisCache;
import com.trash.common.utils.RemoteServerUtils;
import com.trash.common.utils.SecurityUtils;
import com.trash.common.utils.ServletUtils;
import com.trash.driver.domain.vo.DriverVo;
import com.trash.driver.service.IDriverService;
import com.trash.dropPointInfo.domain.DropPointInfo;
import com.trash.dropPointInfo.service.IDropPointInfoService;
import com.trash.enterprise.domain.TransportationEnterprise;
import com.trash.enterprise.service.ITransportationEnterpriseService;
import com.trash.garbage.custom.BizException;
import com.trash.garbage.global.GlobalStatus;
import com.trash.garbage.global.ResultCode;
import com.trash.garbage.mapper.GarOrderMapper;
import com.trash.garbage.pojo.domain.*;
import com.trash.garbage.pojo.dto.*;
import com.trash.garbage.pojo.vo.*;
import com.trash.garbage.service.*;
import com.trash.garbage.utils.HttpUtil;
import com.trash.garbage.utils.SMSUtils;
import com.trash.garbage.utils.ValidateCodeUtil;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.apache.commons.lang3.time.FastDateFormat;
import org.apache.http.client.utils.HttpClientUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.util.HtmlUtils;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author 20412
 * @description 针对表【gar_order(建筑垃圾—订单表)】的数据库操作Service实现
 * @createDate 2023-11-24 16:26:19
 */
@Service
public class GarOrderServiceImpl extends ServiceImpl<GarOrderMapper, GarOrder>
        implements GarOrderService {


    @Autowired
    private GarUserOrderMessageService orderMessageService;
    @Autowired
    private GarUserOrderMessageHistoryService orderMessageHistoryService;
    @Resource
    private SMSUtils smsUtils;
    @Autowired
    private GarOrderImageService garOrderImageService;
    @Autowired
    private GarOrderMatchAskService askService;
    @Autowired
    private GarAddressService garAddressService;
    @Autowired
    private GarOrderMatchDisposalService disposalService;
    @Autowired
    private ITransportationEnterpriseService transportationEnterpriseService;
    @Autowired
    private GarOrderEvaluateService garOrderEvaluateService;
    @Autowired
    private GarSearchHistoryService garSearchHistoryService;
    @Autowired
    private GarUserService garUserService;
    @Autowired
    private IDriverService driverService;
    @Autowired
    private GarOrderMatchHandlerService handlerService;
    @Autowired
    private GarOrderCarService garOrderCarService;
    @Autowired
    private RedisCache redisCache;
    @Autowired
    private GarOrderMatchDisposalService garOrderMatchDisposalService;
    @Autowired
    private DisposalSiteService disposalSiteService;
    @Autowired
    private GarTransportationEnterpriseService garTransportationEnterpriseService;
    @Autowired
    private GarAreaServer garAreaServer;
    @Autowired
    private GarOrderAssociationServiceAsync garOrderAssociationServiceAsync;
    
    @Autowired
    private CarInfoMapper carInfoMapper;

    private FastDateFormat fastDateFormat = FastDateFormat.getInstance("yyyy-MM-dd");

    public String contentType = "application/json";
    @Value("${trash.token}")
    public String authorization;
    @Value("${trash.remotePath}")
    public String remotePath;
    @Autowired
    private GarCarServer garCarServer;
    @Autowired
    private GarOrderMatchHandlerService garOrderMatchHandlerService;
    @Autowired
    private IDropPointInfoService dropPointInfoService;
    @Autowired
    private com.trash.common.config.trashConfig trashConfig;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String saveOrder(OrderDto dto) {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        GarOrder order = new GarOrder();
        // companyId
        BeanUtils.copyProperties(dto, order);
        order.setGarOrderUserId(userId);
        order.setGarOrderHandlerStatus(GlobalStatus.GarOrderStatus.NEW_ORDER.getValue());
        order.setGarCancelFlag(GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
        order.setGarOrderScanHandlerFlag(GlobalStatus.GarOrderStatus.SCAN_HANDLER_NO.getValue());
        // 预估车辆等于用户选择得车辆
        order.setGarRealCarCount(dto.getGarCarInfoList().stream().mapToInt(OrderDto.CarInfo::getGarOrderCarNumber).sum());
        order.setGarTimeOutFlag(GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_NO.getValue());

        save(order);

        // 保存车辆信息
        List<OrderDto.CarInfo> garCarInfoList = dto.getGarCarInfoList();
        List<GarOrderCar> garOrderCars = new ArrayList<>();
        for (OrderDto.CarInfo carInfo : garCarInfoList) {
            for (int index = 0; index < carInfo.getGarOrderCarNumber(); index++) {
                GarOrderCar car = new GarOrderCar();
                car.setGarOrderCarType(carInfo.getGarOrderCarType());
                car.setGarOrderId(order.getGarOrderId());
                car.setCarId(carInfo.getId());
                car.setContainerVolume(carInfo.getContainerVolume());
                car.setGarOrderCarUserType(GlobalStatus.GarOrderStatus.PLAN_CAR_TYPE.getValue());
                garOrderCars.add(car);
            }
        }
        garOrderCarService.saveBatch(garOrderCars);

        // 保存图片url
        List<String> imageUrls = dto.getImageUrls();
        List<GarOrderImage> images = new ArrayList<>(imageUrls.size());
        for (String imageUrl : imageUrls) {
            GarOrderImage image = new GarOrderImage();
            image.setGarOrderId(order.getGarOrderId());
            image.setGarOrderImageUrl(imageUrl);
            image.setGarOrderImageType(GlobalStatus.GarOrderStatus.IMAGE_TYPE_CURRENT.getValue());
            images.add(image);
        }
        garOrderImageService.saveBatch(images);
        // TODO 短信提醒 居民下单
        String content = "【装修垃圾清运】订单提醒：您有新的清运订单" + order.getGarOrderId() + "，请及时处理！用户联系方式" + order.getGarOrderContactTel() + "！";
        smsUtils.sendMessage(order.getGarOrderCompanyTel(), content);
        return order.getGarOrderId();
    }

    @Override
    public OrderDetailVo queryOrderDetail(String id) {
        GarUser user = garUserService.getById(SecurityUtils.getLoginUser().getUser().getUserId());
        OrderDetailVo orderDetailVo = null;
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription())
                || user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription())) {
            orderDetailVo = getOrderDetailVoResponsible(id, user);
        }
        //  订单分发获取 驾驶员
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DRIVER_USER.getDescription())) {
            orderDetailVo = getOrderDetailVoDriver(id, user);
        }

        if (Objects.equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription(), user.getGarUserType()) && Objects.nonNull(orderDetailVo)) {
            //查询是否有用户评价
            GarOrderEvaluate evaluate = new GarOrderEvaluate();
            evaluate.setGarOrderId(id);
            int count = garOrderEvaluateService.countId(evaluate);

            orderDetailVo.setHaveEvaluateOfClient(count == 0 ? 0 : 1);
        }

        if (Objects.nonNull(orderDetailVo)) {
            return orderDetailVo;
        }

        throw new BizException(ResultCode.CODE_500, "没有当前角色");
    }

    private OrderDetailVo getOrderDetailVoDriver(String orderId, GarUser user) {
        LambdaQueryWrapper<GarOrderImage> qwi = new LambdaQueryWrapper<>();
        qwi.eq(GarOrderImage::getGarOrderId, orderId)
                .eq(GarOrderImage::getGarCreateBy, user.getGarUserId());

        OrderDetailVo vo = new OrderDetailVo();
        GarOrderDriverVo orderVo = baseMapper.queryOrderByTelWithType(user.getGarUserTel(), orderId, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
        vo.setHandleFlag(true);
        BeanUtils.copyProperties(orderVo, vo);
        // 获取图片
        List<GarOrderImage> imageAll = new ArrayList<>();

        List<GarOrderImage> currentImageList = garOrderImageService.list(new LambdaQueryWrapper<GarOrderImage>()
                .eq(GarOrderImage::getGarOrderId, orderId)
                .eq(GarOrderImage::getGarOrderImageType, GlobalStatus.GarOrderStatus.IMAGE_TYPE_CURRENT.getValue()));
        imageAll.addAll(garOrderImageService.list(qwi));


        imageAll.addAll(currentImageList);
        for (GarOrderImage image : imageAll) {
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_CURRENT.getValue().equals(image.getGarOrderImageType())) {
                vo.getCurrentImages().add(image.getGarOrderImageUrl());
            }

            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_ON.getValue().equals(image.getGarOrderImageType())) {
                SimpleDateFormat date = new SimpleDateFormat("HHmmss");
                String imageDate = date.format(image.getGarCreateTime());
                String garCreateBy = image.getGarCreateBy();
                GarUser byId = garUserService.getById(garCreateBy);
                String garUserName = byId.getGarUserName();
                vo.getPutOnImages().add(image.getGarOrderImageUrl() + imageDate + "name" + garUserName);
            }
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_DOWN.getValue().equals(image.getGarOrderImageType())) {
                vo.getPutDownImages().add(image.getGarOrderImageUrl());
            }
        }
        // 获取车辆信息
        LambdaQueryWrapper<GarOrderCar> qwc = new LambdaQueryWrapper<>();
        qwc.eq(GarOrderCar::getGarOrderId, orderVo.getGarOrderId());
        List<GarOrderCar> carList = garOrderCarService.list(qwc);
        vo.setGarCarInfoList(carList);

        List<GarOrderMatchDisposal> disposals = garOrderMatchDisposalService.queryDisposalListByOrderId(orderId);
        if (CollectionUtil.isNotEmpty(disposals)) {
            Set<String> tels = disposals.stream().map(GarOrderMatchDisposal::getGarOrderDisposalTel).collect(Collectors.toSet());
            vo.setDisposalSites(queryDisposalSiteVo(tels));
        }

        return vo;
    }

    /***
     *
     * 根据电话号码查询处置场所信息
     * @author liujun
     * @date 2024/6/18 11:31
     * @param tels
     * @return java.util.List<com.trash.garbage.pojo.vo.DisposalSiteVo>
     */
    private List<DisposalSiteVo> queryDisposalSiteVo(Collection<String> tels) {
        if (CollectionUtils.isEmpty(tels)) {
            return Collections.emptyList();
        }
        List<DisposalSiteEntity> entities = disposalSiteService.queryDisposalSiteByTelPhone(tels);
        if (CollectionUtils.isEmpty(entities)) {
            return Collections.emptyList();
        }
        return entities.stream().map(en -> {
            if (Objects.isNull(en)) {
                return null;
            }
            DisposalSiteVo vo = new DisposalSiteVo();
            BeanUtils.copyProperties(en, vo);
            // vo.setLongitude(en.getLongitude());
            return vo;
        }).filter(obj -> Objects.nonNull(obj)).collect(Collectors.toList());
    }

    private OrderDetailVo getOrderDetailVoResponsible(String id, GarUser user) {
        GarOrder order = this.getById(id);
        LambdaQueryWrapper<GarOrderImage> qwi = new LambdaQueryWrapper<>();
        qwi.eq(GarOrderImage::getGarOrderId, id);
        OrderDetailVo vo = new OrderDetailVo();
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription())) {
            vo.setHandleFlag(true);
        }
        BeanUtils.copyProperties(order, vo);
        // 获取图片
        List<GarOrderImage> imageList = garOrderImageService.list(qwi);
        for (GarOrderImage image : imageList) {
            if (GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue().equals(image.getGarOrderImageType())) {
                vo.getCurrentImages().add(image.getGarOrderImageUrl());
            }
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_ON.getValue().equals(image.getGarOrderImageType())) {
                SimpleDateFormat date = new SimpleDateFormat("HHmmss");
                String imageDate = date.format(image.getGarCreateTime());
                String garCreateBy = image.getGarCreateBy();
                GarUser byId = garUserService.getById(garCreateBy);
                String garUserName = byId.getGarUserName();
                vo.getPutOnImages().add(image.getGarOrderImageUrl() + imageDate + "name" + garUserName);
            }
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_DOWN.getValue().equals(image.getGarOrderImageType())) {
                vo.getPutDownImages().add(image.getGarOrderImageUrl());
            }
        }
        // 获取车辆信息
        LambdaQueryWrapper<GarOrderCar> qwc = new LambdaQueryWrapper<>();
        qwc.eq(GarOrderCar::getGarOrderId, order.getGarOrderId());
        List<GarOrderCar> carList = garOrderCarService.list(qwc);
        vo.setGarCarInfoList(carList);

        List<GarOrderMatchDisposal> disposals = garOrderMatchDisposalService.queryDisposalListByOrderId(id);
        if (CollectionUtil.isNotEmpty(disposals)) {
            Set<String> tels = disposals.stream().map(GarOrderMatchDisposal::getGarOrderDisposalTel).collect(Collectors.toSet());
            vo.setDisposalSites(queryDisposalSiteVo(tels));
        }


        return vo;
    }

    @Override
    public PageInfo queryOrderList(Integer type, Integer evaluateFlag, Integer pageNo, Integer pageSize) {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        GarUser user = garUserService.getById(userId);
        // 用户
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription())) {
            LambdaQueryWrapper<GarOrder> qw = new LambdaQueryWrapper<>();
            qw.orderByDesc(GarOrder::getGarCreateTime, GarOrder::getGarOrderHandlerStatus);
            qw.eq(GarOrder::getGarOrderUserId, userId);
            PageHelper.startPage(pageNo, pageSize);
            // 待清运 || 清运中 || 已完成 || 待评价
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                qw.eq(GarOrder::getGarCancelFlag, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue())
                        .eq(GarOrder::getGarOrderHandlerStatus, type);
                if (evaluateFlag != null) {
                    qw.eq(GarOrder::getGarEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue())
                            .eq(GarOrder::getGarTimeOutFlag, GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_NO.getValue());
                }
                List<GarOrder> orderList = list(qw);
                PageInfo<GarOrder> pageInfo = new PageInfo<GarOrder>(orderList, pageSize);
                return pageInfo;
            }

            // 全部
            if (GlobalStatus.GarOrderStatus.ALL_ORDER.getValue().equals(type)) {
                List<GarOrder> orderList = list(qw);
                PageInfo<GarOrder> pageInfo = new PageInfo<GarOrder>(orderList, pageSize);
                return pageInfo;
            }
        }
        // 驾驶员
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DRIVER_USER.getDescription())) {
            PageHelper.startPage(pageNo, pageSize);
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                List<GarOrderDriverVo> orderList = baseMapper.queryDriverOrderListByTelWithType(user.getGarUserTel(), type, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                PageInfo<GarOrderDriverVo> pageInfo = new PageInfo<GarOrderDriverVo>(orderList, pageSize);
                return pageInfo;
            }
            // 全部
            if (GlobalStatus.GarOrderStatus.ALL_ORDER.getValue().equals(type)) {
                List<GarOrderDriverVo> orderList = baseMapper.queryDriverOrderListByTelWithType(user.getGarUserTel(), null, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                PageInfo<GarOrderDriverVo> pageInfo = new PageInfo<GarOrderDriverVo>(orderList, pageSize);
                return pageInfo;
            }
        }
        // 企业负责人
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription())) {
            PageHelper.startPage(pageNo, pageSize);
            LambdaQueryWrapper<GarOrder> qw = new LambdaQueryWrapper<>();
            qw.orderByDesc(GarOrder::getGarCreateTime, GarOrder::getGarOrderHandlerStatus);
            qw.eq(GarOrder::getGarOrderCompanyTel, user.getGarUserTel());
            // 待清运 || 清运中 || 已完成 || 待评价
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                qw.eq(GarOrder::getGarCancelFlag, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue())
                        .eq(GarOrder::getGarOrderHandlerStatus, type);
                if (evaluateFlag != null) {
                    qw.eq(GarOrder::getGarHandlerEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue())
                            .eq(GarOrder::getGarTimeOutFlag, GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_NO.getValue());
                }
                List<GarOrder> orderList = list(qw);
                orderList = queryHaveEvaluateOfClient(orderList, GlobalStatus.GarOrderStatus.EVALUATE_TYPE_COMPANY.getValue());
                PageInfo<GarOrder> pageInfo = new PageInfo<GarOrder>(orderList, pageSize);
                return pageInfo;
            }
            // 全部
            if (GlobalStatus.GarOrderStatus.ALL_ORDER.getValue().equals(type)) {
                List<GarOrder> orderList = baseMapper.selectList(qw);
                orderList = queryHaveEvaluateOfClient(orderList, GlobalStatus.GarOrderStatus.EVALUATE_TYPE_COMPANY.getValue());
                PageInfo<GarOrder> pageInfo = new PageInfo<GarOrder>(orderList, pageSize);
                return pageInfo;
            }
        }
        // 处置场所
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DISPOSAL_SITE_USER.getDescription())) {
            PageHelper.startPage(pageNo, pageSize);
            if (GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                List<GarOrderDisposalVo> orderList = baseMapper.queryDisposalOrderListByTelWithType(user.getGarUserTel(), type, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
//                orderList.forEach(GarOrderDisposalVo::adjustCarCount);
                PageInfo<GarOrderDisposalVo> pageInfo = new PageInfo<GarOrderDisposalVo>(orderList, pageSize);
                return pageInfo;
            }
        }
        return null;
    }

    /***
     * 查询有无评价信息
     *
     * @author liujun
     * @date 2024/6/21 9:08
     * @param orders 订单数据
     */
    private List<GarOrder> queryHaveEvaluateOfClient(List<GarOrder> orders, Integer type) {
        if (CollectionUtils.isEmpty(orders)) {
            return orders;
        }
        Set<String> orderIds = orders.stream().map(GarOrder::getGarOrderId).collect(Collectors.toSet());
        List<GarOrderEvaluate> garOrderEvaluates = garOrderEvaluateService.countIdGroupByOrderId(orderIds, type);
        if (CollectionUtils.isEmpty(garOrderEvaluates)) {
            return orders;
        }

        return orders.stream().map(o -> {
            if (Objects.nonNull(o)) {
                Optional<GarOrderEvaluate> optional = garOrderEvaluates.stream().filter(go -> Objects.equals(go.getGarOrderId(), o.getGarOrderId())).findFirst();
                if (optional.isPresent()) {
                    o.setHaveEvaluateOfClient(optional.get().getCountTheNumber() > 0 ? 1 : 0);
                }
            }
            return o;
        }).collect(Collectors.toList());
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String updateOrder(OrderUpdateDto dto) {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        GarUser user = garUserService.getById(userId);
        // 处理用户订单 居民用户 | 企业负责人
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription())
                || user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription())) {
            return handlerOrderStatus(dto, user);
        }
        // 处理分发订单 驾驶员
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DRIVER_USER.getDescription())) {
            // TODO 驾驶员
            return handlerDispatchOrderStatus(dto, user);
        }
        //
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DISPOSAL_SITE_USER.getDescription())) {
            // TODO 处理场所负责人
            return handlerDisposalSiteOrderStatus(dto, user);
        }
        throw new BizException(ResultCode.CODE_500);

    }

    private String handlerDisposalSiteOrderStatus(OrderUpdateDto dto, GarUser user) {
        // 完成订单
        GarOrder order = getById(dto.getGarOrderId());
        // TODO 发送短信  通知企业和用户 修改订单状态为完成 disposal 和 handler表的状态一起修改
        String message = "【装修垃圾清运】订单提醒：您的预约的清运订单" + order.getGarOrderId() + "已完成，可前往【智慧渣管APP】确认并评价，感谢您的使用！";
        smsUtils.sendMessage(order.getGarOrderContactTel(), message);
//        smsUtils.sendMessage(order.getGarOrderCompanyTel(), "【装修垃圾清运】订单提醒：您的预约的清运订单"+order.getGarOrderId()+"已完成，可前往【智慧渣管APP】确认并评价，感谢您的使用！");
        successOrder(order);
        redisCache.deleteObject(order.getGarOrderId());
        // TODO 用户消息通知 订单菜单消息
        userOrderMessageSend(order, message);
        return "当前订单已完成";
    }

    private boolean checkCode(String code, String orderId, String userId) {
        if (StringUtils.isNotBlank(code)) {
            String validCode = redisCache.getCacheMapValue(orderId, userId);
            return code.equals(validCode);
        }
        return false;
    }


    @Deprecated
    private String handlerDispatchOrderStatus(OrderUpdateDto dto, GarUser user) {
        GarOrderDriverVo order = baseMapper.queryOrderByTelWithType(user.getGarUserTel(), dto.getGarOrderId(), GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
        String tel = user.getGarUserTel();
        // 公司所属 待清运- 》 清运中
        // 接受订单的时候把自己的id更新到handler表中
        if (order.getGarOrderHandlerStatus().equals(GlobalStatus.GarOrderStatus.NEW_ORDER.getValue())
                || GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(dto.getHandleType())) {
            LambdaUpdateWrapper<GarOrderMatchHandler> uw = new LambdaUpdateWrapper<>();
            uw.eq(GarOrderMatchHandler::getGarOrderId, dto.getGarOrderId())
                    .eq(GarOrderMatchHandler::getGarOrderHandlerTel, tel)
                    .set(GarOrderMatchHandler::getGarOrderHandlerStatus, GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue())
                    .set(GarOrderMatchHandler::getGarOrderHandlerId, user.getGarUserId());
            handlerService.update(uw);
            return "已接受订单";
        }
        throw new BizException(ResultCode.CODE_500);
    }

    private String handlerOrderStatus(OrderUpdateDto dto, GarUser user) {
        GarOrder order = getById(dto.getGarOrderId());
        // 取消订单公用
        if (GlobalStatus.GarOrderStatus.CANCEL_FLAG_YES.getValue().equals(dto.getGarCancelFlag())) {
            LambdaUpdateWrapper<GarOrder> uw = new LambdaUpdateWrapper<>();
            uw.set(GarOrder::getGarCancelFlag, dto.getGarCancelFlag())
                    .eq(GarOrder::getGarOrderId, dto.getGarOrderId())
                    .set(GarOrder::getGarReason, dto.getGarReason());
            update(uw);
            // TODO 短信提醒  公司 | 居民
            String tel = GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription().equals(user.getGarUserType()) ?
                    order.getGarOrderCompanyTel() : order.getGarOrderContactTel();
            String message = GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription().equals(user.getGarUserType()) ?
                    "【装修垃圾清运】订单提醒：您的待清运订单" + order.getGarOrderId() + "已被取消，详情请登录【智慧渣管APP】查看！" : "【装修垃圾清运】订单提醒：您的预约清运订单" + order.getGarOrderId() + "已被取消，详情请登录【智慧渣管APP】查看！";
            smsUtils.sendMessage(tel, message);
            // TODO 用户消息通知 订单菜单消息
            userOrderMessageSend(order, message);
            return "订单取消成功";
        }
        // 用户修改
        else if (GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription().equals(user.getGarUserType()) && dto.getUpdated()) {
            // TODO 待优化   可能出现线程安全 需要上锁
            if (order.getGarOrderScanHandlerFlag().equals(GlobalStatus.GarOrderStatus.SCAN_HANDLER_YES.getValue())) {
                throw new BizException(ResultCode.CODE_400, "当前订单无法修改，因为已有驾驶员确认");
            }
            // 删除之前的车辆数
            LambdaQueryWrapper<GarOrderCar> qw = new LambdaQueryWrapper<>();
            qw.eq(GarOrderCar::getGarOrderId, dto.getGarOrderId());
            garOrderCarService.remove(qw);
            // 保存车辆信息
            List<OrderDto.CarInfo> garCarInfoList = dto.getGarCarInfoList();
            List<GarOrderCar> garOrderCars = new ArrayList<>();
            for (OrderDto.CarInfo carInfo : garCarInfoList) {
                for (int index = 0; index < carInfo.getGarOrderCarNumber(); index++) {
                    GarOrderCar car = new GarOrderCar();
                    car.setGarOrderCarType(carInfo.getGarOrderCarType());
                    car.setGarOrderId(dto.getGarOrderId());
                    car.setContainerVolume(carInfo.getContainerVolume());
                    car.setCarId(carInfo.getId());
                    car.setGarOrderCarUserType(GlobalStatus.GarOrderStatus.REAL_CAR_TYPE.getValue());
                    garOrderCars.add(car);
                }
            }
            garOrderCarService.saveBatch(garOrderCars);
            order.setGarRealCarCount(garOrderCars.size());
            updateById(order);
            // TODO  发送短信用户修改订单了
            String message = "您的清运订单有修改，请及时查看并处理!";
            smsUtils.sendMessage(dto.getGarOrderCompanyTel(), message);
            // TODO 用户消息通知 订单菜单消息
            userOrderMessageSend(order, message);
            return "修改成功";
        }
        // 企业负责人 清运-》完成
        else if (GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription().equals(user.getGarUserType())) {
            // 公司所属 待清运- 》 清运中
            if (order.getGarOrderHandlerStatus().equals(GlobalStatus.GarOrderStatus.NEW_ORDER.getValue())
                    || GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(dto.getHandleType())) {
                LambdaUpdateWrapper<GarOrder> uw = new LambdaUpdateWrapper<>();
                uw.eq(GarOrder::getGarOrderId, dto.getGarOrderId())
                        .set(GarOrder::getGarOrderHandlerStatus, GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue())
                        .set(GarOrder::getGarOrderCompanyUserId, user.getGarUserId());
                update(uw);
                // TODO 短信提醒
                String message = "【装修垃圾清运】订单提醒：您的预约清运订单" + order.getGarOrderId() + "已被" + order.getGarOrderCompanyName() + "公司接收，详情请登录【智慧渣管APP】查看！企业服务电话！";
                smsUtils.sendMessage(order.getGarOrderContactTel(), message);
                // TODO 用户消息通知 订单菜单消息
                userOrderMessageSend(order, message);
                return "已接受订单";
            }
            // 企业负责人 清运中 ==》已完成
            if (GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(order.getGarOrderHandlerStatus())
                    && GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(dto.getHandleType())) {
                LambdaUpdateWrapper<GarOrder> uw = new LambdaUpdateWrapper<>();
                uw.eq(GarOrder::getGarOrderId, dto.getGarOrderId())
                        .set(GarOrder::getGarOrderHandlerStatus, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue())
                        .set(GarOrder::getGarHandlerEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue())
                        .set(GarOrder::getGarEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue());
                update(uw);
                smsUtils.sendMessage(order.getGarOrderContactTel(), "【装修垃圾清运】订单提醒：您的预约的清运订单" + order.getGarOrderId() + "已完成，可前往【智慧渣管APP】确认并评价，感谢您的使用！");
                smsUtils.sendMessage(order.getGarOrderCompanyTel(), "【装修垃圾清运】订单提醒：您的预约的清运订单" + order.getGarOrderId() + "已完成，可前往【智慧渣管APP】确认，感谢您的使用！");
                // 更新disposal
                LambdaUpdateWrapper<GarOrderMatchDisposal> uwd = new LambdaUpdateWrapper<>();
                uwd.eq(GarOrderMatchDisposal::getGarOrderId, dto.getGarOrderId())
                        .set(GarOrderMatchDisposal::getGarOrderDisposalStatus, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
                disposalService.update(uwd);
                // 更新handler
                LambdaUpdateWrapper<GarOrderMatchHandler> uwh = new LambdaUpdateWrapper<>();
                uwh.eq(GarOrderMatchHandler::getGarOrderId, dto.getGarOrderId())
                        .set(GarOrderMatchHandler::getGarOrderHandlerStatus, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
                handlerService.update(uwh);
            }
            // TODO 短信提醒
            String message = "运输公司已完成订单号为 " + order.getGarOrderId() + " 的订单。";
            smsUtils.sendMessage(order.getGarOrderContactTel(), message);
            // TODO 用户消息通知 订单菜单消息
            userOrderMessageSend(order, message);
            return "订单已完成";
        }

        throw new BizException(ResultCode.CODE_400);
    }

    private void userOrderMessageSend(GarOrder order, String message) {
        GarUserOrderMessage guom = new GarUserOrderMessage();
        guom.setGarMessageState(GlobalStatus.GarUserStatusEnum.ORDER_MESSAGE_UNREAD.getStatus());
        guom.setGarContent(message);
        guom.setGarUserId(order.getGarCreateBy());
        guom.setGarUserTel(order.getGarOrderContactTel());
        orderMessageService.save(guom);
    }

    @Override
    @Transactional
    public String uploadImageUrlByType(UploadDto dto) {
        String GarOrderAskId = "";
        GarOrder order = getById(dto.getGarOrderId());
        //判断是否已开始装车
        if (dto.getType() == 1) {
            if (order.getGarAskStatus() == null || !order.getGarAskStatus().equals("1")) {
                //修改是否已开始装车状态，为已装车
                order.setGarAskStatus("1");
                updateById(order);

                OrderDetailVo orderDetailVo = this.queryOrderDetail(dto.getGarOrderId());
                //上传装车图片生成订单关联台账

                for (int i = 0; i < order.getGarRealCarCount(); i++) {
                    //新增趟次关联台账
                    GarOrderMatchAsk garOrderMatchAsk = new GarOrderMatchAsk();
                    garOrderMatchAsk.setGarOrderPhone(orderDetailVo.getGarOrderContactTel());
                    garOrderMatchAsk.setGarOrderName(orderDetailVo.getGarOrderContactName());
                    // 查询当前日期+行政区划代码的流水编号
                    garOrderMatchAsk.setGarOrderNumber(generateAssociationNumber(order.getGarOrderAddress()));
                    garOrderMatchAsk.setGarOrderId(dto.getGarOrderId());
                    garOrderMatchAsk.setGarOrderTime(order.getGarCreateTime());


                    //获取处置场所
                    List<GarOrderMatchDisposal> disposalList = garOrderMatchDisposalService.queryObjByOrderId(dto.getGarOrderId());
                    garOrderMatchAsk.setDisposalId(disposalList.get(0).getGarOrderDisposalCompanyId());
                    garOrderMatchAsk.setDisposalSiteName(disposalList.get(0).getGarOrderDisposalCompanyName());

                    List<DropPointInfo> dropPointInfoList = dropPointInfoService.selectDropPointInfoListByPhone(garOrderMatchAsk.getGarOrderPhone());

                    if (!dropPointInfoList.isEmpty()) {

                        garOrderMatchAsk.setDropPointId(Integer.parseInt(dropPointInfoList.get(0).getId().toString()));
                        garOrderMatchAsk.setDropPointName(dropPointInfoList.get(0).getDropPointName());
                    }
                    garOrderMatchAsk.setDropAddress(order.getGarOrderAddress()+order.getGarOrderAddressDetails());
                    garOrderMatchAsk.setGarCreateBy(dto.getDriver());
                    askService.save(garOrderMatchAsk);
                }
            }

            LambdaQueryWrapper<GarOrderMatchAsk> qw = new LambdaQueryWrapper<>();
            qw.eq(GarOrderMatchAsk::getGarOrderId, dto.getGarOrderId());
            List<GarOrderMatchAsk> askList = askService.list(qw);
            for (GarOrderMatchAsk garOrderMatchAsk : askList) {
                //每次只判断一次
                if(garOrderMatchAsk.getGarOrderType()==null && garOrderMatchAsk.getLoadingLonLat()==null){
                    //判断车辆上传装车图片时是否在投放点区域内
                    garOrderAssociationServiceAsync.isWithinDropPointCoordinates(dto.getCarPlate(), garOrderMatchAsk, dto, order);
                    break;
                }
            }
            int dropCarNum = 0;
            for (GarOrderMatchAsk garOrderMatchAsk : askList) {
                //判断该车是否已经结束上一趟次的配送
                if(garOrderMatchAsk.getGarCarCode()!=null && garOrderMatchAsk.getGarCarCode().equals(dto.getCarPlate()) && garOrderMatchAsk.getGarUpdateTime() == null){
                    break;
                }
                //每次只判断一次
                if(garOrderMatchAsk.getGarCarCode()==null && garOrderMatchAsk.getGarUpdateTime() == null){
                    garOrderMatchAsk.setDropCarNum(++dropCarNum);
                    garOrderMatchAsk.setGarCreateTime(new Date());
                    garOrderMatchAsk.setGarCarCode(dto.getCarPlate());
                    GarOrderAskId = garOrderMatchAsk.getGarOrderNumber();
                    askService.updateById(garOrderMatchAsk);
                    break;
                }
                dropCarNum = garOrderMatchAsk.getDropCarNum();
            }

        }

        List<GarOrderImage> garOrderImages = new ArrayList<>(dto.getImageUrls().size());
        for (String imageUrl : dto.getImageUrls()) {
            GarOrderImage orderImage = new GarOrderImage();
            orderImage.setGarOrderAskId(GarOrderAskId);
            orderImage.setGarOrderId(dto.getGarOrderId());
            orderImage.setGarOrderImageUrl(imageUrl);
            orderImage.setGarOrderImageType(dto.getType());
            garOrderImages.add(orderImage);
        }

        garOrderImageService.saveBatch(garOrderImages);
        return "上传成功！";
    }

    public String generateAssociationNumber(String garOrderAddress) {
        String token = trashConfig.getToken();
        if (!token.contains("Bearer")){
            token = "Bearer " + token;
        }
        String data = RemoteServerUtils.getAreasList(token);
        JSONArray jsonArray = JSON.parseArray(data);
        String[] address = garOrderAddress.split("-");
        String code = "430104";
        for (int i = 0; i < jsonArray.size(); i++) {
            JSONObject jsonObject = (JSONObject) jsonArray.get(i);
            if (jsonObject.getString("name").equals(address[2])) {
                code = jsonObject.getString("code");
            }
        }
        // 获取当前日期，格式为YYYYMMDD
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
        String associationNumber = dateFormat.format(new Date()) + code;
        // 查询当前日期+行政区划代码的流水编号
        LambdaQueryWrapper<GarOrderMatchAsk> qw = new LambdaQueryWrapper<>();
        qw.likeRight(GarOrderMatchAsk::getGarOrderNumber, associationNumber);
        int sequenceNumber = askService.list(qw).size();
        // 流水编号自增
        sequenceNumber++;
        // 组合生成最终的编号
        associationNumber = associationNumber + String.format("%06d", sequenceNumber); // 保证6位数字，不足前面补0

        return associationNumber;
    }

    @Override
    public String evaluateOrder(EvaluateDto dto) {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        GarUser user = garUserService.getById(userId);
        GarOrder order = getById(dto.getOrderId());
        if (GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(order.getGarOrderHandlerStatus())) {
            evaluate(dto, order, user);
        }
        return "已评价";
    }

    @Override
    public List<GarOrder> queryOrderListByGarOrder(GarOrder garOrder) {
        LambdaQueryWrapper<GarOrder> qw = createQueryWrapper(garOrder);
        return list(qw);
    }

    private LambdaQueryWrapper<GarOrder> createQueryWrapper(GarOrder garOrder) {
        return new LambdaQueryWrapper<GarOrder>()
                .eq(StringUtils.isNotEmpty(garOrder.getGarOrderAddress()), GarOrder::getGarOrderAddress, garOrder.getGarOrderAddress())
                .eq(!Objects.isNull(garOrder.getGarCancelFlag()), GarOrder::getGarCancelFlag, garOrder.getGarCancelFlag())
                .eq(!Objects.isNull(garOrder.getGarOrderHandlerStatus()), GarOrder::getGarOrderHandlerStatus, garOrder.getGarOrderHandlerStatus())
                .eq(!Objects.isNull(garOrder.getGarEvaluateFlag()), GarOrder::getGarEvaluateFlag, garOrder.getGarEvaluateFlag());
    }

    @Override
    public PageInfo queryOrderListByGarOrderPage(OrderWebDto dto) {
        LambdaQueryWrapper<GarOrder> qw = new LambdaQueryWrapper<>();
        qw.like(StringUtils.isNotEmpty(dto.getGarOrderCompanyName()), GarOrder::getGarOrderCompanyName, dto.getGarOrderCompanyName())
                .eq(dto.getGarOrderHandlerStatus() != null, GarOrder::getGarOrderHandlerStatus, dto.getGarOrderHandlerStatus())
                .eq(dto.getGarCancelFlag() != null, GarOrder::getGarCancelFlag, dto.getGarCancelFlag())
                .orderByDesc(GarOrder::getGarOrderAgreementTime); // 添加按创建时间倒序排序
        List<GarOrder> list = list(qw);
        PageInfo<GarOrder> pageInfo = new PageInfo<>(list);
        return pageInfo;
    }

    @Override
    public OrderDetailVo queryOrderWebDetail(String id) {
        GarOrder order = this.getById(id);
        LambdaQueryWrapper<GarOrderImage> qwi = new LambdaQueryWrapper<>();
        qwi.eq(GarOrderImage::getGarOrderId, id);
        OrderDetailVo vo = new OrderDetailVo();
        List<DriverVo> driverVos = null;
        BeanUtils.copyProperties(order, vo);
        List<GarOrderImage> imageList = garOrderImageService.list(qwi);
        for (GarOrderImage image : imageList) {
            if (GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue().equals(image.getGarOrderImageType())) {
                vo.getCurrentImages().add(image.getGarOrderImageUrl());
            }
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_ON.getValue().equals(image.getGarOrderImageType())) {
                vo.getPutOnImages().add(image.getGarOrderImageUrl());
            }
            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_PUT_DOWN.getValue().equals(image.getGarOrderImageType())) {
                vo.getPutDownImages().add(image.getGarOrderImageUrl());
            }

            if (GlobalStatus.GarOrderStatus.IMAGE_TYPE_FILL_CAR.getValue().equals(image.getGarOrderImageType())) {
                if (Objects.isNull(vo.getPanoramas())) {
                    vo.setPanoramas(new ArrayList<>());
                }
                vo.getPanoramas().add(image.getGarOrderImageUrl());
            }
        }
        if (StringUtils.isNotEmpty(vo.getGarOrderHandlerId())) {
            GarUser handleUser = garUserService.getById(vo.getGarOrderHandlerId());
            DriverVo driverVo = new DriverVo();
            driverVo.setPhoneNo(handleUser.getGarUserTel());
            driverVos = driverService.selectDriverList(driverVo);
            if (CollectionUtil.isNotEmpty(driverVos)) {
                vo.setGarOrderHandleName(driverVos.get(0).getName());
                vo.setGarOrderHandleTel(driverVos.get(0).getPhoneNo());
            }
        } else {
            List<GarOrderMatchHandler> matchHandlers = handlerService.queryByOrderId(id);
            int size = CollectionUtils.size(matchHandlers);
            if (size > 0) {
                Set<OrderDriver> orderDrivers = new LinkedHashSet<>();
                for (int i = 0; i < size; i++) {
                    DriverVo driverVo = new DriverVo();
                    driverVo.setPhoneNo(matchHandlers.get(i).getGarOrderHandlerTel());
                    driverVos = driverService.selectDriverList(driverVo);
                    if (CollectionUtil.isNotEmpty(driverVos)) {
                        OrderDriver od = new OrderDriver();
                        od.setDriverName(driverVos.get(0).getName());
                        od.setDriverPhone(driverVos.get(0).getPhoneNo());
                        orderDrivers.add(od);
                    }
                }
                vo.setOrderDrivers(orderDrivers);
            }
        }
        // 获取车辆信息
        LambdaQueryWrapper<GarOrderCar> qwc = new LambdaQueryWrapper<>();
        qwc.eq(GarOrderCar::getGarOrderId, id);
        List<GarOrderCar> carList = garOrderCarService.list(qwc);
        if (CollectionUtils.isNotEmpty(carList)) {
            Map<String, List<GarOrderCar>> groupCars = carList.stream().collect(Collectors.groupingBy(GarOrderCar::getGarOrderCarType));
            Set<OrderCarStatistics> orderCarStatistics = new LinkedHashSet<>();
            for (Map.Entry<String, List<GarOrderCar>> entry : groupCars.entrySet()) {
                OrderCarStatistics statistics = new OrderCarStatistics();
                statistics.setCarType(entry.getKey());
                statistics.setNumber(CollectionUtils.size(entry.getValue()));
                orderCarStatistics.add(statistics);
            }
            vo.setOrderCarStatistics(orderCarStatistics);
        }
        vo.setGarCarInfoList(carList);

        List<GarOrderMatchAsk> matchAsks = askService.queryByOrderId(order.getGarOrderId());
        if (CollectionUtils.isNotEmpty(matchAsks)) {
            List<OrderCarReport> orderCarReports = new ArrayList<>();
            for (GarOrderMatchAsk matchAsk : matchAsks) {
                OrderCarReport carReport = new OrderCarReport();
                carReport.setCarNo(matchAsk.getGarHandlerCarCode());
                carReport.setCarWeight(Convert.toStr(matchAsk.getGarCarryingWeight()));
                orderCarReports.add(carReport);
            }
            vo.setCarReports(orderCarReports);
        }

        List<GarOrderMatchDisposal> garOrderMatchDisposals = garOrderMatchDisposalService.queryObjByOrderId(id);
        List<DispatchDisposalVo> dispatchDisposalVos = garOrderMatchDisposalService.requestDisposalListWithDispatch();
        if (CollectionUtils.isNotEmpty(garOrderMatchDisposals) && CollectionUtils.isNotEmpty(garOrderMatchDisposals)) {

            dispatchDisposalVos = dispatchDisposalVos.stream().map(d -> {
                if (CollectionUtils.isNotEmpty(d.getPersonnelInfo())) {
                    boolean flag = false;
                    for (DispatchDisposalVo.Personnel personnel : d.getPersonnelInfo()) {
                        if (Objects.nonNull(personnel)) {
                            for (GarOrderMatchDisposal disposal : garOrderMatchDisposals) {
                                if (StringUtils.equals(disposal.getGarOrderDisposalTel(), personnel.getTel())) {
                                    d.setCheck(true);
                                    flag = true;
                                    break;
                                }
                            }
                            if (flag) {
                                break;
                            }
                        }
                    }
                }
                return d;
            }).filter(d -> d.isCheck()).collect(Collectors.toList());
            List<OrderDisposalCompanyReport> disposalCompanyReports = new ArrayList<>();
            for (DispatchDisposalVo disposalVo : dispatchDisposalVos) {
                OrderDisposalCompanyReport report = new OrderDisposalCompanyReport();
                report.setDisposalCompanyName(disposalVo.getGarOrderDisposalCompanyName());
                if (CollectionUtils.isNotEmpty(disposalVo.getPersonnelInfo())) {
                    report.setTelphone(disposalVo.getPersonnelInfo().get(0).getTel());
                }
                disposalCompanyReports.add(report);
            }
            vo.setOrderDisposalCompanyReports(disposalCompanyReports);

        }


        return vo;
    }

    @Override
    public PageInfo queryEnterpriseList(TransportationEnterprise enterprise) {
        // 1）支持选择企业“所属区域”（长沙市内的）展示区域内所有企业
        // 2）支持选择车辆“车辆类型”展示有该车辆类型的企业
        // TODO 车辆类型暂时不考虑
        List<TransportationEnterprise> list = transportationEnterpriseService.selectTransportationEnterpriseList(enterprise);
        Integer pageNum = ServletUtils.getParameterToInt("pageNum");
        Integer pageSize = ServletUtils.getParameterToInt("pageSize");
        Integer orderByColumn = ServletUtils.getParameterToInt("orderByColumn");
        Comparator<TransportationEnterpriseVo> comparator;
        if (1 == orderByColumn) {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getCleanNumber);
        } else if (2 == orderByColumn) {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getScore);
        } else {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getDistance);
        }
        // 企业id为空说明没有公司
        List<String> enterpriseIds = list.stream().map(TransportationEnterprise::getId).collect(Collectors.toList());
        List<GarOrder> orderList = baseMapper.queryCleanNumberByEnterpriseIds(enterpriseIds, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
        List<GarOrderEvaluate> evaluateList = garOrderEvaluateService.queryEvaluateByEnterpriseIds(enterpriseIds, GlobalStatus.GarOrderStatus.EVALUATE_TYPE_COMPANY.getValue());
        Map<String, List<GarOrderEvaluate>> evaluateMap = new HashMap<>();
        for (GarOrderEvaluate garOrderEvaluate : evaluateList) {
            List<GarOrderEvaluate> evaluate = evaluateMap.get(garOrderEvaluate.getGarCompanyId());
            if (CollectionUtil.isEmpty(evaluate)) {
                evaluateMap.put(garOrderEvaluate.getGarCompanyId(), new ArrayList<>(Arrays.asList(garOrderEvaluate)));
            } else {
                evaluate.add(garOrderEvaluate);
            }
        }
        // 获取当前选中地址计算距离
        LambdaQueryWrapper<GarAddress> qw = new LambdaQueryWrapper<>();
        qw.eq(GarAddress::getGarUserId, SecurityUtils.getLoginUser().getUser().getUserId())
                .eq(GarAddress::getGarUserDefault, GlobalStatus.GarAddressStatus.CURRENT_ADDRESS.getValue());
        GarAddress address = garAddressService.getOne(qw);

        Stream<TransportationEnterpriseVo> stream = list.stream().map(item -> {
            TransportationEnterpriseVo vo = new TransportationEnterpriseVo();
            BeanUtils.copyProperties(item, vo);
            List<GarOrderEvaluate> evaluate = evaluateMap.get(String.valueOf(item.getId()));
            handleCleanNumber(vo, orderList);
            handleScore(vo, evaluate);
            handleDistance(vo, address);
            return vo;
        });
        List<TransportationEnterpriseVo> voList;
        if (orderByColumn != 0) {
            // 降序
            voList = stream.sorted(comparator.reversed()).collect(Collectors.toList());
        } else {
            voList = stream.sorted(comparator).collect(Collectors.toList());
        }
        int total = voList.size();
        int remainder = total % pageSize;
        int currentPage = pageNum > 0 ? (pageNum - 1) * pageSize : pageNum * pageSize;
        // 怕页码超出界限了 超出界限就通过currenPage (3 * 10) > total (25) ? currentPage (20) - (pageSize (10) - remainder (3)) : currentPage
        int startPage = currentPage > total ? currentPage - (pageSize - remainder) : currentPage;
        int endPage = Math.min(startPage + pageSize, total);
        PageInfo<TransportationEnterpriseVo> pageInfo = new PageInfo<>();
        pageInfo.setList(voList.subList(startPage, endPage));
        pageInfo.setTotal(total);
        return pageInfo;
    }


    @Override
    public PageInfo dockingUpEnterpriseList(TransportationEnterprise dto) {
        // 1）支持选择企业"所属区域"（长沙市内的）展示区域内所有企业
        // 2）支持选择车辆"车辆类型"展示有该车辆类型的企业
        // TODO 车辆类型暂时不考虑

        Map<String, String> headers = new HashMap<>();
        headers.put("Authorization", authorization);
        headers.put("Content-Type", contentType);

        String tel = null;
        String areaCode = null;
        String officeAddress = null;
        String name = null; // 添加name变量

        if (StringUtils.isNotEmpty(dto.getServicePhone())) {
            tel = dto.getServicePhone();
        }

        if (StringUtils.isNotEmpty(dto.getRegistrationArea())) {
            officeAddress = dto.getRegistrationArea();
        }

        // 添加对企业名称的处理
        if (StringUtils.isNotEmpty(dto.getName())) {
            name = dto.getName();
        }

        if (StringUtils.isNotEmpty(dto.getRegistrationArea())) {
            try {
                JSONArray jsonArray = garAreaServer.request();
                if (Objects.isNull(jsonArray)) {
                    areaCode = "no found";
                } else {
                    Optional<Object> opt = jsonArray.stream().filter(jo -> {
                        JSONObject jsonObject = (JSONObject) jo;
                        return StringUtils.equals(jsonObject.getString("name"), dto.getRegistrationArea());
                    }).findFirst();
                    if (opt.isPresent()) {
                        areaCode = ((JSONObject) opt.get()).getString("code");
                    } else {
                        areaCode = "no found";
                    }
                }

            } catch (Exception e) {
                log.error("请求的确信息异常", e);
            }
        }

        // 修改这里，将name参数传递给request方法
        List<TransportationEnterprise> list = garTransportationEnterpriseService.request(tel, areaCode, officeAddress, name);

        // 后续代码保持不变...
        if (CollectionUtils.isNotEmpty(list) && StringUtils.isNotEmpty(tel)) {
            String telStr = tel;
            list = list.stream().filter(t -> StringUtils.equals(telStr, t.getServicePhone())).collect(Collectors.toList());
        }

//        saveOrUpdate(list);
        Integer pageNum = ServletUtils.getParameterToInt("pageNum");
        Integer pageSize = ServletUtils.getParameterToInt("pageSize");
        Integer orderByColumn = ServletUtils.getParameterToInt("orderByColumn");
        Comparator<TransportationEnterpriseVo> comparator;
        if (1 == orderByColumn) {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getCleanNumber);
        } else if (2 == orderByColumn) {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getScore);
        } else {
            comparator = Comparator.comparing(TransportationEnterpriseVo::getDistance);
        }
        // 企业id为空说明没有公司
        List<String> enterpriseIds = list.stream().map(TransportationEnterprise::getId).collect(Collectors.toList());
        List<GarOrder> orderList = baseMapper.queryCleanNumberByEnterpriseIds(enterpriseIds, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
        List<GarOrderEvaluate> evaluateList = garOrderEvaluateService.queryEvaluateByEnterpriseIds(enterpriseIds, GlobalStatus.GarOrderStatus.EVALUATE_TYPE_COMPANY.getValue());
        Map<String, List<GarOrderEvaluate>> evaluateMap = new HashMap<>();
        for (GarOrderEvaluate garOrderEvaluate : evaluateList) {
            List<GarOrderEvaluate> evaluate = evaluateMap.get(garOrderEvaluate.getGarCompanyId());
            if (CollectionUtil.isEmpty(evaluate)) {
                evaluateMap.put(garOrderEvaluate.getGarCompanyId(), new ArrayList<>(Arrays.asList(garOrderEvaluate)));
            } else {
                evaluate.add(garOrderEvaluate);
            }
        }
        // 获取当前选中地址计算距离
        LambdaQueryWrapper<GarAddress> qw = new LambdaQueryWrapper<>();
        qw.eq(GarAddress::getGarUserId, SecurityUtils.getLoginUser().getUser().getUserId())
                .eq(GarAddress::getGarUserDefault, GlobalStatus.GarAddressStatus.CURRENT_ADDRESS.getValue());
        GarAddress address = garAddressService.getOne(qw);

        Stream<TransportationEnterpriseVo> stream = list.stream().map(item -> {
            TransportationEnterpriseVo vo = new TransportationEnterpriseVo();
            BeanUtils.copyProperties(item, vo);
            List<GarOrderEvaluate> evaluate = evaluateMap.get(String.valueOf(item.getId()));
            handleCleanNumber(vo, orderList);
            handleScore(vo, evaluate);
            handleDistance(vo, address);
            return vo;
        });
        List<TransportationEnterpriseVo> voList;
        if (orderByColumn != 0) {
            // 降序
            voList = stream.sorted(comparator.reversed()).collect(Collectors.toList());
        } else {
            voList = stream.sorted(comparator).collect(Collectors.toList());
        }
        int total = voList.size();
        int remainder = total % pageSize;
        int currentPage = pageNum > 0 ? (pageNum - 1) * pageSize : pageNum * pageSize;
        // 怕页码超出界限了 超出界限就通过currenPage (3 * 10) > total (25) ? currentPage (20) - (pageSize (10) - remainder (3)) : currentPage
        int startPage = currentPage > total ? currentPage - (pageSize - remainder) : currentPage;
        int endPage = Math.min(startPage + pageSize, total);
        PageInfo<TransportationEnterpriseVo> pageInfo = new PageInfo<>();
        pageInfo.setList(voList.subList(startPage, endPage));
        pageInfo.setTotal(total);
        return pageInfo;
    }

    private void saveOrUpdate(List<TransportationEnterprise> list) {
        if (CollectionUtils.isNotEmpty(list)) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (TransportationEnterprise transportationEnterprise : list) {
                        try {
                            transportationEnterprise.setCarNumber(0);
                            TransportationEnterprise source = transportationEnterpriseService.selectTransportationEnterpriseByIdStr(transportationEnterprise.getId());
                            if (Objects.isNull(source)) {
                                transportationEnterpriseService.save(transportationEnterprise);
                            } else {
                                TransportationEnterprise target = new TransportationEnterprise();
                                BeanUtils.copyProperties(transportationEnterprise, target);
                                TransportationEnterprise source1 = new TransportationEnterprise();
                                source1.setId(source.getId());
                                //transportationEnterprise.setId(jsonObject.get("id").toString());
                                source1.setName(source.getName());
                                source1.setAbbreviation(source.getAbbreviation());
                                source1.setOfficeAddress(source.getOfficeAddress());
                                //  source1.setServicePhone(source.getServicePhone());
                                source1.setLegalRepresentative(source.getLegalRepresentative());
                                source1.setLegalRepresentativePhone(source.getLegalRepresentativePhone());
                                source1.setCarNumber(0);
                                target.setServicePhone(null);

                                if (Objects.equals(JSON.toJSONString(source1), JSON.toJSONString(target))) {
                                    continue;
                                } else {
                                    transportationEnterpriseService.updateById(transportationEnterprise);
                                }
                            }
                        } catch (Exception e) {
                            log.error(e.getMessage(), e);
                        }
                    }
                }
            }).start();
        }
    }


    private void handleDistance(TransportationEnterpriseVo vo, GarAddress address) {
        if (Objects.isNull(vo) || StringUtils.isEmpty(vo.getOfficeAddressGps()) || StringUtils.indexOf(vo.getOfficeAddressGps(), ",") == -1 || Objects.isNull(address)) {
            vo.setDistance(9999999);
            return;
        }
        String[] params = vo.getOfficeAddressGps().split(",");
        double distance = calculateDistance(Double.parseDouble(params[1]), Double.parseDouble(params[0]), address.getGarLatitude(), address.getGarLongitude());
        vo.setDistance(distance);
    }

    private double calculateDistance(double lat1, double lon1, double lat2, double lon2) {
        // 将经纬度转换为弧度
        double lat1Rad = Math.toRadians(lat1);
        double lon1Rad = Math.toRadians(lon1);
        double lat2Rad = Math.toRadians(lat2);
        double lon2Rad = Math.toRadians(lon2);

        // 应用 Haversine 公式计算距离
        double dlon = lon2Rad - lon1Rad;
        double dlat = lat2Rad - lat1Rad;
        double a = Math.sin(dlat / 2) * Math.sin(dlat / 2) +
                Math.cos(lat1Rad) * Math.cos(lat2Rad) *
                        Math.sin(dlon / 2) * Math.sin(dlon / 2);
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        double radius = 6371; // 地球平均半径（单位：公里）
        double distance = radius * c;
        return distance;
    }

    @Override
    public List<GarOrderEvaluate> queryEvaluateDetail(String orderId) {
        //首先查询最近20条数据
        LambdaQueryWrapper<GarOrderEvaluate> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderEvaluate::getGarOrderId, orderId).orderByDesc(GarOrderEvaluate::getGarCreateTime);
        PageHelper.startPage(1, 20, Boolean.FALSE);
        List<GarOrderEvaluate> evaluateList = garOrderEvaluateService.list(qw);

        if (CollectionUtils.isNotEmpty(evaluateList)) {
            //再正序排列评价
            evaluateList.sort(new Comparator<GarOrderEvaluate>() {
                @Override
                public int compare(GarOrderEvaluate o1, GarOrderEvaluate o2) {

                    return Objects.isNull(o1.getGarCreateTime()) || Objects.isNull(o2.getGarCreateTime()) ? 0 : o1.getGarCreateTime().compareTo(o2.getGarCreateTime());
                }
            });
        }
        return evaluateList;
    }

    @Override
    public void dispatchDriverOrders(DispatchDto dto) {
        GarOrder order = getById(dto.getGarOrderId());
        List<GarOrderMatchHandler> handlerList = new ArrayList<>(dto.getDispatchList().size());
        // 已分配 继续下发
//        if (order.getGarOrderScanHandlerFlag().equals(GlobalStatus.GarOrderStatus.SCAN_HANDLER_YES.getValue())) {
        LambdaQueryWrapper<GarOrderMatchHandler> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderMatchHandler::getGarOrderId, order.getGarOrderId());
        Map<String, GarOrderMatchHandler> handlerMap = handlerService.list(qw).stream().collect(Collectors.toMap(item -> item.getGarOrderHandlerTel(), item -> item));
        for (DispatchDto.DispatchDetail dispatchDetail : dto.getDispatchList()) {
            if (handlerMap.containsKey(dispatchDetail.getTel())) {
                continue;
            }
            GarOrderMatchHandler handler = getGarOrderMatchHandler(order, dispatchDetail);
            handlerList.add(handler);
        }
//        }
//        else {
//            for (DispatchDto.DispatchDetail detail : dto.getDispatchList()) {
//                GarOrderMatchHandler handler = getGarOrderMatchHandler(order, detail);
//                handlerList.add(handler);
//            }
//        }
        handlerService.saveBatch(handlerList);
        List<String> tels = handlerList.stream().map(GarOrderMatchHandler::getGarOrderHandlerTel).collect(Collectors.toList());
        // TODO 短信通知
        smsUtils.sendMessage(tels, "【装修垃圾清运】订单提醒：您有新的清运订单" + order.getGarOrderId() + "，请及时处理！用户联系方式" + order.getGarOrderContactTel());
    }

    private GarOrderMatchHandler getGarOrderMatchHandler(GarOrder order, DispatchDto.DispatchDetail detail) {
        GarOrderMatchHandler handler = new GarOrderMatchHandler();
        handler.setGarOrderHandlerTel(detail.getTel());
        handler.setGarOrderHandlerName(detail.getName());
        handler.setGarHandlerCarCode(detail.getCarCode());
        handler.setGarCancelFlag(order.getGarCancelFlag());
        handler.setGarOrderId(order.getGarOrderId());
        handler.setGarOrderHandlerStatus(GlobalStatus.GarOrderStatus.NEW_ORDER.getValue());
        handler.setGarOrderHandlerCompanyName(order.getGarOrderCompanyName());
        handler.setGarOrderHandlerCompanyId(order.getGarOrderCompanyId());
        handler.setGarOrderContainerVolume(detail.getGarOrderContainerVolume());
//        handler.setGarOrderHandlerId(detail.getId());
        handler.setGarOrderStatus(GlobalStatus.GarOrderStatus.DISPATCH_HANDLE_NEW.getValue());
        return handler;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<DispatchDriverVo> queryDispatch(String orderId) {
//        GarOrder order = getById(orderId);
//        order.setGarOrderMatchFlag(GlobalStatus.GarOrderStatus.MATCH_YES.getValue());
//        updateById(order);

        String tel = SecurityUtils.getLoginUser().getUser().getPhonenumber();

        List<TransportationEnterprise> enterprises = garTransportationEnterpriseService.request(tel, null, null, null);
        if (CollectionUtils.isEmpty(enterprises)) {
            return Collections.emptyList();
        }
        enterprises = enterprises.stream().filter(e -> Objects.equals(e.getServicePhone(), tel)).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(enterprises)) {
            return Collections.emptyList();
        }
        List<GarOrderMatchHandler> garOrderCars = garOrderCarService.queryGarOrderMatchHandler(orderId);
        int garOrderCarsLength = CollectionUtils.size(garOrderCars);

        List<DispatchDriverVo> voList = garCarServer.requestDispatchDriverVo(enterprises.get(0).getId());


        if (CollectionUtils.isEmpty(voList)) {
            return Collections.emptyList();
        }
        voList = voList.stream().map(vo -> {
            Collection<DispatchDriverVo.Personnel> ps = vo.getPersonnelInfo();
            if (CollectionUtils.isNotEmpty(ps)) {
                ps = ps.stream().map(p -> {
                    if (garOrderCarsLength > 0) {
                        Optional<GarOrderMatchHandler> optional = garOrderCars.stream().filter(ga -> Objects.equals(ga.getGarOrderHandlerTel(), p.getTel()) && Objects.equals(ga.getGarHandlerCarCode(), vo.getLicensePlateNumber())).findFirst();
                        p.setChecked(optional.isPresent());
                    }
                    return p;
                }).collect(Collectors.toList());
                vo.setPersonnelInfo(ps);
            }
            return vo;
        }).collect(Collectors.toList());
        LambdaQueryWrapper<GarOrderCar> qwc = new LambdaQueryWrapper<>();
        qwc.eq(GarOrderCar::getGarOrderId, orderId);

        List<GarOrderCar> carList = garOrderCarService.list(qwc);
        if (CollectionUtils.isNotEmpty(carList)) {
            Set<String> carTypes = carList.stream().map(GarOrderCar::getGarOrderCarType).collect(Collectors.toSet());
            if (CollectionUtils.isNotEmpty(carTypes)) {
                String[] carTypeStrs = {"4方车", "6方车", "8方车"};
                String[] carTypeStrs1 = {"轻型货车", "中型货车", "中大型货车"};
                int size = carTypeStrs.length;
                for (int i = 0; i < size; i++) {
                    if (carTypes.contains(carTypeStrs[i])) {
                        carTypes.add(carTypeStrs1[i]);
                    }
                }
            }
            voList = voList.stream().filter(v -> carTypes.contains(v.getContainerVolume())).sorted(Comparator.comparing(DispatchDriverVo::getLicensePlateNumber)).sorted(Comparator.comparing(DispatchDriverVo::getSortValue)).collect(Collectors.toList());
//            voList = voList.stream().filter(v -> v.getPersonnelInfo()!=null).collect(Collectors.toList());
        }

        return voList;
    }


//    private List<DispatchDisposalVo> comDis(){
//        Map<String, String> headers = new HashMap<>();
//        headers.put("Authorization", authorization);
//        headers.put("Content-Type", contentType);
//
//        Map<String, Object> params = new HashMap<>();
//        if (Objects.nonNull(carInfo.getCompanyId())) {
//            try {
//                Long companyId = Convert.toLong( carInfo.getCompanyId());
//                if(companyId< 10000){
//                    params.put("companyID", "zxljqy" + carInfo.getCompanyId());
//                }else{
//                    params.put("companyID",  carInfo.getCompanyId());
//                }
//            }catch (Exception e){
//                log.error(e.getMessage());
//                params.put("companyID",  carInfo.getCompanyId());
//            }
//        }
//
//        params.put("valid", 0);
//        params.put("tag", 1);
//        params.put("page", 1);
//        params.put("size", 100);
//
//        String json = null;
//        List<CarInfoVo> list = new ArrayList<>();
//        try {
//            String paramStr = JSON.toJSONString(params);
//            json = HttpRequest.get(remotePath+"/api/gpsservice/cs/basevehicle/ledger/list").header("Authorization", authorization).header("Content-Type", contentType)
//                    .timeout(15000).body(paramStr).execute().body();
//            log.info("/api/gpsservice/cs/basevehicle/ledger/list;params:[{}],returnJson:[{}]",paramStr,json);
//        } catch (Exception e) {
//            log.error("请求公司车辆信息异常", e);
//        }
//
//        if (StringUtils.isNotEmpty(json)) {
//            Map<String, Object> hash = JSON.parseObject(json, HashMap.class);
//            if (Objects.nonNull(hash)) {
//                if (Objects.nonNull(hash.get("code")) && StringUtils.equals(hash.get("code").toString(), "200")) {
//                    if (Objects.nonNull(hash.get("result")) && hash.get("result") instanceof JSONObject) {
//                        JSONObject resultObj = (JSONObject) hash.get("result");
//                        if (Objects.nonNull(resultObj) && Objects.nonNull(resultObj.get("list")) && resultObj.get("list") instanceof JSONArray) {
//                            JSONArray jsonArray = (JSONArray)  resultObj.get("list");
//                            for (Object object : jsonArray) {
//                                JSONObject jsonObject = (JSONObject) object;
//
//                                CarInfoVo vo = new CarInfoVo();
//                                vo.setCarBrank(jsonObject.getString("brandName"));
//                                vo.setCarCode(jsonObject.getString("licenseplateNo"));
//                                vo.setCarColor(jsonObject.getString(""));
//                                vo.setCarIdentification(jsonObject.getString("licenseplateNo"));
//                                vo.setCarType(jsonObject.getString("energyTypeName"));
//                                if (Objects.nonNull(jsonObject.getString("companyID"))) {
//                                    vo.setCompanyId(Convert.toLong(StringUtils.replace(jsonObject.getString("companyID").toString(), "zxljqy", "")));
//                                }
//                                vo.setCompanyName(jsonObject.getString("companyName"));
//                                vo.setContainerVolume(jsonObject.getString("containerVolume"));
//                                vo.setEmissionStandard(jsonObject.getString("emissionStanName"));
//                                vo.setFarmeNumber(jsonObject.getString("frmaeNo"));
//                                vo.setId(Convert.toLong(StringUtils.replace(jsonObject.getString("id"), "zxljcl", "")));
//                                vo.setStatus(jsonObject.getInteger("auditStatus"));
//                                if (StringUtils.isNotEmpty(jsonObject.getString("transportCertValid"))) {
//                                    vo.setRoadTransportDate(FAST_DATE_FORMAT.parse(jsonObject.getString("transportCertValid")));
//                                }
//                                if (StringUtils.isNotEmpty(jsonObject.getString("registerAt"))) {
//                                    vo.setEnterDate(FAST_DATE_FORMAT.parse(jsonObject.getString("registerAt")));
//                                }
//
//                                if (Objects.nonNull(jsonObject.get("drivers")) && jsonObject.get("drivers") instanceof JSONArray) {
//                                    JSONArray das = (JSONArray) jsonObject.get("drivers");
//                                    int length = CollectionUtils.size(das);
//                                    if (length > 0) {
//                                        if (Objects.nonNull(das.get(0)) && das.get(0) instanceof JSONObject) {
//                                            JSONObject dro = (JSONObject) das.get(0);
//                                            vo.setDrivers(StringUtils.replace(dro.getString("driverId").toString(), "zxljjsy", ""));
//                                            vo.setDriversName(dro.getString("driverName"));
//                                        }
//
//                                    }
//                                }
//                                if(StringUtils.isNotEmpty(vo.getCarType())) {
//                                    list.add(vo);
//                                }
//                            }
//                        }
//                    }
//                }
//            }
//        }
//    }

    @Override
    public List<GarOrderMatchHandler> queryOrderHandlerStatus(String orderId) {
        List<GarOrderMatchHandler> list =
                handlerService.list(new LambdaQueryWrapper<GarOrderMatchHandler>()
                        .eq(GarOrderMatchHandler::getGarOrderId, orderId));
        return list;
    }

    @Override
    public PageInfo querySearchHistory() {
        // 查询历史搜索记录 最多返回8个历史搜索
        PageHelper.startPage(1, 8);
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        LambdaQueryWrapper<GarSearchHistory> qw = new LambdaQueryWrapper<>();
        qw.eq(GarSearchHistory::getGarCreateBy, userId);
        List<GarSearchHistory> list = garSearchHistoryService.list(qw);
        PageInfo<GarSearchHistory> page = new PageInfo<>(list);
        return page;
    }

    @Override
    public void dispatchDisposalOrders(DisposalDispatchDto dto) {
        // TODO
        GarOrder order = getById(dto.getGarOrderId());
        List<GarOrderMatchDisposal> disposalList = new ArrayList<>(dto.getDispatchList().size());
        LambdaQueryWrapper<GarOrderMatchDisposal> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderMatchDisposal::getGarOrderId, order.getGarOrderId());
        Map<String, GarOrderMatchDisposal> handlerMap = disposalService.list(qw).stream().collect(Collectors.toMap(item -> item.getGarOrderDisposalTel(), item -> item));
        for (DisposalDispatchDto.DispatchDetail detail : dto.getDispatchList()) {
            if (handlerMap.containsKey(detail.getTel())) {
                continue;
            }
            GarOrderMatchDisposal disposal = getGarOrderMatchDisposal(order, detail);
            disposalList.add(disposal);
        }
        disposalService.saveBatch(disposalList);

        LambdaQueryWrapper<GarOrderMatchHandler> handlerQw = new LambdaQueryWrapper<>();
        handlerQw.eq(GarOrderMatchHandler::getGarOrderId, order.getGarOrderId());
        List<GarOrderMatchHandler> list = handlerService.list(handlerQw);

        List<String> tels = disposalList.stream().map(GarOrderMatchDisposal::getGarOrderDisposalTel).collect(Collectors.toList());
        for (GarOrderMatchHandler garOrderMatchHandler : list) {
            String content = "【装修垃圾清运】订单提醒：您有新的处置清运订单" + order.getGarOrderId() + "，请联系" + order.getGarOrderCompanyName() + "企业 " + garOrderMatchHandler.getGarOrderHandlerName() + " 驾驶员，驾驶员联系方式" + garOrderMatchHandler.getGarOrderHandlerTel() + "！";
            // TODO 短信通知
            smsUtils.sendMessage(tels, content);
        }

    }

    private GarOrderMatchDisposal getGarOrderMatchDisposal(GarOrder order, DisposalDispatchDto.DispatchDetail detail) {
        GarOrderMatchDisposal disposal = new GarOrderMatchDisposal();
        disposal.setGarOrderDisposalTel(detail.getTel());
        disposal.setGarOrderDisposalName(detail.getName());
        disposal.setGarOrderId(order.getGarOrderId());
        disposal.setGarOrderDisposalCompanyName(detail.getCompanyName());
        disposal.setGarOrderDisposalName(detail.getName());
        disposal.setGarOrderDisposalCompanyId(detail.getCompanyId());
//        disposal.setGarOrderDisposalId(detail.getId());
        disposal.setGarOrderDisposalStatus(GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue());
        return disposal;
    }

    @Override
    public List<DispatchDisposalVo> queryDisposalDispatch(String orderId) {
        // TODO
        // String tel = SecurityUtils.getLoginUser().getUser().getPhonenumber();
        // 选中的司机处理场所
        List<DispatchDisposalVo> voList = disposalService.requestDisposalListWithDispatchStatus(orderId);

        if (CollectionUtils.isNotEmpty(voList)) {
            voList = voList.stream().sorted(Comparator.comparing(DispatchDisposalVo::getGarOrderDisposalCompanyName)).collect(Collectors.toList());
        }
        return voList;
    }

    @Override
    public ScanDriverDetailVo checkValidCode(String validCode) {
        if (StringUtils.isNotBlank(validCode)) {
            String[] params = validCode.split(",");
            String orderId = params[0];
            String userId = params[1];
            // TODO check code
            if (checkCode(validCode, orderId, userId)) {
                ScanDriverDetailVo vo = baseMapper.queryDriverDetailByTelWithOrderId(orderId, userId);
                return vo;
            }
        }

        throw new BizException(ResultCode.CODE_400, "二维码验证不通过");
    }

    @Override
    public String askTransport(AskTransportDto dto) {
        // TODO 判断是否运载完毕  已经到预估趟次则不在生成验证码
        String orderId = dto.getGarOrderId();
        // 查询当前运载几趟  如果全部运输完毕则发送成功短信
        LambdaQueryWrapper<GarOrderMatchAsk> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderMatchAsk::getGarOrderId, dto.getGarOrderId());
        List<GarOrderMatchAsk> askList = askService.list(qw);
        GarOrder order = getById(orderId);
        for (GarOrderMatchAsk garOrderMatchAsk : askList) {
            if(garOrderMatchAsk.getGarOrderHandlerId()==null){
                // 第一次的话需要修改订单状态为已扫码
                if (order.getGarOrderScanHandlerFlag().equals(GlobalStatus.GarOrderStatus.SCAN_HANDLER_NO.getValue())) {
                    order.setGarOrderScanHandlerFlag(GlobalStatus.GarOrderStatus.SCAN_HANDLER_YES.getValue());
                    updateById(order);
                }
                BeanUtils.copyProperties(dto, garOrderMatchAsk);
                garOrderMatchAsk.setGarUpdateBy(dto.getGarOrderHandlerName());
                garOrderMatchAsk.setGarUpdateTime(new Date());
                garOrderMatchAsk.setTransportDistance(dto.getTransportDistance());
                // 判断本趟次是否上传了图片
                if(garOrderMatchAsk.getGarCarCode()==null){
                    garOrderMatchAsk.setGarOrderType("1");
                    garOrderMatchAsk.setGarRemark(garOrderMatchAsk.getGarRemark()!=null?garOrderMatchAsk.getGarRemark()+";未上传装车图片":"未上传装车图片");
                }else if(!dto.getGarHandlerCarCode().equals(garOrderMatchAsk.getGarCarCode())){
                    //判断本趟次运输车辆是否相同
                    garOrderMatchAsk.setGarOrderType("1");
                    garOrderMatchAsk.setGarRemark(garOrderMatchAsk.getGarRemark()!=null?garOrderMatchAsk.getGarRemark()+";装车和卸车的车辆号牌不一致":"装车和卸车的车辆号牌不一致");
                }
                garOrderAssociationServiceAsync.isWithinDisposal(dto.getGarHandlerCarCode(), garOrderMatchAsk, dto);
                askService.updateById(garOrderMatchAsk);
                // 保存图片url
                List<GarOrderImage> imageList = new ArrayList<>(dto.getFillImageList().size());
                for (String fillImageUrl : dto.getFillImageList()) {
                    GarOrderImage image = new GarOrderImage();
                    image.setGarOrderImageType(GlobalStatus.GarOrderStatus.IMAGE_TYPE_FILL_CAR.getValue());
                    image.setGarOrderId(orderId);
                    image.setGarOrderImageUrl(fillImageUrl);
                    image.setGarRemark(garOrderMatchAsk.getGarId());
                    imageList.add(image);
                }
                garOrderImageService.saveBatch(imageList);
                // TODO 删除验证码
                redisCache.deleteObject(orderId, dto.getGarOrderHandlerId());
                return "当前趟次记录成功";
            }
        }
        throw new BizException(ResultCode.CODE_400, "当前记录无效,已完成所有趟次！");
    }

    private void successOrder(GarOrder order) {
        order.setGarOrderHandlerStatus(GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
        order.setGarHandlerEvaluateFlag(GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue());
        order.setGarEvaluateFlag(GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue());
        updateById(order);
        // 更新disposal
        LambdaUpdateWrapper<GarOrderMatchDisposal> uwd = new LambdaUpdateWrapper<>();
        uwd.eq(GarOrderMatchDisposal::getGarOrderId, order.getGarOrderId())
                .set(GarOrderMatchDisposal::getGarOrderDisposalStatus, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
        disposalService.update(uwd);
        // 更新handler
        LambdaUpdateWrapper<GarOrderMatchHandler> uwh = new LambdaUpdateWrapper<>();
        uwh.eq(GarOrderMatchHandler::getGarOrderId, order.getGarOrderId())
                .set(GarOrderMatchHandler::getGarOrderHandlerStatus, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue());
        handlerService.update(uwh);
    }


    @Override
    public OrderDetailTransportVo queryOrderTransportDetail(String id) {
        // 根据当前订单id查订单数据 - 查扫码趟次数据
        OrderDetailTransportVo vo = baseMapper.queryOrderTransportDetail(id);
        vo.getGarRealCarCount();
        List<OrderDetailTransportVo.TransportDetail> transportDetails = vo.getTransportDetails();


        vo.setCurrentImages(new ArrayList<>());
        // 全景图片
        LambdaQueryWrapper<GarOrderImage> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderImage::getGarOrderId, id)
                .in(GarOrderImage::getGarOrderImageType,
                        Arrays.asList(GlobalStatus.GarOrderStatus.IMAGE_TYPE_FILL_CAR.getValue(), GlobalStatus.GarOrderStatus.IMAGE_TYPE_CURRENT.getValue()));
        List<GarOrderImage> imageList = garOrderImageService.list(qw);
        for (GarOrderImage image : imageList) {
            // 现场照片
            if (image.getGarOrderImageType().equals(GlobalStatus.GarOrderStatus.IMAGE_TYPE_CURRENT.getValue())) {
                vo.getCurrentImages().add(image.getGarOrderImageUrl());
            }
            // 全景图片
            else {
                for (OrderDetailTransportVo.TransportDetail detail : vo.getTransportDetails()) {
                    if (detail.getGarAskId().equals(image.getGarRemark())) {
                        detail.setFillImage(image.getGarOrderImageUrl());
                        break;
                    }
                }
            }
        }
        return vo;
    }

    @Override
    public GarOrderMatchAskVo scanDetail(String askId) {
        GarOrderMatchAsk ask = askService.getById(askId);
        GarOrderMatchAskVo vo = new GarOrderMatchAskVo();
        BeanUtils.copyProperties(ask, vo);
        // 图片url
        LambdaQueryWrapper<GarOrderImage> qw = new LambdaQueryWrapper<>();
        qw.eq(GarOrderImage::getGarOrderId, ask.getGarOrderId())
                .eq(GarOrderImage::getGarRemark, askId)
                .eq(GarOrderImage::getGarOrderImageType, GlobalStatus.GarOrderStatus.IMAGE_TYPE_FILL_CAR.getValue());
        List<String> fillImageList = garOrderImageService.list(qw).stream().map(GarOrderImage::getGarOrderImageUrl).collect(Collectors.toList());
        vo.setFillImageList(fillImageList);
        return vo;
    }

    @Override
    public String createHandlerQrCode(String orderId) {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        // 返回验证码
        // TODO 以订单id和用户id hash key返回前端生成二维码  存放到redis中
        String code = orderId + "," + userId + "," + ValidateCodeUtil.generatorCode(6);
        redisCache.setCacheMapValue(orderId, userId, code);
        return code;
    }

    @Override
    public PageInfo queryOrderMessageList(Integer pageNo, Integer pageSize) {
        PageHelper.startPage(pageNo, pageSize);
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        LambdaQueryWrapper<GarUserOrderMessage> qw = new LambdaQueryWrapper<>();
        qw.eq(GarUserOrderMessage::getGarUserId, userId)
                .eq(GarUserOrderMessage::getGarMessageState, GlobalStatus.GarUserStatusEnum.ORDER_MESSAGE_UNREAD.getStatus());
        List<GarUserOrderMessageVo> messageVos = orderMessageService.queryMessageListByUserIdWithState(userId, GlobalStatus.GarUserStatusEnum.ORDER_MESSAGE_UNREAD.getStatus());
        PageInfo<GarUserOrderMessageVo> pageInfo = new PageInfo<>(messageVos, pageSize);
        return pageInfo;
    }

    @Override
    public String readMessage(List<String> messageIds) {
        LambdaQueryWrapper<GarUserOrderMessage> qw = new LambdaQueryWrapper<>();
        qw.in(GarUserOrderMessage::getGarId, messageIds);
        List<GarUserOrderMessage> messageList = orderMessageService.list(qw);
        List<GarUserOrderMessageHistory> historyList = messageList.stream().map(item -> {
            GarUserOrderMessageHistory history = new GarUserOrderMessageHistory();
            item.setGarMessageState(GlobalStatus.GarUserStatusEnum.ORDER_MESSAGE_READ.getStatus());
            BeanUtils.copyProperties(item, history, "garId");
            return history;
        }).collect(Collectors.toList());
        orderMessageHistoryService.saveBatch(historyList);
        // 删除数据
        orderMessageService.removeByIds(messageIds);
        return "消息确认成功";
    }

    @Override
    public Integer queryOrderMessageCount() {
        String userId = SecurityUtils.getLoginUser().getUser().getUserId();
        LambdaQueryWrapper<GarUserOrderMessage> qw = new LambdaQueryWrapper<>();
        qw.eq(GarUserOrderMessage::getGarUserId, userId)
                .eq(GarUserOrderMessage::getGarMessageState, GlobalStatus.GarUserStatusEnum.ORDER_MESSAGE_UNREAD.getStatus());
        int count = orderMessageService.count(qw);
        return count;
    }

    @Override
    public List<GarOrder> queryUnprocessedOrder(Integer value, Integer orderTimeOutFlag, Integer value1) {
        return baseMapper.queryUnprocessedOrder(value, orderTimeOutFlag, value1);
    }

    @Override
    public void updateTimeOutOrderStatus(List<GarOrder> timeOutList) {
        if (CollectionUtil.isNotEmpty(timeOutList)) {
            baseMapper.updateTimeOutOrderStatus(timeOutList, GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue(), GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_YES.getValue());
        }
    }

    @Override
    public MyBargeVo queryBadgeByType(Integer type) {
        GarUser user = garUserService.getById(SecurityUtils.getLoginUser().getUser().getUserId());
        MyBargeVo vo = new MyBargeVo();
        // 用户
        if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.NORMAL_USER.getDescription())) {
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                LambdaQueryWrapper<GarOrder> qw = new LambdaQueryWrapper<>();
                qw.eq(GarOrder::getGarOrderUserId, user.getGarUserId())
                        .eq(GarOrder::getGarOrderHandlerStatus, type)
                        .eq(GarOrder::getGarCancelFlag, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                if (GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                    qw.eq(GarOrder::getGarEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue())
                            .eq(GarOrder::getGarTimeOutFlag, GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_NO.getValue());
                }
                int badge = count(qw);
                vo.setBadge(badge);
                vo.setType(type);
            }
        }
        // 运输企业
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.RESPONSIBLE_USER.getDescription())) {
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                LambdaQueryWrapper<GarOrder> qw = new LambdaQueryWrapper<>();
                qw.eq(GarOrder::getGarOrderCompanyTel, user.getGarUserTel())
                        .eq(GarOrder::getGarOrderHandlerStatus, type)
                        .eq(GarOrder::getGarCancelFlag, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                if (GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                    qw.eq(GarOrder::getGarHandlerEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_NO.getValue())
                            .eq(GarOrder::getGarTimeOutFlag, GlobalStatus.GarOrderStatus.ORDER_TIME_OUT_FLAG_NO.getValue());
                }
                int badge = count(qw);
                vo.setBadge(badge);
                vo.setType(type);
            }
        }
        // 驾驶员
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DRIVER_USER.getDescription())) {
            if (GlobalStatus.GarOrderStatus.NEW_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                Integer badge = baseMapper.queryDriverOrderListByTelWithTypeCount(user.getGarUserTel(), type, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                vo.setBadge(badge);
                vo.setType(type);
            }
        }
        // 处理场所
        else if (user.getGarUserType().equals(GlobalStatus.GarUserStatusEnum.DISPOSAL_SITE_USER.getDescription())) {
            if (GlobalStatus.GarOrderStatus.ACTIVE_ORDER.getValue().equals(type)
                    || GlobalStatus.GarOrderStatus.SUCCESS_ORDER.getValue().equals(type)) {
                Integer badge = baseMapper.queryDisposalOrderListByTelWithTypeCount(user.getGarUserTel(), type, GlobalStatus.GarOrderStatus.CANCEL_FLAG_NO.getValue());
                vo.setType(type);
                vo.setBadge(badge);
            }
        }
        return vo;
    }

    @Override
    public String queryCarIdOfDriver(String phone) {
        return baseMapper.queryCompanyIdByPhone(phone);
    }

    /**
     * 根据车牌号查询报告
     *
     * 该方法用于查询特定车牌号的车辆在前一天的报告信息它首先获取前一天的日期字符串，
     * 然后调用基础映射器（baseMapper）的查询方法，以获取符合条件的记录
     *
     * @param carCode 车牌号，用于查询报告的依据
     * @return 返回一个包含DockingQRCodeEntity对象的列表，这些对象代表了与车牌号关联的报告信息
     */
    @Override
    public List<DockingQRCodeEntity> queryReportByCarCode(String carCode) {
        // 获取前一天的日期字符串，用于查询昨天的报告
        String dateStr = fastDateFormat.format(DateUtils.addDays(new Date(), -1));
        // 调用基础映射器的查询方法，根据车牌号和日期查询报告
        return baseMapper.queryReportByCarCode(carCode, dateStr);
    }

    @Override
    public Integer queryGarRealCarCountByGarOrderId(String garOrderId) {
        return baseMapper.queryGarRealCarCountByGarOrderId(garOrderId);
    }


    private void handleCleanNumber(TransportationEnterpriseVo vo, List<GarOrder> orderList) {
        Long cleanNumber = 0L;
        for (GarOrder order : orderList) {
            if (vo.getId().toString().equals(order.getGarOrderCompanyId())) {
                cleanNumber = order.getCount();
            }
        }
        vo.setCleanNumber(cleanNumber.intValue());
    }

    private void handleScore(TransportationEnterpriseVo vo, List<GarOrderEvaluate> evaluate) {
        float score = 0;
        if (CollectionUtil.isNotEmpty(evaluate)) {
            for (GarOrderEvaluate orderEvaluate : evaluate) {
                score += orderEvaluate.getGarEvaluateScore();
            }
            vo.setScore(score / evaluate.size());
        } else {
            vo.setScore(score);
        }
    }

    private void evaluate(EvaluateDto dto, GarOrder order, GarUser user) {
        GarOrderEvaluate evaluate = new GarOrderEvaluate();
        evaluate.setGarOrderId(order.getGarOrderId());
        evaluate.setGarEvaluateContent(dto.getContent());
        evaluate.setGarEvaluateScore(dto.getScore());
        evaluate.setGarCompanyId(order.getGarOrderCompanyId());
        evaluate.setGarEvaluateTarget(dto.getEvaluateType());
        garOrderEvaluateService.save(evaluate);
        // 修改订单评价状态
        LambdaUpdateWrapper<GarOrder> uw = new LambdaUpdateWrapper<>();
        uw.eq(GarOrder::getGarOrderId, order.getGarOrderId())
                .set(dto.getEvaluateType().equals(GlobalStatus.GarOrderStatus.EVALUATE_TYPE_COMPANY.getValue()), GarOrder::getGarEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_YES.getValue())
                .set(dto.getEvaluateType().equals(GlobalStatus.GarOrderStatus.EVALUATE_TYPE_USER.getValue()), GarOrder::getGarHandlerEvaluateFlag, GlobalStatus.GarOrderStatus.EVALUATE_ORDER_YES.getValue());
        update(uw);
    }
}