package com.zbkj.admin.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
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.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.zbkj.admin.filter.TokenComponent;
import com.zbkj.admin.manager.AdminLineUpWebSocketHandler;
import com.zbkj.admin.manager.BigScreenWebSocketHandler;
import com.zbkj.common.constants.VehicleInfoConstants;
import com.zbkj.common.exception.CarException;
import com.zbkj.common.model.sms.SmsTemplate;
import com.zbkj.common.model.system.AdminAreaRelation;
import com.zbkj.common.model.system.SystemNotification;
import com.zbkj.common.model.vehicle.EbVehicleInfo;
import com.zbkj.common.model.system.SystemGroupData;
import com.zbkj.common.page.CommonPage;
import com.zbkj.common.request.AddEbVehicleInfoListReq;
import com.zbkj.common.request.AddEbVehicleInfoReq;
import com.zbkj.common.request.EditEbVehicleInfoReq;
import com.zbkj.common.request.PageEbVehicleInfoReq;
import com.zbkj.common.response.EbVehicleInfoRep;
import com.zbkj.common.response.PageEbVehicleInfoRep;
import com.zbkj.common.response.VehicleInfoStatistics;
import com.zbkj.common.response.VehicleScreenResponse;
import com.zbkj.common.utils.MiracleAECUtil;
import com.zbkj.common.utils.RedisUtil;
import com.zbkj.common.utils.SendSmsUtils;
import com.zbkj.common.vo.SendSmsVo;
import com.zbkj.service.dao.EbVehicleInfoDao;
import com.zbkj.admin.service.EbVehicleInfoService;
import com.zbkj.service.service.AdminAreaRelationService;
import com.zbkj.service.service.SmsTemplateService;
import com.zbkj.service.service.SystemGroupDataService;
import com.zbkj.service.service.SystemNotificationService;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.apache.commons.lang3.StringUtils;
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 javax.servlet.http.HttpServletRequest;
import java.time.LocalDateTime;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

@Slf4j
@Service
public class EbVehicleInfoServiceImpl extends ServiceImpl<EbVehicleInfoDao, EbVehicleInfo> implements EbVehicleInfoService {

    @Autowired
    private SystemGroupDataService systemGroupDataService;

    private final BigScreenWebSocketHandler webSocketHandler;

    private final AdminLineUpWebSocketHandler lineUpWebSocketHandler;

    @Autowired
    private TokenComponent tokenComponent;

    @Autowired
    private AdminAreaRelationService adminAreaRelationService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private SystemNotificationService systemNotificationService;

    @Autowired
    private SmsTemplateService smsTemplateService;

    @Value("${car-manager.sms.apiKey}")
    private String smsApiKey;
    @Value("${car-manager.sms.apiSecret}")
    private String smsApiSecret;
    @Value("${car-manager.sms.signName}")
    private String smsSignName;

    @Autowired
    public EbVehicleInfoServiceImpl(BigScreenWebSocketHandler webSocketHandler, AdminLineUpWebSocketHandler lineUpWebSocketHandler) {
        this.webSocketHandler = webSocketHandler;
        this.lineUpWebSocketHandler = lineUpWebSocketHandler;
    }


    /**
     * @Description:添加车辆信息
     * @author:chenbing
     * @date 2025/7/3 9:56
     */
    @SneakyThrows
    @Override
    @Transactional
    public List<EbVehicleInfoRep> add(AddEbVehicleInfoListReq request) {
        List<EbVehicleInfoRep> ebVehicleInfoRepList = new ArrayList<>();
        List<EbVehicleInfo> ebVehicleInfoList = new ArrayList<>();

        final HashMap<String, DateTime> stringDateTimeHashMap = checkTime();
        final DateTime startDateTime = stringDateTimeHashMap.get("startDateTime");
        final DateTime endDateTime = stringDateTimeHashMap.get("endDateTime");

        for (AddEbVehicleInfoReq addEbVehicleInfoReq : request.getAddEbVehicleInfoList()) {
            EbVehicleInfo ebVehicleInfo = new EbVehicleInfo();
            BeanUtils.copyProperties(addEbVehicleInfoReq, ebVehicleInfo);
            ebVehicleInfo.setLoadingAreaCode(addEbVehicleInfoReq.getLoadingAreaCode());
            //判断当前时间段中是否有数据,并获取当前时间段中最大的排队号码
            //生成排队号码（生成规则：长度为8位数字，从00000001开始，99999999结束）
            String maxQueueNumber = baseMapper.selectMaxQueueNumber(DateUtil.format(startDateTime, "yyyy-MM-dd HH:mm:ss"), DateUtil.format(endDateTime, "yyyy-MM-dd HH:mm:ss"));
            int nextNumber = (maxQueueNumber == null) ? 1 : Integer.parseInt(maxQueueNumber) + 1;
            final String maxSort = baseMapper.selectMaxSort(DateUtil.format(startDateTime, "yyyy-MM-dd HH:mm:ss"), DateUtil.format(endDateTime, "yyyy-MM-dd HH:mm:ss"));
            int nextSort = (maxSort == null) ? 1 : Integer.parseInt(maxSort) + 1;
            ebVehicleInfo.setQueueNumber(nextNumber);
            ebVehicleInfo.setSort(nextSort);
            ebVehicleInfo.setRegisterTime(DateTime.now());
            ebVehicleInfo.setLinkCode(generateRandomString());
            final boolean save = save(ebVehicleInfo);
            if (!save) {
                throw new CarException("添加车辆信息失败");
            }
            ebVehicleInfoList.add(ebVehicleInfo);
        }
        for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
            if (ebVehicleInfo.getIsPrint()) {
                EbVehicleInfoRep ebVehicleInfoRep = getVehicleInfoById(ebVehicleInfo.getId(), null, null, null, true);
                ebVehicleInfoRepList.add(ebVehicleInfoRep);
            }
        }
        final HashMap<String, Object> a = screen("添加车辆信息");
        webSocketHandler.broadcast(JSONObject.toJSONString(a));
        lineUpWebSocketHandler.broadcast("update");

        new Thread(() -> {
            for (EbVehicleInfoRep ebVehicleInfo : ebVehicleInfoRepList) {
//                if (!ebVehicleInfo.getSendSms()) {
//                    log.error("添加车辆信息时未开启发送叫号短信");
//                    continue;
//                }
                final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.REGISTRATION_SUCCESSFUL);
                if (systemNotification.getIsSms() != 1) {
                    log.error("短信通知未开启");
                    continue;
                }
                //发送短信验证码
                HashMap<String, Object> justPram = new HashMap<>();
                justPram.put("preNumber", ebVehicleInfo.getQueueNumber());
                justPram.put("carNumber", ebVehicleInfo.getCurrentWaitNum());
                justPram.put("time", ebVehicleInfo.getRegisterTime());
                justPram.put("code", ebVehicleInfo.getLinkCode());
                SendSmsVo sendSmsVo = new SendSmsVo();
                sendSmsVo.setAccessKeyIdSms(smsApiKey);
                sendSmsVo.setAccessKeySecretSms(smsApiSecret);
                sendSmsVo.setSignName(smsSignName);
                sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
                final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
                sendSmsVo.setTempLateCode(smsTemplate.getTempId());
                sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
                try {
                    SendSmsUtils.sendSms(sendSmsVo);
                } catch (Exception e) {
                    log.error("发送短信通知异常 {}", e.getMessage());
                    log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
                }
            }
        }).start();
        return ebVehicleInfoRepList;
    }

    /**
     * @Description:生成随机字符串
     * @author:chenbing
     * @date 2025/7/23 14:57
     */
    public String generateRandomString() {
        boolean grs = true;
        String code = "";
        while (grs) {
            String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
            Random random = new Random();
            StringBuilder sb = new StringBuilder(6);

            for (int i = 0; i < 6; i++) {
                int randomIndex = random.nextInt(characters.length());
                char randomChar = characters.charAt(randomIndex);
                sb.append(randomChar);
            }
            code = sb.toString();
            if (count(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getLinkCode, code)) <= 0) {
                grs = false;
            }
        }
        return code;
    }

    @Override
    public HashMap<String, DateTime> getSystemConfigTime(DateTime dateTime) {
        //判断当前时间是否在上班时间内
        final SystemGroupData systemGroupData = systemGroupDataService.getById(VehicleInfoConstants.TIME_CONFIG_ID);
        if (systemGroupData == null) {
            throw new CarException("未配置上班时间");
        }
        Integer validityHour = Integer.valueOf(getGroupDataValue(systemGroupData, "validity"));
        Integer startTimeShangBanStr = Integer.valueOf(getGroupDataValue(systemGroupData, "startTime"));
        String startTimeShangBan = startTimeShangBanStr >= 10 ? startTimeShangBanStr + ":00:00" : "0" + startTimeShangBanStr + ":00:00";
        // 解析上班时间
        DateTime startTime = DateUtil.parse(startTimeShangBan, "HH:mm:ss");
        DateTime endTime = DateUtil.offsetHour(startTime, validityHour);
        // 获取当前时间
        DateTime now = DateTime.now();
        if (dateTime != null) {
            now = dateTime;
        }
        DateTime startDateTime = new DateTime();
        DateTime endDateTime = new DateTime();
        if (now.getHours() < startTime.getHours()) {
            //如果当前小时数小于开始时间小时数，那么计算开始时间小时数就需要往前面推一天
            final String start = DateUtil.format(DateUtil.offsetDay(now, -1), "yyyy-MM-dd " + startTimeShangBan);
            startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
            endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
        } else {
            final String start = DateUtil.format(now, "yyyy-MM-dd " + startTimeShangBan);
            startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
            endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
        }
        HashMap<String, DateTime> timeMap = new HashMap<>();
        timeMap.put("startDateTime", startDateTime);
        timeMap.put("endDateTime", endDateTime);
        return timeMap;
    }

    /**
     * @Description:检查时间
     * @author:chenbing
     * @date 2025/7/18 14:36
     */
    private HashMap<String, DateTime> checkTime() {
        //判断当前时间是否在上班时间内
        final SystemGroupData systemGroupData = systemGroupDataService.getById(VehicleInfoConstants.TIME_CONFIG_ID);
        if (systemGroupData == null) {
            throw new CarException("未配置上班时间");
        }
        Integer validityHour = Integer.valueOf(getGroupDataValue(systemGroupData, "validity"));
        Integer startTimeShangBanStr = Integer.valueOf(getGroupDataValue(systemGroupData, "startTime"));
        // 处理上班时间判断逻辑
        if (validityHour == 0) {
            log.error("上班时长为0小时");
            throw new CarException("当前时间不在上班时间内");
        }
        String startTimeShangBan = startTimeShangBanStr >= 10 ? startTimeShangBanStr + ":00:00" : "0" + startTimeShangBanStr + ":00:00";
        // 解析上班时间
        DateTime startTime = DateUtil.parse(startTimeShangBan, "HH:mm:ss");
        DateTime endTime = DateUtil.offsetHour(startTime, validityHour);
        // 获取当前时间
        DateTime now = DateTime.now();
        DateTime startDateTime = new DateTime();
        DateTime endDateTime = new DateTime();
        if (now.getHours() < startTime.getHours()) {
            //如果当前小时数小于开始时间小时数，那么计算开始时间小时数就需要往前面推一天
            final String start = DateUtil.format(DateUtil.offsetDay(now, -1), "yyyy-MM-dd " + startTimeShangBan);
            startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
            endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
        } else {
            final String start = DateUtil.format(now, "yyyy-MM-dd " + startTimeShangBan);
            startDateTime = DateUtil.parse(start, "yyyy-MM-dd HH:mm:ss");
            endDateTime = DateUtil.offsetHour(startDateTime, validityHour);
        }
        if (now.isAfter(endDateTime) || now.isBefore(startDateTime)) {
            throw new CarException("当前时间不在上班时间内");
        }
        System.out.println("startDateTime = " + startDateTime);
        System.out.println("endDateTime = " + endDateTime);
        HashMap<String, DateTime> timeMap = new HashMap<>();
        timeMap.put("startDateTime", startDateTime);
        timeMap.put("endDateTime", endDateTime);
        return timeMap;
    }

    private String getGroupDataValue(SystemGroupData systemGroupData, String key) {
        String result = "";
        final JSONObject data = JSONObject.parseObject(systemGroupData.getValue());
        final JSONArray fields = data.getJSONArray("fields");
        for (Object field : fields) {
            JSONObject fieldJson = (JSONObject) field;
            if (!fieldJson.containsValue(key)) {
                continue;
            }
            result = fieldJson.getString("value");
        }
        return result;
    }

    /**
     * @Description:修改车辆信息
     * @author:chenbing
     * @date 2025/7/3 10:49
     */
    @Override
    public boolean edit(EditEbVehicleInfoReq request) {
        EbVehicleInfo ebVehicleInfo = getById(request.getId());
        if (ObjectUtil.isNull(ebVehicleInfo)) {
            throw new CarException("车辆信息不存在");
        }
        BeanUtils.copyProperties(request, ebVehicleInfo);
        ebVehicleInfo.setUpdateTime(DateTime.now());
        if (updateById(ebVehicleInfo)) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("修改车辆信息")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * @Description:分页查询车辆信息
     * @author:chenbing
     * @date 2025/7/3 10:31
     */
    @Override
    public PageInfo<PageEbVehicleInfoRep> getPage(PageEbVehicleInfoReq request) {
        Page<EbVehicleInfo> startPage = PageHelper.startPage(request.getPage(), request.getLimit());
        LambdaQueryWrapper<EbVehicleInfo> lqw = new LambdaQueryWrapper<>();
        if (ObjectUtil.isNotNull(request.getIdCard())) {
            lqw.like(EbVehicleInfo::getIdCard, request.getIdCard());
        }
        if (ObjectUtil.isNotNull(request.getName())) {
            lqw.like(EbVehicleInfo::getName, request.getName());
        }
        if (ObjectUtil.isNotNull(request.getPhone())) {
            lqw.like(EbVehicleInfo::getPhone, request.getPhone());
        }
        if (ObjectUtil.isNotNull(request.getLicensePlate())) {
            lqw.like(EbVehicleInfo::getLicensePlate, request.getLicensePlate());
        }
        if (ObjectUtil.isNotNull(request.getLoadingAreaCode())) {
            lqw.eq(EbVehicleInfo::getLoadingAreaCode, request.getLoadingAreaCode());
        }
        if (ObjectUtil.isNotNull(request.getOrderTypeCode())) {
            lqw.eq(EbVehicleInfo::getOrderTypeCode, request.getOrderTypeCode());
        }
        if (ObjectUtil.isNotNull(request.getLoadUnloadQtyMin()) && ObjectUtil.isNotNull(request.getLoadUnloadQtyMax())) {
            lqw.between(EbVehicleInfo::getLoadUnloadQty, request.getLoadUnloadQtyMin(), request.getLoadUnloadQtyMax());
        }
        if (ObjectUtil.isNotNull(request.getUnitCode())) {
            lqw.eq(EbVehicleInfo::getUnitCode, request.getUnitCode());
        }
        if (ObjectUtil.isNotNull(request.getVehicleStatusCode())) {
            lqw.eq(EbVehicleInfo::getVehicleStatusCode, request.getVehicleStatusCode());
        }
        if (ObjectUtil.isNotNull(request.getGoodsStatusCode())) {
            lqw.eq(EbVehicleInfo::getGoodsStatusCode, request.getGoodsStatusCode());
        }
        if (ObjectUtil.isNotNull(request.getQueueNumber())) {
            lqw.like(EbVehicleInfo::getQueueNumber, request.getQueueNumber());
        }
        if (ObjectUtil.isNotNull(request.getReasonCode())) {
            lqw.eq(EbVehicleInfo::getReasonCode, request.getReasonCode());
        }
        if (ObjectUtil.isNotNull(request.getRegisterTimeStart()) && ObjectUtil.isNotNull(request.getRegisterTimeEnd())) {
            lqw.between(EbVehicleInfo::getRegisterTime, handleDate(request.getRegisterTimeStart(), true), handleDate(request.getRegisterTimeEnd(), false));
        }
        lqw.eq(EbVehicleInfo::getIsDel, false).orderByDesc(EbVehicleInfo::getRegisterTime);
        List<EbVehicleInfo> ebVehicleInfoList = baseMapper.selectList(lqw);
        if (ObjectUtil.isNotEmpty(ebVehicleInfoList)) {
            return CommonPage.copyPageInfo(startPage, handleVehicleInfoList(ebVehicleInfoList));
        }
        return CommonPage.copyPageInfo(startPage, new ArrayList<>());
    }

    /**
     * @param areaId      厂区ID
     * @param queueNumber 排队号码
     * @param phone       手机号
     * @param page        当前页码，从1开始
     * @param limit       每页显示记录数
     * @Description:排队叫号列表
     * @author:chenbing
     * @date 2025/7/3 13:14
     */
    @Override
    public PageInfo<PageEbVehicleInfoRep> queueList(Integer areaId, Integer queueNumber, String phone, Integer page, Integer limit) {
        LambdaQueryWrapper<EbVehicleInfo> lqw = new LambdaQueryWrapper<>();
        lqw.eq(EbVehicleInfo::getLoadingAreaCode, areaId)
                .in(EbVehicleInfo::getVehicleStatusCode, Arrays.asList(VehicleInfoConstants.SCREEN_STATUS_FILTER))
                .eq(EbVehicleInfo::getIsDel, false).orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber);
        if (ObjectUtil.isNotNull(queueNumber)) {
            lqw.like(EbVehicleInfo::getQueueNumber, queueNumber);
        }
        if (ObjectUtil.isNotNull(phone)) {
            lqw.like(EbVehicleInfo::getPhone, phone);
        }
        final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
        lqw.between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"));
        Page<EbVehicleInfo> startPage = PageHelper.startPage(page, limit);
        List<EbVehicleInfo> ebVehicleInfoList = baseMapper.selectList(lqw);
        PageInfo<EbVehicleInfo> pageInfo = new PageInfo<>(startPage);
        if (ObjectUtil.isNotEmpty(ebVehicleInfoList)) {
            return CommonPage.copyPageInfo(pageInfo, handleVehicleInfoList(ebVehicleInfoList));
        }
        return CommonPage.copyPageInfo(startPage, new ArrayList<>());
    }

    /**
     * @param vehicleId 车辆信息ID
     * @param linkCode
     * @Description:根据车辆ID查询车辆信息
     * @author:chenbing
     * @date 2025/7/3 14:31
     */
    @Override
    public EbVehicleInfoRep getVehicleInfoById(String vehicleId, Integer queueNumber, String linkCode, HttpServletRequest httpServletRequest, boolean isDriver) {
        final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
        if (!isDriver) {
            EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>()
                    .eq(ObjectUtil.isNotNull(queueNumber), EbVehicleInfo::getQueueNumber, queueNumber)
                    .eq(ObjectUtil.isNotNull(linkCode), EbVehicleInfo::getLinkCode, linkCode)
                    .eq(EbVehicleInfo::getIsDel, false)
                    .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
            if (ObjectUtil.isNull(ebVehicleInfo)) {
                throw new RuntimeException("车辆信息不存在");
            }
            //查询门卫权限
            if (adminAreaRelationService.count(new LambdaQueryWrapper<AdminAreaRelation>().eq(AdminAreaRelation::getAdminId, tokenComponent.getLoginUser(httpServletRequest).getUser().getId()).eq(AdminAreaRelation::getAreaId, ebVehicleInfo.getLoadingAreaCode())) <= 0) {
                throw new CarException("无权限核销该区域");
            }
        }
        EbVehicleInfoRep pageEbVehicleInfoRep = new EbVehicleInfoRep();
//        EbVehicleInfo ebVehicleInfo = null;
//        if (ObjectUtil.isNotNull(vehicleId)) {
//            ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false)
//                    .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
//        }
//        if (ObjectUtil.isNull(ebVehicleInfo)) {
//            ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getQueueNumber, queueNumber).eq(EbVehicleInfo::getIsDel, false)
//                    .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
//        }
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIsDel, false)
                .eq(ObjectUtil.isNotNull(vehicleId), EbVehicleInfo::getId, vehicleId)
                .eq(ObjectUtil.isNotNull(queueNumber), EbVehicleInfo::getQueueNumber, queueNumber)
                .eq(ObjectUtil.isNotNull(linkCode), EbVehicleInfo::getLinkCode, linkCode)
                .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
        BeanUtils.copyProperties(handleVehicleInfo(ebVehicleInfo), pageEbVehicleInfoRep);
        //查询当前厂区所有车辆信息
        List<EbVehicleInfo> ebVehicleInfos = list(new LambdaQueryWrapper<EbVehicleInfo>()
//                .between(EbVehicleInfo::getRegisterTime, DateUtil.format(DateUtil.beginOfDay(new Date()), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(DateUtil.endOfDay(new Date()), "yyyy-MM-dd HH:mm:ss"))
//                .in(EbVehicleInfo::getVehicleStatusCode, Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER))
                .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
                .eq(EbVehicleInfo::getLoadingAreaCode, ebVehicleInfo.getLoadingAreaCode())
                .eq(EbVehicleInfo::getIsDel, false)
                .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
                .orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
        //判断vehicleId在ebVehicleInfos中的哪一个item中
        if (!ebVehicleInfos.isEmpty()) {
            int waitCount = ebVehicleInfos.indexOf(ebVehicleInfo);
            pageEbVehicleInfoRep.setCurrentWaitNum(waitCount);
        } else {
            pageEbVehicleInfoRep.setCurrentWaitNum(0);
        }
        //查询当前车辆关联的所有厂区
        List<String> loadingAreaNames = new ArrayList<>();
        list(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, ebVehicleInfo.getMasterId())).forEach(ebVehicleInfo1 -> {
            loadingAreaNames.add(handleDataTeam(ebVehicleInfo1.getLoadingAreaCode(), "name"));
        });
        if (loadingAreaNames.size() > 1) {
            pageEbVehicleInfoRep.setLoadingAreaName(StringUtils.join(loadingAreaNames, ","));
        } else {
            pageEbVehicleInfoRep.setLoadingAreaName(loadingAreaNames.get(0));
        }
        return pageEbVehicleInfoRep;
    }

    public Integer passCarNumber(String vehicleId) {
        final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIsDel, false)
                .eq(ObjectUtil.isNotNull(vehicleId), EbVehicleInfo::getId, vehicleId)
                .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime")));
        //查询当前正在排队中的车辆数量
        return count(new LambdaQueryWrapper<EbVehicleInfo>()
                .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
                .eq(EbVehicleInfo::getLoadingAreaCode, ebVehicleInfo.getLoadingAreaCode())
                .eq(EbVehicleInfo::getIsDel, false)
                .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
                .orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
    }

    /**
     * @param masterId 关联关系ID
     * @Description:门卫-车辆入厂核销
     * @author:chenbing
     * @date 2025/7/3 14:51
     */
    @Override
    public boolean vehicleIn(String masterId, HttpServletRequest httpServletRequest) {
        checkAdminAuth(masterId, httpServletRequest);
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_ENTERED)
                .set("enter_time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")).eq("master_id", masterId))) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("车辆入厂核销")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * @Description:检查门卫权限
     * @author:chenbing
     * @date 2025/7/18 15:14
     */
    private void checkAdminAuth(String masterId, HttpServletRequest httpServletRequest) {
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>()
                .eq(ObjectUtil.isNotNull(masterId), EbVehicleInfo::getMasterId, masterId)
//                .eq(EbVehicleInfo::getIsPrint, true)
                .eq(EbVehicleInfo::getIsCall, true)
                .eq(EbVehicleInfo::getIsDel, false));
        if (ObjectUtil.isNull(ebVehicleInfo)) {
            throw new RuntimeException("车辆信息不存在");
        }
        //查询门卫权限
        if (adminAreaRelationService.count(new LambdaQueryWrapper<AdminAreaRelation>().eq(AdminAreaRelation::getAdminId, tokenComponent.getLoginUser(httpServletRequest).getUser().getId()).eq(AdminAreaRelation::getAreaId, ebVehicleInfo.getLoadingAreaCode())) <= 0) {
            throw new CarException("无权限核销该区域");
        }
    }

    /**
     * @param masterId 关联关系ID
     * @Description:门卫-车辆离厂核销
     * @author:chenbing
     * @date 2025/7/3 14:53
     */
    @Override
    public boolean vehicleOut(String masterId, HttpServletRequest httpServletRequest) {
        checkAdminAuth(masterId, httpServletRequest);
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_LEFT)
                .set("leave_time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss")).eq("master_id", masterId))) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("车辆离厂核销")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * @Description:自动更新数据
     * @author:chenbing
     * @date 2025/7/23 11:09
     */
    @Override
    public void autoUpdateScreen() {
        webSocketHandler.broadcast(JSONObject.toJSONString(screen("每小时定时更新")));
        lineUpWebSocketHandler.broadcast("update");
    }

    /**
     * @param card 身份证号
     * @Description:根据身份证号获取最近的一条车辆信息数据
     * @author:chenbing
     * @date 2025/7/7 16:53
     */
    @Override
    public PageEbVehicleInfoRep getVehicleInfoByCard(String card) {
        final List<EbVehicleInfo> ebVehicleInfos = list(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getIdCard, card).eq(EbVehicleInfo::getIsDel, false).orderByDesc(EbVehicleInfo::getRegisterTime));
        if (ObjectUtil.isNotEmpty(ebVehicleInfos)) {
            return handleVehicleInfo(ebVehicleInfos.get(0));
        }
        return null;
    }

    /**
     * @Description:处理车辆信息列表
     * @author:chenbing
     * @date 2025/7/3 13:44
     */
    private List<PageEbVehicleInfoRep> handleVehicleInfoList(List<EbVehicleInfo> ebVehicleInfoList) {
        return ebVehicleInfoList.stream().map(this::handleVehicleInfo).collect(Collectors.toList());
    }


    /**
     * @Description:处理车辆信息
     * @author:chenbing
     * @date 2025/7/3 14:43
     */
    private PageEbVehicleInfoRep handleVehicleInfo(EbVehicleInfo ebVehicleInfo) {
        PageEbVehicleInfoRep pageEbVehicleInfoRep = new PageEbVehicleInfoRep();
        BeanUtils.copyProperties(ebVehicleInfo, pageEbVehicleInfoRep);
        if (ObjectUtil.isNotNull(ebVehicleInfo.getLoadingAreaCode())) {
            pageEbVehicleInfoRep.setLoadingAreaName(handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getOrderTypeCode())) {
            pageEbVehicleInfoRep.setOrderTypeName(handleDataTeam(ebVehicleInfo.getOrderTypeCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getUnitCode())) {
            pageEbVehicleInfoRep.setUnitName(handleDataTeam(ebVehicleInfo.getUnitCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getVehicleStatusCode())) {
            pageEbVehicleInfoRep.setVehicleStatusName(handleDataTeam(ebVehicleInfo.getVehicleStatusCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getGoodsStatusCode())) {
            pageEbVehicleInfoRep.setGoodsStatusName(handleDataTeam(ebVehicleInfo.getGoodsStatusCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getReasonCode())) {
            pageEbVehicleInfoRep.setReasonName(handleDataTeam(ebVehicleInfo.getReasonCode(), "name"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getEnterTime())) {
            pageEbVehicleInfoRep.setEnterTime(DateUtil.format(ebVehicleInfo.getEnterTime(), "yyyy-MM-dd HH:mm:ss"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getLeaveTime())) {
            pageEbVehicleInfoRep.setLeaveTime(DateUtil.format(ebVehicleInfo.getLeaveTime(), "yyyy-MM-dd HH:mm:ss"));
        }
        if (ObjectUtil.isNotNull(ebVehicleInfo.getRegisterTime())) {
            pageEbVehicleInfoRep.setRegisterTime(DateUtil.format(ebVehicleInfo.getRegisterTime(), "yyyy-MM-dd HH:mm:ss"));
        }
        return pageEbVehicleInfoRep;
    }


    /**
     * @Description:大屏数据
     * @author:chenbing
     * @date 2025/7/3 18:07
     */
    @Override
    public HashMap<String, Object> screen(String event) {
        HashMap<String, Object> result = new HashMap<>();
        int totalWaitCount = 0;
        int totalCurrentCount = 0;
        int totalOverCount = 0;
        int totalCount = 0;
        //查询出所有的厂区
        List<SystemGroupData> systemGroupDataList = systemGroupDataService.list(new LambdaQueryWrapper<SystemGroupData>()
                .eq(SystemGroupData::getGid, VehicleInfoConstants.LOADING_AREA_ID).eq(SystemGroupData::getStatus, true));
        if (ObjectUtil.isEmpty(systemGroupDataList)) {
            return null;
        }
        //遍历厂区
        JSONArray jsonArray = new JSONArray();
        for (SystemGroupData systemGroupData : systemGroupDataList) {
            HashMap<String, Object> areaMap = new HashMap<>();
            HashMap<String, Object> map = new HashMap<>();
            //获取当前厂区名称
            String loadingAreaName = handleDataTeam(systemGroupData.getId(), "name");
            //查询当前厂区所有车辆信息
//            String registerTimeStart = DateUtil.format(DateUtil.beginOfDay(new Date()), "yyyy-MM-dd HH:mm:ss");
//            String registerTimeEnd = DateUtil.format(DateUtil.endOfDay(new Date()), "yyyy-MM-dd HH:mm:ss");
            final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
            String registerTimeStart = DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss");
            String registerTimeEnd = DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss");
            List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
                    .between(EbVehicleInfo::getRegisterTime, registerTimeStart, registerTimeEnd)
                    .eq(EbVehicleInfo::getLoadingAreaCode, systemGroupData.getId())
                    .eq(EbVehicleInfo::getIsDel, false).orderByAsc(EbVehicleInfo::getSort)
                    .orderByAsc(EbVehicleInfo::getQueueNumber).last("LIMIT 27"));
            //查询当前厂区统计数据
            VehicleInfoStatistics vehicleInfoStatistics = new VehicleInfoStatistics();
            if (ebVehicleInfoList.isEmpty()) {
                map.put("vehicleInfoStatistics", vehicleInfoStatistics);
                map.put("ebVehicleInfoList", new ArrayList<>());
//                areaMap.put(loadingAreaName, map);
                areaMap.put("name", loadingAreaName);
                areaMap.put("value", map);
                jsonArray.add(areaMap);
                continue;
            }
            //统计等待车辆（车辆状态为：排队中、已叫号、已过号）的数量
            long waitCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                    Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).count();
            vehicleInfoStatistics.setWaitingVehicleCount(Math.toIntExact(waitCount));
            totalWaitCount += Math.toIntExact(waitCount);
            //统计当前厂区车辆（车辆状态为：已入厂并且已打印）数量
            long currentCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                    VehicleInfoConstants.QUEUE_STATUS_ENTERED.equals(ebVehicleInfo.getVehicleStatusCode()) && Boolean.TRUE.equals(ebVehicleInfo.getIsCall())).count();
            vehicleInfoStatistics.setCurrentVehicleCount(Math.toIntExact(currentCount));
            totalCurrentCount += Math.toIntExact(currentCount);
            //统计已发货车辆（车辆状态为：已离厂）数量
            long overCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                    VehicleInfoConstants.QUEUE_STATUS_LEFT.equals(ebVehicleInfo.getVehicleStatusCode())).count();
            vehicleInfoStatistics.setShippedVehicleCount(Math.toIntExact(overCount));
            totalOverCount += Math.toIntExact(overCount);
            map.put("vehicleInfoStatistics", vehicleInfoStatistics);
            //统计当前登记车辆总数量（等待车辆数量 + 当前厂区车辆数量 + 已发货车辆数量）
            vehicleInfoStatistics.setCurrentLevelVehicleCount(Math.toIntExact(waitCount + currentCount + overCount));
            totalCount += Math.toIntExact(waitCount + currentCount + overCount);
            ebVehicleInfoList = ebVehicleInfoList.stream().filter(ebVehicleInfo -> Arrays.asList(VehicleInfoConstants.SCREEN_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).collect(Collectors.toList());
            List<VehicleScreenResponse> vehicleScreenResponseList = new ArrayList<>();
            for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
                VehicleScreenResponse vehicleScreenResponse = new VehicleScreenResponse();
                BeanUtils.copyProperties(ebVehicleInfo, vehicleScreenResponse);
                vehicleScreenResponse.setVehicleStatusName(handleDataTeam(ebVehicleInfo.getVehicleStatusCode(), "name"));
                vehicleScreenResponse.setRegisterTime(DateUtil.format(ebVehicleInfo.getRegisterTime(), "yyyy-MM-dd HH:mm:ss"));
                vehicleScreenResponse.setName(getName(ebVehicleInfo.getName()));
                vehicleScreenResponse.setLicensePlate(getLicensePlate(ebVehicleInfo.getLicensePlate()));
                vehicleScreenResponse.setPhone(getPhone(ebVehicleInfo.getPhone()));
                vehicleScreenResponseList.add(vehicleScreenResponse);
            }
            map.put("ebVehicleInfoList", vehicleScreenResponseList);
//                areaMap.put(loadingAreaName, map);
            areaMap.put("name", loadingAreaName);
            areaMap.put("value", map);
            jsonArray.add(areaMap);
        }
        result.put("areaList", jsonArray);
        HashMap<String, Object> totalMap = new HashMap<>();
        totalMap.put("totalWaitCount", totalWaitCount);
        totalMap.put("totalCurrentCount", totalCurrentCount);
        totalMap.put("totalOverCount", totalOverCount);
        totalMap.put("totalCount", totalCount);
        result.put("total", totalMap);
        result.put("time", DateUtil.format(new Date(), "yyyy-MM-dd HH:mm:ss"));
        result.put("event", event);
        // 创建一个新的 HashMap 并复制 result 的内容
        HashMap<String, Object> result1 = new HashMap<>(result);
        result1.put("event", "建立连接返回数据");
        redisUtil.set("screen-data", JSONObject.toJSONString(result1));
        return result;
    }

    public String getName(String name) {
        if (StringUtils.isEmpty(name) || name.length() < 2) {
            return name;
        }
        // Java 8 兼容方案
        return name.charAt(0) + String.join("", Collections.nCopies(name.length() - 1, "*"));
    }

    public String getLicensePlate(String licensePlate) {
//        if (StringUtils.isEmpty(licensePlate) || licensePlate.length() < 3) {
//            return licensePlate;
//        }
//        // Java 8 兼容方案
//        return licensePlate.substring(0, 2) +
//                String.join("", Collections.nCopies(licensePlate.length() - 4, "*")) +
//                licensePlate.substring(licensePlate.length() - 2);
        if (StringUtils.isEmpty(licensePlate)) {
            return licensePlate;
        }
        if (licensePlate.length() <= 2) {
            // 长度小于等于 2 时，不进行脱敏处理
            return licensePlate;
        }
        // 提取首尾字符
        String firstChar = licensePlate.substring(0, 1);
        String lastChar = licensePlate.substring(licensePlate.length() - 1);
        // 生成中间的 * 字符串
        String maskedPart = String.join("", Collections.nCopies(licensePlate.length() - 2, "*"));
        return firstChar + maskedPart + lastChar;
    }

    public String getPhone(String phone) {
        if (StringUtils.isEmpty(phone) || phone.length() != 11) {
            return phone;
        }
        return phone.substring(0, 3) + "****" + phone.substring(7);
    }

    /**
     * @param areaId 厂区ID
     * @Description:根据厂区ID统计车辆信息数据
     * @author:chenbing
     * @date 2025/7/3 13:29
     */
    @Override
    public VehicleInfoStatistics statistics(Integer areaId) {
        VehicleInfoStatistics vehicleInfoStatistics = new VehicleInfoStatistics();
        //根据厂区ID查询当前厂区车辆最大数量
        Integer maxCount = Integer.parseInt(handleDataTeam(areaId, "maxcount"));
        vehicleInfoStatistics.setMaxVehicleCount(maxCount);
        //查询当前厂区所有车辆信息
        final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
        List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
                .between(EbVehicleInfo::getRegisterTime, systemConfigTime.get("startDateTime"), systemConfigTime.get("endDateTime"))
                .eq(EbVehicleInfo::getLoadingAreaCode, areaId)
                .eq(EbVehicleInfo::getIsDel, false));
        if (ebVehicleInfoList.isEmpty()) {
            return vehicleInfoStatistics;
        }
        //统计等待车辆（车辆状态为：排队中、已叫号、已过号）的数量
        long waitCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                Arrays.asList(VehicleInfoConstants.QUEUE_STATUS_FILTER).contains(ebVehicleInfo.getVehicleStatusCode())).count();
        vehicleInfoStatistics.setWaitingVehicleCount(Math.toIntExact(waitCount));
        //统计当前厂区车辆（车辆状态为：已入厂并且已叫号）数量
        long currentCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                VehicleInfoConstants.QUEUE_STATUS_ENTERED.equals(ebVehicleInfo.getVehicleStatusCode()) && Boolean.TRUE.equals(ebVehicleInfo.getIsCall())).count();
        vehicleInfoStatistics.setCurrentVehicleCount(Math.toIntExact(currentCount));
        //统计已发货车辆（车辆状态为：已离厂）数量
        long overCount = ebVehicleInfoList.stream().filter(ebVehicleInfo ->
                VehicleInfoConstants.QUEUE_STATUS_LEFT.equals(ebVehicleInfo.getVehicleStatusCode())).count();
        vehicleInfoStatistics.setShippedVehicleCount(Math.toIntExact(overCount));
        //统计当前登记车辆总数量（等待车辆数量 + 当前厂区车辆数量 + 已发货车辆数量）
        vehicleInfoStatistics.setCurrentLevelVehicleCount(Math.toIntExact(waitCount + currentCount + overCount));
        return vehicleInfoStatistics;
    }

    private String handleDate(String date, Boolean begin) {
        if (!begin) {
            return date + " 23:59:59";
        }
        return date + " 00:00:00";
    }

    /**
     * @param vehicleId 车辆信息ID
     * @param sort      排序
     * @Description:调整排序
     * @author:chenbing
     * @date 2025/7/3 14:11
     */
    @Override
    public boolean sort(String vehicleId, Integer sort) {
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
        if (ObjectUtil.isNull(ebVehicleInfo)) {
            throw new CarException("车辆信息不存在");
        }
        if (update(new UpdateWrapper<EbVehicleInfo>().set("sort", sort).eq("id", vehicleId))) {
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * @param vehicleId 车辆信息ID
     * @Description:手动叫号
     * @author:chenbing
     * @date 2025/7/3 14:15
     */
    @Override
    public boolean callNumber(String vehicleId) {
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_CALLED).set("call_time", LocalDateTime.now()).eq("master_id", ebVehicleInfo.getMasterId()))) {
            //设置 手动叫号 的车辆信息 is_call 为 true
            update(new UpdateWrapper<EbVehicleInfo>().set("is_call", true).eq("id", vehicleId));
            if (!ebVehicleInfo.getSendSms()) {
                //todo 发送短信提醒
                webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
                lineUpWebSocketHandler.broadcast("update");
                return true;
            }
            final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
            if (systemNotification.getIsSms() != 1) {
                webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
                lineUpWebSocketHandler.broadcast("update");
                return true;
            }
            //发送短信验证码
            HashMap<String, Object> justPram = new HashMap<>();
            justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
            justPram.put("code", ebVehicleInfo.getLinkCode());
            SendSmsVo sendSmsVo = new SendSmsVo();
            sendSmsVo.setAccessKeyIdSms(smsApiKey);
            sendSmsVo.setAccessKeySecretSms(smsApiSecret);
            sendSmsVo.setSignName(smsSignName);
            sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
            final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
            sendSmsVo.setTempLateCode(smsTemplate.getTempId());
            sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
            try {
                Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
                if (!sendSms) {
                    log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
                }
            } catch (Exception e) {
                log.error("发送短信通知异常 {}", e.getMessage());
            }
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * 不是已叫号的状态，提示当前车辆未叫号
     *
     * @param vehicleId 车辆信息ID
     * @Description:发送短信提醒
     * @author:chenbing
     * @date 2025/8/4 18:26
     */
    @SneakyThrows
    @Override
    public boolean sendSms(String vehicleId) {
        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getId, vehicleId).eq(EbVehicleInfo::getIsDel, false));
        final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
        if (systemNotification.getIsSms() != 1) {
            throw new CarException("当前通知设置未开启短信通知");
        }
        //发送短信验证码
        HashMap<String, Object> justPram = new HashMap<>();
        justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
        justPram.put("code", ebVehicleInfo.getLinkCode());
        SendSmsVo sendSmsVo = new SendSmsVo();
        sendSmsVo.setAccessKeyIdSms(smsApiKey);
        sendSmsVo.setAccessKeySecretSms(smsApiSecret);
        sendSmsVo.setSignName(smsSignName);
        sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
        final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
        sendSmsVo.setTempLateCode(smsTemplate.getTempId());
        sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
        Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
        if (!sendSms) {
            log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
            throw new CarException("发送短信通知失败");
        }
        return true;
    }

    public boolean autoCallNumber(String masterId, String vehicleId) {
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_CALLED).set("call_time", LocalDateTime.now()).eq("master_id", masterId))) {
            //设置 自动叫号 的车辆信息 is_call 为 true
            return update(new UpdateWrapper<EbVehicleInfo>().set("is_call", true).eq("id", vehicleId));
        }
        return false;
    }

    /**
     * @param masterId 关联关系ID
     * @Description:标记为已过号
     * @author:chenbing
     * @date 2025/7/3 14:16
     */
    @Override
    public boolean passNumber(String masterId) {
        final EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsCall, true).eq(EbVehicleInfo::getIsDel, false));
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_PASSED).set("is_call", false).eq("master_id", masterId))) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("标记为已过号")));
            lineUpWebSocketHandler.broadcast("update");
            //todo 发送短信提醒
            final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.PASS_NUMBER_SMS);
            if (systemNotification.getIsSms() != 1) {
                return true;
            }
            //发送短信验证码
            HashMap<String, Object> justPram = new HashMap<>();
            justPram.put("preNumber", ebVehicleInfo.getQueueNumber());
            justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
            justPram.put("carNumber", passCarNumber(ebVehicleInfo.getId()));
            SendSmsVo sendSmsVo = new SendSmsVo();
            sendSmsVo.setAccessKeyIdSms(smsApiKey);
            sendSmsVo.setAccessKeySecretSms(smsApiSecret);
            sendSmsVo.setSignName(smsSignName);
            sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
            final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
            sendSmsVo.setTempLateCode(smsTemplate.getTempId());
            sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
            try {
                final Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
                if (!sendSms) {
                    log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
                }
            } catch (Exception e) {
                log.error("发送短信通知异常 {}", e.getMessage());
            }
            return true;
        }
        return false;
    }

    /**
     * @param masterId 关联关系ID
     * @param sort     排序
     * @Description:重新排队
     * @author:chenbing
     * @date 2025/7/3 14:18
     */
    @Override
    public boolean reQueue(String masterId, Integer sort) {
        if (update(new UpdateWrapper<EbVehicleInfo>().set("vehicle_status_code", VehicleInfoConstants.QUEUE_STATUS_UNDERWAY).set("sort", sort).eq("master_id", masterId))) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("重新排队")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }

    /**
     * @Description:自动叫号
     * @author:chenbing
     * @date 2025/7/3 14:19
     */
    @Override
    public void autoCallNumber() {
        //查询所有的厂区
        final List<SystemGroupData> systemGroupData = systemGroupDataService.list(new LambdaQueryWrapper<SystemGroupData>().eq(SystemGroupData::getGid, VehicleInfoConstants.LOADING_AREA_ID));
        if (ObjectUtil.isNotEmpty(systemGroupData)) {
            //遍历所有的厂区
            for (SystemGroupData groupData : systemGroupData) {
                final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
                //根据厂区ID查询当前厂区车辆最大数量
                Integer maxCount = Integer.parseInt(handleDataTeam(groupData.getId(), "maxcount"));
                //统计当前厂区车辆（车辆状态为：已入厂）数量并且从当前区域叫号的车辆数量
                final int currentCount = count(new LambdaQueryWrapper<EbVehicleInfo>()
                        .between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
                        .eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
                        .eq(EbVehicleInfo::getIsDel, false)
//                        .eq(EbVehicleInfo::getIsPrint, true)
                        .eq(EbVehicleInfo::getIsCall, true)
                        .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_ENTERED)
                        .orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
                //统计当前已叫号车辆数量并且从当前区域叫号的车辆数量
                final int waitCount = count(new LambdaQueryWrapper<EbVehicleInfo>()
                        .between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
                        .eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
                        .eq(EbVehicleInfo::getIsDel, false)
                        .eq(EbVehicleInfo::getIsCall, true)
                        .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_CALLED)
                        .orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber));
                final int rotaCount = maxCount - currentCount - waitCount;
                if (rotaCount <= 0) {
                    continue;
                }
                //查询当前厂区所有车辆信息（状态为：排队中的）
                final List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
                        .between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
                        .eq(EbVehicleInfo::getLoadingAreaCode, groupData.getId())
                        .eq(EbVehicleInfo::getIsDel, false)
//                        .eq(EbVehicleInfo::getIsPrint, true)
                        .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_UNDERWAY)
                        .ne(EbVehicleInfo::getGoodsStatusCode, VehicleInfoConstants.VEHICLE_STATUS_PRODUCTION)
                        .orderByAsc(EbVehicleInfo::getSort).orderByAsc(EbVehicleInfo::getQueueNumber).last("LIMIT " + rotaCount));
                if (ebVehicleInfoList.isEmpty()) {
                    continue;
                }
                for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
                    //叫号
                    if (autoCallNumber(ebVehicleInfo.getMasterId(), ebVehicleInfo.getId())) {
                        log.info("自动叫号成功，车辆信息ID：{}", JSONObject.toJSONString(ebVehicleInfo));
                        if (!ebVehicleInfo.getSendSms()) {
                            //todo 发送短信提醒
                            continue;
                        }
                        final SystemNotification systemNotification = systemNotificationService.getByMark(VehicleInfoConstants.CALL_THE_NUMBER_TO_ENTER_THE_FACTORY);
                        if (systemNotification.getIsSms() != 1) {
                            continue;
                        }
                        //发送短信验证码
                        HashMap<String, Object> justPram = new HashMap<>();
                        justPram.put("areaName", handleDataTeam(ebVehicleInfo.getLoadingAreaCode(), "name"));
                        justPram.put("code", ebVehicleInfo.getLinkCode());
                        SendSmsVo sendSmsVo = new SendSmsVo();
                        sendSmsVo.setAccessKeyIdSms(smsApiKey);
                        sendSmsVo.setAccessKeySecretSms(smsApiSecret);
                        sendSmsVo.setSignName(smsSignName);
                        sendSmsVo.setTemplateParam(JSONObject.toJSONString(justPram));
                        final SmsTemplate smsTemplate = smsTemplateService.getDetail(systemNotification.getSmsId());
                        sendSmsVo.setTempLateCode(smsTemplate.getTempId());
                        sendSmsVo.setPhoneNumber(ebVehicleInfo.getPhone());
                        try {
                            final Boolean sendSms = SendSmsUtils.sendSms(sendSmsVo);
                            if (!sendSms) {
                                log.error("发送短信通知失败，车辆信息：{}", JSONObject.toJSONString(ebVehicleInfo));
                            }
                        } catch (Exception e) {
                            log.error("发送短信通知异常 {}", e.getMessage());
                        }
                    }
                }
                webSocketHandler.broadcast(JSONObject.toJSONString(screen("手动叫号")));
                lineUpWebSocketHandler.broadcast("update");
            }
        }
    }

    /**
     * @Description:自动标记为已过号
     * @author:chenbing
     * @date 2025/8/4 18:27
     */
    @Override
    public void autoPassNumber() {
        //获取叫号超时时长
        final String callNumberTimeout = handleDataTeam(VehicleInfoConstants.CALL_NUMBER_TIMEOUT_DATA_ID, "overtime");
        if (StringUtils.isBlank(callNumberTimeout)) {
            return;
        }
        //获取叫号超时时长
        final Integer callNumberTimeoutInt = Integer.parseInt(callNumberTimeout);
        final HashMap<String, DateTime> systemConfigTime = getSystemConfigTime(null);
        //查询叫号超时时长前的车辆信息
        final List<EbVehicleInfo> ebVehicleInfoList = list(new LambdaQueryWrapper<EbVehicleInfo>()
                .between(EbVehicleInfo::getRegisterTime, DateUtil.format(systemConfigTime.get("startDateTime"), "yyyy-MM-dd HH:mm:ss"), DateUtil.format(systemConfigTime.get("endDateTime"), "yyyy-MM-dd HH:mm:ss"))
                .eq(EbVehicleInfo::getIsDel, false)
                .eq(EbVehicleInfo::getIsCall, true)
                .eq(EbVehicleInfo::getVehicleStatusCode, VehicleInfoConstants.QUEUE_STATUS_CALLED));
        if (CollectionUtils.isEmpty(ebVehicleInfoList)) {
            return;
        }
        //获取当前时间
        final DateTime now = DateUtil.date();
        for (EbVehicleInfo ebVehicleInfo : ebVehicleInfoList) {
            //判断叫号时间+超时时间 是否 大于当前时间
            DateTime callTime = DateUtil.parse(ebVehicleInfo.getCallTime(), "yyyy-MM-dd HH:mm:ss");
            DateTime passCallTime = DateUtil.offsetMinute(callTime, callNumberTimeoutInt);
            if (passCallTime.isAfterOrEquals(now)) {
                // 此时还没有过号，就到下一个 item
                continue;
            }
            log.info("自动标记为已过号，车辆信息ID：{}", JSONObject.toJSONString(ebVehicleInfo));
            //标记为已过号
            passNumber(ebVehicleInfo.getMasterId());
        }
    }

    /**
     * @Description:处理数据组内容
     * @author:chenbing
     * @date 2025/7/3 11:22
     */
    private String handleDataTeam(Integer dataId, String key) {
        String result = "";
        //获取数据组内容
        final SystemGroupData systemGroupData = systemGroupDataService.getById(dataId);
        final JSONObject data = JSONObject.parseObject(systemGroupData.getValue());
        final JSONArray fields = data.getJSONArray("fields");
        for (Object field : fields) {
            JSONObject fieldJson = (JSONObject) field;
            if (!fieldJson.containsValue(key)) {
                continue;
            }
            result = fieldJson.getString("value");
        }
        return result;
    }

    /**
     * @Description:删除车辆信息
     * @author:chenbing
     * @date 2025/7/3 10:47
     */
    @Override
    public boolean delete(String masterId) {
//        EbVehicleInfo ebVehicleInfo = getOne(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsPrint, true).eq(EbVehicleInfo::getIsDel, false));
        if (count(new LambdaQueryWrapper<EbVehicleInfo>().eq(EbVehicleInfo::getMasterId, masterId).eq(EbVehicleInfo::getIsDel, false)) <= 0) {
            throw new CarException("车辆信息不存在");
        }
        if (update(new UpdateWrapper<EbVehicleInfo>().set("is_del", true).eq("master_id", masterId))) {
            webSocketHandler.broadcast(JSONObject.toJSONString(screen("删除车辆信息")));
            lineUpWebSocketHandler.broadcast("update");
            return true;
        }
        return false;
    }
}