#滴滴出行架构

// 早期派单：最近司机优先
public class SimpleDispatchService {

    public DispatchResult dispatch(Order order) {
        Location userLocation = order.getUserLocation();

        // 1. 查询附近 5km 内的司机
        List<Driver> nearbyDrivers = driverService.findNearby(
            userLocation.getLat(),
            userLocation.getLng(),
            5000  // 5km
        );

        // 2. 按距离排序
        nearbyDrivers.sort(Comparator.comparingDouble(
            d -> distance(d.getLocation(), userLocation)));

        // 3. 推送给最近的司机
        for (Driver driver : nearbyDrivers) {
            boolean accepted = pushToDriver(driver, order);
            if (accepted) {
                return DispatchResult.success(driver.getId());
            }
            // 司机拒单，继续推下一个
        }

        return DispatchResult.noDriverAvailable();
    }
}

// 订单状态机
public class OrderStateMachine {

    public static enum OrderStatus {
        CREATED,        // 用户下单
        DISPATCHING,    // 系统派单中
        DRIVER_ACCEPTED, // 司机接单
        DRIVER_ARRIVED,  // 司机到达
        TRIP_STARTED,    // 行程开始
        TRIP_COMPLETED,  // 行程结束
        CANCELLED,      // 取消
        CLOSED          // 订单关闭（已付款）
    }

    // 状态转换规则
    public boolean canTransition(OrderStatus from, OrderStatus to) {
        Map<OrderStatus, Set<OrderStatus>> transitions = Map.of(
            CREATED, Set.of(DISPATCHING, CANCELLED),
            DISPATCHING, Set.of(DRIVER_ACCEPTED, CANCELLED),
            DRIVER_ACCEPTED, Set.of(DRIVER_ARRIVED, CANCELLED),
            DRIVER_ARRIVED, Set.of(TRIP_STARTED, CANCELLED),
            TRIP_STARTED, Set.of(TRIP_COMPLETED),
            TRIP_COMPLETED, Set.of(CLOSED),
            CANCELLED, Set.of(),
            CLOSED, Set.of()
        );
        return transitions.get(from).contains(to);
    }

    // 执行状态转换
    public void transition(Order order, OrderStatus to) {
        if (!canTransition(order.getStatus(), to)) {
            throw new IllegalStateException(
                "Cannot transition from " + order.getStatus() + " to " + to);
        }

        OrderStatus from = order.getStatus();
        order.setStatus(to);
        order.setUpdatedAt(System.currentTimeMillis());

        // 持久化
        orderRepository.save(order);

        // 发布领域事件
        eventBus.publish(new OrderStatusChangedEvent(order.getId(), from, to));
    }
}

// 司机位置缓存：Redis GEO
@Service
public class DriverLocationService {

    private static final String GEO_KEY = "driver:locations";
    private static final String AVAIL_KEY = "driver:available:";

    // 司机位置上报（每 5 秒一次）
    public void updateLocation(Long driverId, double lng, double lat) {
        // GEOADD：更新司机地理位置
        redisTemplate.opsForGeo().add(GEO_KEY, new Point(lng, lat), driverId.toString());

        // 标记可用：带 2 分钟过期时间
        String availKey = AVAIL_KEY + driverId;
        redisTemplate.opsForValue().set(availKey, "1", Duration.ofMinutes(2));
    }

    // 查询附近可用司机
    public List<Driver> findNearbyAvailable(double lng, double lat, double radiusMeters) {
        // 1. 查询附近所有司机
        Circle circle = new Circle(new Point(lng, lat),
            new Distance(radiusMeters, MetricsUnit.METERS));
        GeoResults<GeoLocation<String>> results =
            redisTemplate.opsForGeo().radius(GEO_KEY, circle);

        if (results == null) return Collections.emptyList();

        // 2. 过滤出可用司机
        return results.getContent().stream()
            .filter(r -> {
                String key = AVAIL_KEY + r.getContent().getName();
                return Boolean.TRUE.equals(redisTemplate.hasKey(key));
            })
            .map(r -> {
                Long driverId = Long.parseLong(r.getContent().getName());
                return driverService.findById(driverId);
            })
            .collect(Collectors.toList());
    }
}

// 机器学习派单：综合评分
@Service
public class MLDispatchService {

    @Autowired private MLModel rankModel;
    @Autowired private DriverService driverService;
    @Autowired private DemandService demandService;

    public DispatchDecision dispatch(Order order) {
        Location pickup = order.getPickupLocation();

        // 1. 获取候选司机（附近 5km 内）
        List<Driver> candidates = driverService.findNearby(
            pickup.getLat(), pickup.getLng(), 5000);

        // 2. 构造特征
        List<CandidateFeature> features = candidates.stream()
            .map(driver -> buildFeature(driver, order))
            .collect(Collectors.toList());

        // 3. 模型打分（批量预测，节省 RPC 调用）
        List<Double> scores = rankModel.predict(features);

        // 4. 选择分数最高的司机
        int bestIdx = 0;
        double bestScore = scores.get(0);
        for (int i = 1; i < scores.size(); i++) {
            if (scores.get(i) > bestScore) {
                bestScore = scores.get(i);
                bestIdx = i;
            }
        }

        // 5. 推送并确认
        return dispatchToDriver(order, candidates.get(bestIdx));
    }

    private CandidateFeature buildFeature(Driver driver, Order order) {
        return CandidateFeature.builder()
            // 距离特征
            .distanceToPickup(distance(driver.getLocation(), order.getPickupLocation()))
            .distanceToDestination(distance(driver.getLocation(), order.getDestination()))
            // 供需特征
            .supplyDemandRatio(demandService.getSupplyDemandRatio(order.getPickupLocation()))
            .currentDriverDensity(driverService.countNearby(order.getPickupLocation(), 3000))
            // 司机特征
            .driverAcceptRate(driver.getAcceptRate())
            .driverRating(driver.getRating())
            .driverCancellationRate(driver.getCancellationRate())
            .driverActiveHours(driver.getActiveHoursToday())
            // 顺路特征
            .detourDistance(calculateDetour(driver, order))
            .directionMatch(calculateDirectionMatch(driver, order))
            .build();
    }
}

// 需求预测：提前引导司机
@Service
public class DemandForecastService {

    // 预测未来 30 分钟的出行需求（按网格）
    public Map<GridCell, Double> forecastDemand30min() {
        Map<GridCell, Double> forecast = new HashMap<>();

        for (GridCell cell : allCells) {
            // 历史数据：上周同期、同昨天同期
            double historyAvg = getHistoryAverage(cell);

            // 实时修正：当前需求相对历史的倍数
            double realTimeFactor = getRealTimeFactor(cell);

            // 外部因素：天气、节假日、大型活动
            double externalFactor = externalFactorService.getFactor(cell);

            // 综合预测
            double forecastValue = historyAvg * realTimeFactor * externalFactor;
            forecast.put(cell, forecastValue);
        }

        return forecast;
    }

    // 发送引导：告诉司机哪些区域需求高
    public void sendGuidance(Long driverId) {
        Map<GridCell, Double> forecast = forecastDemand30min();

        // 找出预测需求最高的前 3 个区域
        List<GridCell> hotSpots = forecast.entrySet().stream()
            .sorted(Map.Entry.<GridCell, Double>comparingByValue().reversed())
            .limit(3)
            .map(Map.Entry::getKey)
            .collect(Collectors.toList());

        if (!hotSpots.isEmpty()) {
            notificationService.pushGuidance(driverId, hotSpots);
        }
    }
}