#地理分片

@Service
public class GeoAwareRouter {

    private final Map<String, List<String>> regionPriority;
    private final LoadBalancer loadBalancer;

    public GeoAwareRouter() {
        // 定义区域优先级：用户区域 -> 机房列表（按优先级排序）
        this.regionPriority = Map.of(
            "CN_NORTH", List.of("CN_BJ", "CN_SH", "US_EAST"), // 北京用户优先北京机房
            "CN_SOUTH", List.of("CN_SH", "CN_BJ", "US_EAST"), // 上海用户优先上海机房
            "US_EAST", List.of("US_EAST", "US_WEST", "CN_BJ"),
            "US_WEST", List.of("US_WEST", "US_EAST", "CN_SH")
        );
    }

    public String route(String userId, String userRegion) {
        List<String> priorities = regionPriority.getOrDefault(
            userRegion,
            List.of("US_EAST", "US_WEST")
        );

        // 按优先级尝试路由
        for (String region : priorities) {
            if (isRegionHealthy(region)) {
                return selectNode(region);
            }
        }

        // 所有优先级机房都不可用，降级到默认
        return selectNode("US_EAST");
    }

    private String selectNode(String region) {
        List<String> nodes = getNodesByRegion(region);
        return loadBalancer.select(nodes);
    }
}

@Service
public class ComplianceShardRouter {

    private final Map<String, String> dataResidencyRules;

    public ComplianceShardRouter() {
        // 定义数据主权规则
        this.dataResidencyRules = Map.of(
            "EU", "EU_WEST",
            "CN", "CN_EAST",
            "US", "US_CENTRAL"
        );
    }

    public String routeForUserData(User user) {
        String region = determineUserRegion(user);
        String shardRegion = dataResidencyRules.getOrDefault(region, "US_CENTRAL");

        // 确保数据存储在合规区域
        return ensureDataResidency(user.getId(), shardRegion);
    }

    private String ensureDataResidency(Long userId, String targetRegion) {
        // 检查用户数据当前存储位置
        String currentRegion = getCurrentDataRegion(userId);

        if (!currentRegion.equals(targetRegion)) {
            // 触发数据迁移（异步）
            migrateDataAsync(userId, currentRegion, targetRegion);
            // 返回当前区域（迁移期间）
            return currentRegion;
        }

        return targetRegion;
    }

    private String determineUserRegion(User user) {
        // 根据用户注册地址、IP、证件归属地确定地区
        return user.getCountryCode();
    }
}

@Service
public class CrossRegionSync {

    private final Map<String, DataSource> regionDataSources;
    private final MessageQueue mq;

    public void syncDataChange(DataChange change) {
        // 1. 先写入本地库
        writeToLocal(change);

        // 2. 发送跨区域同步消息
        SyncMessage message = new SyncMessage(
            change.getTableName(),
            change.getPrimaryKey(),
            change.getOperation(),
            change.getData(),
            System.currentTimeMillis()
        );

        // 发布到消息队列
        mq.publish("data-sync", message);
    }

    @KafkaListener(topics = "data-sync")
    public void handleSyncMessage(SyncMessage message) {
        // 接收其他区域的消息
        String currentRegion = getCurrentRegion();

        if (!message.getSourceRegion().equals(currentRegion)) {
            // 应用数据变更
            applyChange(message);
        }
    }
}

@Component
public class GeoRoutingInterceptor implements HandlerInterceptor {

    private final GeoShardRouter router;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 从请求中获取用户信息
        String userId = getUserId(request);
        String userRegion = determineRegion(request);

        // 路由到对应分片
        String targetRegion = router.route(userId, userRegion);

        // 将路由结果存入请求上下文
        request.setAttribute("targetRegion", targetRegion);

        return true;
    }

    private String determineRegion(HttpServletRequest request) {
        // 1. 优先使用请求头中的区域标识
        String region = request.getHeader("X-User-Region");
        if (region != null) return region;

        // 2. 根据 IP 地理位置确定
        String clientIp = getClientIp(request);
        return GeoIPLookup.lookup(clientIp);
    }
}

@Service
public class ConflictResolver {

    public void resolveConflict(DataChange local, DataChange remote) {
        // 基于时间戳的 LWW（Last Write Wins）
        if (remote.getTimestamp() > local.getTimestamp()) {
            applyChange(remote);
        } else {
            // 本地更近，发送本地变更到远程
            publishToRemote(local);
        }
    }

    public void resolveConflict(Order local, Order remote) {
        // 订单状态以最新状态为准
        // 金额以首次确认的为准
        if (remote.getStatus().getTimestamp() > local.getStatus().getTimestamp()) {
            local.setStatus(remote.getStatus());
        }
        if (remote.getConfirmedAmount() != null) {
            local.setConfirmedAmount(remote.getConfirmedAmount());
        }
    }
}