#美团本地生活架构

// 配送调度：骑手匹配算法
@Service
public class DispatchService {

    @Autowired private MerchantStore merchantStore;
    @Autowired private RiderService riderService;
    @Autowired private DistanceService distanceService;

    public DispatchDecision dispatch(Long orderId, Location deliveryAddress) {
        Merchant merchant = merchantStore.findByOrder(orderId);
        Location merchantLocation = merchant.getLocation();

        // 1. 找出附近可用的骑手（10km 范围内）
        List<Rider> nearbyRiders = riderService.findNearby(
            merchantLocation.getLat(),
            merchantLocation.getLng(),
            10000  // 10km
        );

        // 2. 过滤出正在等单的骑手（不是正在配送中的）
        nearbyRiders = nearbyRiders.stream()
            .filter(Rider::isIdle)
            .collect(Collectors.toList());

        if (nearbyRiders.isEmpty()) {
            return DispatchDecision.noRiderAvailable();
        }

        // 3. 并行计算每个骑手的配送成本
        List<RiderCost> riderCosts = nearbyRiders.parallelStream()
            .map(rider -> calculateCost(rider, merchant, deliveryAddress))
            .collect(Collectors.toList());

        // 4. 选择最优骑手（综合考虑距离、骑手当前负载、时间窗口）
        RiderCost best = riderCosts.stream()
            .min(Comparator.comparingDouble(RiderCost::getTotalCost))
            .orElseThrow();

        // 5. 绑定订单
        riderService.assignOrder(best.getRiderId(), orderId);

        return DispatchDecision.success(best.getRiderId(), best.getEstimatedTime());
    }

    private RiderCost calculateCost(Rider rider, Merchant merchant,
                                   Location deliveryAddress) {
        // 距离成本：骑手到商家的距离
        double distToMerchant = distanceService.distance(
            rider.getLocation(), merchant.getLocation());

        // 配送成本：商家到用户地址的距离
        double distToUser = distanceService.distance(
            merchant.getLocation(), deliveryAddress);

        // 时间成本：骑手当前等单时间（等得越久越优先派单）
        long waitTime = System.currentTimeMillis() - rider.getLastDeliveryTime();

        // 综合成本
        double totalCost = distToMerchant * 1.0
                         + distToUser * 0.5
                         - waitTime * 0.1;  // 负号：等得越久成本越低

        return new RiderCost(rider, distToMerchant, distToUser,
            waitTime, totalCost);
    }
}

// 多点配送：路径规划
@Service
public class MultiStopDispatcher {

    // 骑手一次接 N 单，按最优路线配送
    public DeliveryPlan planMultiStopRoute(Rider rider, List<Order> orders) {
        Merchant firstPickup = orders.get(0).getMerchant();
        Location currentPos = rider.getLocation();

        List<DeliveryStop> plan = new ArrayList<>();

        for (Order order : orders) {
            // 1. 前往商家取餐
            DeliveryStop pickup = new DeliveryStop();
            pickup.setType(StopType.PICKUP);
            pickup.setLocation(order.getMerchant().getLocation());
            pickup.setOrderId(order.getId());
            pickup.setEstimatedArrival(
                calculateArrivalTime(currentPos, pickup.getLocation()));
            plan.add(pickup);
            currentPos = pickup.getLocation();

            // 2. 前往用户地址送餐
            DeliveryStop dropoff = new DeliveryStop();
            dropoff.setType(StopType.DROPOFF);
            dropoff.setLocation(order.getDeliveryAddress());
            dropoff.setOrderId(order.getId());
            dropoff.setEstimatedArrival(
                calculateArrivalTime(currentPos, dropoff.getLocation()));
            dropoff.setTimeWindow(order.getLatestAcceptableTime()); // 用户可接受的最晚时间
            plan.add(dropoff);
            currentPos = dropoff.getLocation();
        }

        // 3. 优化路线顺序（贪心算法 + 2-opt 局部优化）
        plan = optimizeRouteOrder(plan);

        // 4. 验证时间窗口约束
        validateTimeWindows(plan);

        return new DeliveryPlan(rider.getId(), plan);
    }

    // 2-opt 局部优化：交换路径中两条边的中点，看是否能缩短总距离
    private List<DeliveryStop> optimizeRouteOrder(List<DeliveryStop> plan) {
        double bestDistance = calculateTotalDistance(plan);

        for (int i = 1; i < plan.size() - 2; i++) {
            for (int j = i + 1; j < plan.size() - 1; j++) {
                List<DeliveryStop> newPlan = twoOptSwap(plan, i, j);
                double newDistance = calculateTotalDistance(newPlan);

                if (newDistance < bestDistance) {
                    plan = newPlan;
                    bestDistance = newDistance;
                }
            }
        }

        return plan;
    }
}

// 需求预测：提前 30 分钟预调度骑手
@Service
public class DemandPredictionService {

    @Autowired private HistoryOrderStore orderHistory;

    // 每 5 分钟跑一次预测
    @Scheduled(fixedRate = 5 * 60 * 1000)
    public void predictAndPreposition() {
        // 1. 按 1 公里网格统计历史订单分布
        Map<GeoHash, Integer> demandDistribution = predictDemand30min();

        // 2. 获取当前骑手分布
        Map<GeoHash, Integer> riderDistribution = riderService.getCurrentDistribution();

        // 3. 计算供需差
        Map<GeoHash, Double> gapMap = new HashMap<>();
        for (GeoHash cell : demandDistribution.keySet()) {
            double demand = demandDistribution.get(cell);
            double supply = riderDistribution.getOrDefault(cell, 0);
            gapMap.put(cell, demand - supply);
        }

        // 4. 发送预调度指令：引导骑手前往需求高的区域
        for (Map.Entry<GeoHash, Double> entry : gapMap.entrySet()) {
            if (entry.getValue() > 5) {  // 需求超过供给 5 单
                sendPrepositioningDirective(entry.getKey(), entry.getValue());
            }
        }
    }

    // 需求预测模型：基于历史数据 + 当前实时数据
    private Map<GeoHash, Integer> predictDemand30min() {
        LocalDateTime now = LocalDateTime.now();
        // 获取同时间（昨天/上周同期）的历史数据
        LocalDateTime[] historySlots = {
            now.minusDays(1),
            now.minusDays(7),
            now.minusDays(14)
        };

        Map<GeoHash, Integer> prediction = new HashMap<>();

        for (GeoHash cell : allCells) {
            int totalHistory = 0;
            for (LocalDateTime slot : historySlots) {
                totalHistory += orderHistory.getCount(cell, slot);
            }
            int avg = totalHistory / historySlots.length;

            // 加上实时趋势修正（当前 30 分钟的实时流量）
            double trendFactor = getRealTimeTrendFactor(cell);
            prediction.put(cell, (int) (avg * trendFactor));
        }

        return prediction;
    }
}