package com.ruoyi.system.service.impl;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.config.TiandituMapConfig;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.system.domain.VehicleGps;
import com.ruoyi.system.domain.VehicleGpsSegmentMileage;
import com.ruoyi.system.domain.SysTask;
import com.ruoyi.system.domain.VehicleInfo;
import com.ruoyi.system.mapper.VehicleGpsMapper;
import com.ruoyi.system.mapper.VehicleGpsSegmentMileageMapper;
import com.ruoyi.system.mapper.SysTaskMapper;
import com.ruoyi.system.mapper.VehicleInfoMapper;
import com.ruoyi.system.service.IVehicleGpsSegmentMileageService;
import com.ruoyi.system.service.IVehicleMileageStatsService;
import com.ruoyi.system.service.ISysConfigService;

/**
 * 车辆GPS分段里程Service业务层处理
 */
@Service
public class VehicleGpsSegmentMileageServiceImpl implements IVehicleGpsSegmentMileageService {
    
    private static final Logger logger = LoggerFactory.getLogger(VehicleGpsSegmentMileageServiceImpl.class);
    
    /** 地球半径（公里） */
    private static final double EARTH_RADIUS_KM = 6371.0;
    
    /** 天地图批量路径规划API */
    private static final String TIANDITU_ROUTE_API = "http://api.tianditu.gov.cn/drive";
    
    @Autowired
    private VehicleGpsSegmentMileageMapper segmentMileageMapper;
    
    @Autowired
    private VehicleGpsMapper vehicleGpsMapper;
    
    @Autowired
    private SysTaskMapper sysTaskMapper;
    
    @Autowired
    private TiandituMapConfig tiandituMapConfig;
    
    @Autowired
    private ISysConfigService configService;
    
    @Autowired
    private RedisCache redisCache;
    
    @Autowired
    private IVehicleMileageStatsService mileageStatsService;
    
    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

    @Override
    public VehicleGpsSegmentMileage selectVehicleGpsSegmentMileageById(Long segmentId) {
        return segmentMileageMapper.selectVehicleGpsSegmentMileageById(segmentId);
    }

    @Override
    public List<VehicleGpsSegmentMileage> selectVehicleGpsSegmentMileageList(VehicleGpsSegmentMileage vehicleGpsSegmentMileage) {
        return segmentMileageMapper.selectVehicleGpsSegmentMileageList(vehicleGpsSegmentMileage);
    }

    @Override
    public int insertVehicleGpsSegmentMileage(VehicleGpsSegmentMileage vehicleGpsSegmentMileage) {
        return segmentMileageMapper.insertVehicleGpsSegmentMileage(vehicleGpsSegmentMileage);
    }

    @Override
    public int updateVehicleGpsSegmentMileage(VehicleGpsSegmentMileage vehicleGpsSegmentMileage) {
        return segmentMileageMapper.updateVehicleGpsSegmentMileage(vehicleGpsSegmentMileage);
    }

    @Override
    public int deleteVehicleGpsSegmentMileageByIds(Long[] segmentIds) {
        return segmentMileageMapper.deleteVehicleGpsSegmentMileageByIds(segmentIds);
    }

    @Override
    public int deleteVehicleGpsSegmentMileageById(Long segmentId) {
        return segmentMileageMapper.deleteVehicleGpsSegmentMileageById(segmentId);
    }

    @Override
    public int batchCalculateSegmentMileage(Date startTime, Date endTime) {
        try {
            // 查询所有活跃车辆
            List<Long> vehicleIds = vehicleGpsMapper.selectActiveVehicleIds();
            
            if (vehicleIds == null || vehicleIds.isEmpty()) {
                logger.info("没有找到活跃车辆");
                return 0;
            }
            
            int successCount = 0;
            for (Long vehicleId : vehicleIds) {
                try {
                    int segmentCount = calculateVehicleSegmentMileage(vehicleId, startTime, endTime);
                    if (segmentCount > 0) {
                        successCount++;
                    }
                } catch (Exception e) {
                    logger.error("计算车辆 {} 的分段里程失败", vehicleId, e);
                }
            }
            
            logger.info("批量分段里程计算完成 - 时间范围: {} 到 {}, 总车辆数: {}, 成功: {}", 
                       startTime, endTime, vehicleIds.size(), successCount);
            return successCount;
            
        } catch (Exception e) {
            logger.error("批量计算分段里程失败", e);
            throw new RuntimeException("批量计算失败: " + e.getMessage());
        }
    }

    @Override
    public int compensateCalculation(int lookbackDays) {
        try {
            // 计算时间范围
            Calendar cal = Calendar.getInstance();
            Date endTime = cal.getTime();
            cal.add(Calendar.DAY_OF_MONTH, -lookbackDays);
            Date startTime = cal.getTime();
            
            logger.info("开始补偿计算 - 回溯天数: {}, 时间范围: {} 到 {}", lookbackDays, startTime, endTime);
            
            // 查询所有活跃车辆
            List<Long> vehicleIds = vehicleGpsMapper.selectActiveVehicleIds();
            
            if (vehicleIds == null || vehicleIds.isEmpty()) {
                logger.info("没有找到活跃车辆");
                return 0;
            }
            
            int successCount = 0;
            int totalUncalculated = 0;
            
            for (Long vehicleId : vehicleIds) {
                try {
                    // 查询该车辆未被计算的GPS数据
                    List<VehicleGps> uncalculatedGps = vehicleGpsMapper.selectUncalculatedGps(vehicleId, startTime, endTime);
                    
                    if (uncalculatedGps == null || uncalculatedGps.isEmpty()) {
                        logger.debug("车辆 {} 没有未计算的GPS数据", vehicleId);
                        continue;
                    }
                    
                    totalUncalculated += uncalculatedGps.size();
                    logger.info("车辆 {} 发现 {} 个未计算的GPS点，开始补偿计算...", 
                               vehicleId, uncalculatedGps.size());
                    
                    // 重新计算该车辆在该时间范围的分段里程
                    // 注意：这里会重新计算整个时间范围，确保边缘节点被正确处理
                    int segmentCount = calculateVehicleSegmentMileage(vehicleId, startTime, endTime);
                    
                    if (segmentCount > 0) {
                        successCount++;
                        logger.info("车辆 {} 补偿计算完成，生成 {} 个分段记录", vehicleId, segmentCount);
                    }
                } catch (Exception e) {
                    logger.error("车辆 {} 补偿计算失败", vehicleId, e);
                }
            }
            
            logger.info("补偿计算完成 - 总车辆数: {}, 未计算GPS点数: {}, 成功车辆数: {}", 
                       vehicleIds.size(), totalUncalculated, successCount);
            return successCount;
            
        } catch (Exception e) {
            logger.error("补偿计算失败", e);
            throw new RuntimeException("补偿计算失败: " + e.getMessage());
        }
    }

    @Override
    public int calculateVehicleSegmentMileage(Long vehicleId, Date startTime, Date endTime) {
        try {
            // 获取配置的时间间隔（分钟）
            int segmentMinutes = configService.selectConfigByKey("gps.mileage.segment.minutes") != null 
                ? Integer.parseInt(configService.selectConfigByKey("gps.mileage.segment.minutes")) 
                : 5;
            
            // 获取计算方式配置
            String calculateMethod = configService.selectConfigByKey("gps.mileage.calculate.method");
            if (calculateMethod == null || calculateMethod.isEmpty()) {
                calculateMethod = "tianditu";
            }
            
            // 获取是否跳过已计算GPS点的配置
            String skipCalculatedConfig = configService.selectConfigByKey("gps.mileage.skip.calculated");
            boolean skipCalculated = skipCalculatedConfig == null || "true".equalsIgnoreCase(skipCalculatedConfig);
            
            // 查询车辆在时间范围内的GPS数据
            List<VehicleGps> gpsList = vehicleGpsMapper.selectGpsDataByTimeRange(vehicleId, startTime, endTime);
            
            if (gpsList == null || gpsList.isEmpty()) {
                logger.debug("车辆ID: {} 在时间范围 {} 到 {} 内无GPS数据", vehicleId, startTime, endTime);
                return 0;
            }
            
            logger.info("车辆ID: {} 查询到 {} 条GPS数据", vehicleId, gpsList.size());
            
            // 按时间段分组GPS数据
            Map<Date, List<VehicleGps>> segmentedData = segmentGpsDataByTime(gpsList, segmentMinutes);
            
            int savedCount = 0;
            VehicleGps previousSegmentLastPoint = null; // 记录上一个时间段的最后一个点
            
            // 遍历每个时间段，计算里程
            for (Map.Entry<Date, List<VehicleGps>> entry : segmentedData.entrySet()) {
                Date segmentStartTime = entry.getKey();
                List<VehicleGps> segmentGpsList = entry.getValue();
                
                if (segmentGpsList.size() < 2) {
                    // 如果本段只有1个点，但有上一段的最后一个点，仍可计算跨段距离
                    if (segmentGpsList.size() == 1 && previousSegmentLastPoint != null) {
                        // 保留当前点作为下一段的前置点，但不创建记录
                        previousSegmentLastPoint = segmentGpsList.get(0);
                    }
                    continue; // 至少需要2个点才能计算距离
                }
                
                // 检查是否已存在该时间段的记录
                VehicleGpsSegmentMileage existing = segmentMileageMapper.selectByVehicleIdAndTime(vehicleId, segmentStartTime);
                if (existing != null) {
                    logger.debug("车辆 {} 时间段 {} 的分段里程已存在，跳过", vehicleId, segmentStartTime);
                    // 更新上一段最后一个点
                    previousSegmentLastPoint = segmentGpsList.get(segmentGpsList.size() - 1);
                    continue;
                }
                
                // 计算时间段的结束时间
                Calendar cal = Calendar.getInstance();
                cal.setTime(segmentStartTime);
                cal.add(Calendar.MINUTE, segmentMinutes);
                Date segmentEndTime = cal.getTime();
                
                // 计算该时间段的里程（包括跨段距离）
                BigDecimal distance = calculateSegmentDistanceWithGap(segmentGpsList, calculateMethod, previousSegmentLastPoint);
                
                // 收集GPS ID列表（包括上一段的最后一个点，因为跨段间隙距离也用到了它）
                List<Long> gpsIdList = new ArrayList<>();
                // 如果有上一段的最后一个点，先添加它的ID
                if (previousSegmentLastPoint != null && previousSegmentLastPoint.getGpsId() != null) {
                    gpsIdList.add(previousSegmentLastPoint.getGpsId());
                }
                // 再添加当前段的所有GPS点ID
                for (VehicleGps gps : segmentGpsList) {
                    if (gps.getGpsId() != null) {
                        gpsIdList.add(gps.getGpsId());
                    }
                }
                String gpsIds = gpsIdList.stream()
                    .map(String::valueOf)
                    .collect(java.util.stream.Collectors.joining(","));
                
                // 创建分段里程记录
                VehicleGpsSegmentMileage segment = new VehicleGpsSegmentMileage();
                segment.setVehicleId(vehicleId);
                
                // 从GPS数据或车辆表获取车牌号
                String vehicleNo = segmentGpsList.get(0).getVehicleNo();
                if (vehicleNo == null || vehicleNo.trim().isEmpty()) {
                    // GPS数据中没有车牌号，从车辆表查询
                    VehicleInfo vehicleInfo = vehicleInfoMapper.selectVehicleInfoById(vehicleId);
                    if (vehicleInfo != null) {
                        vehicleNo = vehicleInfo.getVehicleNo();
                    }
                }
                segment.setVehicleNo(vehicleNo);
                
                segment.setSegmentStartTime(segmentStartTime);
                segment.setSegmentEndTime(segmentEndTime);
                
                // 起点坐标
                VehicleGps firstPoint = segmentGpsList.get(0);
                segment.setStartLongitude(BigDecimal.valueOf(firstPoint.getLongitude()));
                segment.setStartLatitude(BigDecimal.valueOf(firstPoint.getLatitude()));
                
                // 终点坐标
                VehicleGps lastPoint = segmentGpsList.get(segmentGpsList.size() - 1);
                segment.setEndLongitude(BigDecimal.valueOf(lastPoint.getLongitude()));
                segment.setEndLatitude(BigDecimal.valueOf(lastPoint.getLatitude()));
                
                segment.setSegmentDistance(distance);
                segment.setGpsPointCount(gpsIdList.size()); // GPS点数：包括边缘点 + 当前段的点
                segment.setGpsIds(gpsIds); // 设置GPS ID列表
                segment.setCalculateMethod(calculateMethod);
                
                // 查询并关联正在执行的任务
                associateActiveTask(segment, vehicleId, segmentStartTime, segmentEndTime);
                
                // 保存到数据库
                segmentMileageMapper.insertVehicleGpsSegmentMileage(segment);
                
                // 更新上一段最后一个点，供下一段使用
                previousSegmentLastPoint = segmentGpsList.get(segmentGpsList.size() - 1);
                
                // 记录已计算的GPS点到状态表（如果开启了重复计算控制）
                if (skipCalculated && segment.getSegmentId() != null) {
                    for (Long gpsId : gpsIdList) {
                        try {
                            segmentMileageMapper.insertGpsCalculated(gpsId, segment.getSegmentId(), vehicleId);
                        } catch (Exception e) {
                            // 忽略重复键异常，继续处理
                            logger.debug("记录GPS计算状态失败，可能已存在: gpsId={}", gpsId);
                        }
                    }
                }
                
                savedCount++;
                
                logger.debug("车辆 {} 时间段 {} 到 {} 里程: {}km, GPS点数: {}, GPS IDs: {}", 
                           vehicleId, segmentStartTime, segmentEndTime, distance, segmentGpsList.size(), 
                           gpsIds.length() > 50 ? gpsIds.substring(0, 50) + "..." : gpsIds);
            }
            
            logger.info("车辆 {} 计算完成，保存了 {} 个时间段的里程数据", vehicleId, savedCount);
            
            // 自动触发汇总生成每日统计（如果有数据被保存）
            if (savedCount > 0) {
                try {
                    // 获取涉及的日期范围，触发汇总
                    Set<Date> affectedDates = new HashSet<>();
                    Calendar cal = Calendar.getInstance();
                    
                    for (Map.Entry<Date, List<VehicleGps>> entry : segmentedData.entrySet()) {
                        cal.setTime(entry.getKey());
                        cal.set(Calendar.HOUR_OF_DAY, 0);
                        cal.set(Calendar.MINUTE, 0);
                        cal.set(Calendar.SECOND, 0);
                        cal.set(Calendar.MILLISECOND, 0);
                        affectedDates.add(cal.getTime());
                    }
                    
                    // 对每个涉及的日期，触发汇总
                    for (Date statDate : affectedDates) {
                        try {
                            mileageStatsService.aggregateFromSegmentMileage(vehicleId, statDate);
                            logger.info("车辆 {} 日期 {} 的统计数据已自动汇总生成", vehicleId, statDate);
                        } catch (Exception e) {
                            logger.error("车辆 {} 日期 {} 自动汇总统计失败", vehicleId, statDate, e);
                        }
                    }
                } catch (Exception e) {
                    logger.error("触发自动汇总失败", e);
                }
            }
            
            return savedCount;
            
        } catch (Exception e) {
            logger.error("计算车辆 {} 分段里程失败", vehicleId, e);
            throw new RuntimeException("计算分段里程失败: " + e.getMessage());
        }
    }

    /**
     * 将GPS数据按时间段分组
     */
    private Map<Date, List<VehicleGps>> segmentGpsDataByTime(List<VehicleGps> gpsList, int segmentMinutes) {
        Map<Date, List<VehicleGps>> segmentedData = new LinkedHashMap<>();
        
        for (VehicleGps gps : gpsList) {
            // 解析GPS采集时间
            Date collectTime = parseDateTime(gps.getCollectTime());
            
            // 计算该GPS点所属的时间段起始时间（向下取整到最近的时间段）
            Date segmentStart = getSegmentStartTime(collectTime, segmentMinutes);
            
            // 添加到对应时间段
            segmentedData.computeIfAbsent(segmentStart, k -> new ArrayList<>()).add(gps);
        }
        
        return segmentedData;
    }

    /**
     * 获取时间段的起始时间（向下取整）
     */
    private Date getSegmentStartTime(Date time, int segmentMinutes) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(time);
        
        // 将分钟数向下取整到最近的分段
        int minute = cal.get(Calendar.MINUTE);
        int segmentIndex = minute / segmentMinutes;
        int alignedMinute = segmentIndex * segmentMinutes;
        
        cal.set(Calendar.MINUTE, alignedMinute);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        
        return cal.getTime();
    }

    /**
     * 计算一个时间段内的总里程（包括与上一段的间隙距离）
     * @param gpsList 当前时间段的GPS点列表
     * @param calculateMethod 计算方式
     * @param previousLastPoint 上一个时间段的最后一个点（可为null）
     */
    private BigDecimal calculateSegmentDistanceWithGap(List<VehicleGps> gpsList, String calculateMethod, VehicleGps previousLastPoint) {
        if (gpsList == null || gpsList.size() < 2) {
            return BigDecimal.ZERO;
        }
        
        BigDecimal totalDistance = BigDecimal.ZERO;
        
        // 1. 先计算跨段间隙距离（上一段最后一个点 -> 当前段第一个点）
        if (previousLastPoint != null) {
            VehicleGps currentFirstPoint = gpsList.get(0);
            double gapDistance = calculateHaversineDistance(
                previousLastPoint.getLatitude().doubleValue(),
                previousLastPoint.getLongitude().doubleValue(),
                currentFirstPoint.getLatitude().doubleValue(),
                currentFirstPoint.getLongitude().doubleValue()
            );
            totalDistance = totalDistance.add(BigDecimal.valueOf(gapDistance));
            
            logger.debug("跨段间隙距离: {}km (上一段末点 -> 当前段首点)", 
                String.format("%.3f", gapDistance));
        }
        
        // 2. 再计算当前段内部的距离
        BigDecimal segmentInternalDistance;
        if ("tianditu".equalsIgnoreCase(calculateMethod)) {
            segmentInternalDistance = calculateDistanceByTianditu(gpsList);
        } else {
            segmentInternalDistance = calculateDistanceByHaversine(gpsList);
        }
        totalDistance = totalDistance.add(segmentInternalDistance);
        
        return totalDistance.setScale(3, RoundingMode.HALF_UP);
    }
    
    /**
     * 计算一个时间段内的总里程（仅段内距离）
     */
    private BigDecimal calculateSegmentDistance(List<VehicleGps> gpsList, String calculateMethod) {
        if (gpsList == null || gpsList.size() < 2) {
            return BigDecimal.ZERO;
        }
        
        BigDecimal totalDistance = BigDecimal.ZERO;
        
        if ("tianditu".equalsIgnoreCase(calculateMethod)) {
            // 使用天地图API计算（批量计算更精确）
            totalDistance = calculateDistanceByTianditu(gpsList);
        } else {
            // 使用Haversine公式计算（直线距离，更快但不够精确）
            totalDistance = calculateDistanceByHaversine(gpsList);
        }
        
        return totalDistance.setScale(3, RoundingMode.HALF_UP);
    }

    /**
     * 使用天地图API计算距离
     */
    private BigDecimal calculateDistanceByTianditu(List<VehicleGps> gpsList) {
        try {
            // 天地图路径规划API有点数限制，如果点太多需要分批处理
            int maxPointsPerRequest = 50; // 天地图API建议不超过50个点
            BigDecimal totalDistance = BigDecimal.ZERO;
            
            // 如果GPS点数较少，直接使用Haversine公式（避免频繁调用API）
            if (gpsList.size() <= 3) {
                return calculateDistanceByHaversine(gpsList);
            }
            
            // 分批处理
            for (int i = 0; i < gpsList.size() - 1; i += maxPointsPerRequest) {
                int endIndex = Math.min(i + maxPointsPerRequest, gpsList.size());
                List<VehicleGps> batchList = gpsList.subList(i, endIndex);
                
                BigDecimal batchDistance = calculateBatchDistanceByTianditu(batchList);
                totalDistance = totalDistance.add(batchDistance);
            }
            
            return totalDistance;
            
        } catch (Exception e) {
            logger.warn("天地图API计算距离失败，降级使用Haversine公式: {}", e.getMessage());
            return calculateDistanceByHaversine(gpsList);
        }
    }

    /**
     * 使用天地图API计算一批GPS点的距离
     */
    private BigDecimal calculateBatchDistanceByTianditu(List<VehicleGps> gpsList) {
        try {
            // 简化处理：计算相邻点之间的直线距离总和
            // 注：天地图的路径规划API主要用于导航，这里用简化的距离计算
            BigDecimal totalDistance = BigDecimal.ZERO;
            
            for (int i = 0; i < gpsList.size() - 1; i++) {
                VehicleGps p1 = gpsList.get(i);
                VehicleGps p2 = gpsList.get(i + 1);
                
                double distance = calculateHaversineDistance(
                    p1.getLatitude().doubleValue(), 
                    p1.getLongitude().doubleValue(),
                    p2.getLatitude().doubleValue(), 
                    p2.getLongitude().doubleValue()
                );
                
                totalDistance = totalDistance.add(BigDecimal.valueOf(distance));
            }
            
            return totalDistance;
            
        } catch (Exception e) {
            logger.error("天地图批量距离计算失败", e);
            throw e;
        }
    }

    /**
     * 使用Haversine公式计算距离
     */
    private BigDecimal calculateDistanceByHaversine(List<VehicleGps> gpsList) {
        BigDecimal totalDistance = BigDecimal.ZERO;
        
        for (int i = 0; i < gpsList.size() - 1; i++) {
            VehicleGps p1 = gpsList.get(i);
            VehicleGps p2 = gpsList.get(i + 1);
            
            double distance = calculateHaversineDistance(
                p1.getLatitude().doubleValue(), 
                p1.getLongitude().doubleValue(),
                p2.getLatitude().doubleValue(), 
                p2.getLongitude().doubleValue()
            );
            
            totalDistance = totalDistance.add(BigDecimal.valueOf(distance));
        }
        
        return totalDistance;
    }

    /**
     * 使用Haversine公式计算两点之间的距离（公里）
     */
    private double calculateHaversineDistance(double lat1, double lon1, double lat2, double lon2) {
        // 如果起点和终点经纬度相同，直接返回0，避免不必要的计算
        if (lat1 == lat2 && lon1 == lon2) {
            return 0.0;
        }
        
        // 将角度转换为弧度
        double dLat = Math.toRadians(lat2 - lat1);
        double dLon = Math.toRadians(lon2 - lon1);
        double rLat1 = Math.toRadians(lat1);
        double rLat2 = Math.toRadians(lat2);

        // Haversine公式
        double a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                   Math.cos(rLat1) * Math.cos(rLat2) *
                   Math.sin(dLon / 2) * Math.sin(dLon / 2);
        
        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
        
        return EARTH_RADIUS_KM * c;
    }

    /**
     * 解析日期时间字符串
     */
    private Date parseDateTime(String dateTimeStr) {
        if (dateTimeStr == null || dateTimeStr.trim().isEmpty()) {
            throw new RuntimeException("日期时间字符串不能为空");
        }
        
        try {
            java.text.SimpleDateFormat sdf = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            sdf.setLenient(false);
            return sdf.parse(dateTimeStr.trim());
        } catch (Exception e) {
            throw new RuntimeException("日期时间格式错误: " + dateTimeStr + ", 应为 yyyy-MM-dd HH:mm:ss", e);
        }
    }
    
    /**
     * 查询并关联车辆正在执行的任务
     * @param segment 分段里程记录
     * @param vehicleId 车辆ID
     * @param segmentStartTime 时间段开始时间
     * @param segmentEndTime 时间段结束时间
     */
    private void associateActiveTask(VehicleGpsSegmentMileage segment, Long vehicleId, 
                                      Date segmentStartTime, Date segmentEndTime) {
        try {
            // 查询该车辆正在执行的任务列表
            List<SysTask> activeTasks = sysTaskMapper.selectActiveTasksByVehicleId(vehicleId);
            
            if (activeTasks == null || activeTasks.isEmpty()) {
                logger.debug("车辆 {} 在时间段 {} - {} 没有正在执行的任务", vehicleId, segmentStartTime, segmentEndTime);
                return;
            }
            
            // 遍历任务，查找与当前时间段有重叠的任务
            for (SysTask task : activeTasks) {
                // 获取任务的实际执行时间，如果没有实际时间则使用计划时间
                Date taskStart = task.getActualStartTime() != null ? task.getActualStartTime() : task.getPlannedStartTime();
                Date taskEnd = task.getActualEndTime() != null ? task.getActualEndTime() : task.getPlannedEndTime();
                
                // 判断时间段是否有重叠
                if (isTimeOverlap(segmentStartTime, segmentEndTime, taskStart, taskEnd)) {
                    // 关联任务ID和任务编号
                    segment.setTaskId(task.getTaskId());
                    segment.setTaskCode(task.getTaskCode());
                    
                    logger.debug("车辆 {} 时间段 {} - {} 关联任务: taskId={}, taskCode={}", 
                               vehicleId, segmentStartTime, segmentEndTime, task.getTaskId(), task.getTaskCode());
                    break; // 找到一个匹配的任务即可
                }
            }
            
        } catch (Exception e) {
            // 关联任务失败不影响主流程，只记录日志
            logger.warn("关联车辆 {} 的任务信息失败", vehicleId, e);
        }
    }
    
    /**
     * 判断两个时间段是否有重叠
     * @param start1 时间段1开始
     * @param end1 时间段1结束
     * @param start2 时间段2开始
     * @param end2 时间段2结束
     * @return true-有重叠, false-无重叠
     */
    private boolean isTimeOverlap(Date start1, Date end1, Date start2, Date end2) {
        // 任何时间为null，返回false
        if (start1 == null || end1 == null || start2 == null || end2 == null) {
            return false;
        }
        
        // 两个时间段有重叠的条件：
        // start1 < end2 && end1 > start2
        return start1.before(end2) && end1.after(start2);
    }
}