#春晚红包架构

// 多活路由服务：根据用户 ID 路由到不同数据中心
@Service
public class MultiSiteRouter {

    // 数据中心列表（生产环境通常 3-5 个）
    private static final List<DataCenter> DATACENTERS = List.of(
        new DataCenter("dc-bj", "北京", Region.NORTH),
        new DataCenter("dc-sh", "上海", Region.EAST),
        new DataCenter("dc-sz", "深圳", Region.SOUTH)
    );

    // 一致性哈希：确保同一用户的请求尽量路由到同一数据中心
    private final ConsistentHashRing<String> hashRing;

    public MultiSiteRouter() {
        this.hashRing = new ConsistentHashRing<>(
            DATACENTERS.stream()
                .map(DataCenter::getId)
                .collect(Collectors.toList()),
            150  // 虚拟节点数量
        );
    }

    public DataCenter route(Long userId) {
        String dcId = hashRing.get(userId.toString());
        return DATACENTERS.stream()
            .filter(dc -> dc.getId().equals(dcId))
            .findFirst()
            .orElse(DATACENTERS.get(0));
    }

    // 故障切换：当某个 DC 不可用时，自动切换
    public DataCenter routeWithFailover(Long userId, DataCenter... excludeDCs) {
        String excluded = Arrays.stream(excludeDCs)
            .map(DataCenter::getId)
            .collect(Collectors.joining(","));

        for (int i = 0; i < DATACENTERS.size(); i++) {
            DataCenter dc = route(userId);
            if (!excluded.contains(dc.getId())) {
                return dc;
            }
        }
        return DATACENTERS.get(0);  // 保底
    }
}

// 红包发放服务：预扣 + 异步发放
@Service
public class HongbaoService {

    @Autowired private RedisTemplate<String, String> redisTemplate;
    @Autowired private MessageQueueTemplate mqTemplate;
    @Autowired private UserFundService fundService;

    /**
     * 预扣红包资格（快速路径）
     * 用户摇一摇后，系统快速判断是否有红包，有则预扣
     * 红包金额的真正发放由消息队列异步处理
     */
    public HongbaoPreResult preDeduct(Long userId, String activityId) {
        String activityKey = "hongbao:activity:" + activityId;
        String userKey = "hongbao:user:" + activityId + ":" + userId;

        // 1. 检查用户是否已经摇过（防重）
        if (Boolean.TRUE.equals(redisTemplate.hasKey(userKey))) {
            return HongbaoPreResult.alreadyGrabbed();
        }

        // 2. Lua 脚本：原子预扣红包数量
        String luaScript = """
            local remaining = tonumber(redis.call('GET', KEYS[1]) or 0)
            if remaining > 0 then
                redis.call('DECR', KEYS[1])
                redis.call('SET', KEYS[2], '1', 'EX', 86400)
                return remaining - 1
            end
            return -1
            """;

        Long result = redisTemplate.execute(
            new RedisScript<>(luaScript, Long.class),
            List.of(activityKey, userKey),
            "");

        if (result == null || result < 0) {
            return HongbaoPreResult.soldOut();
        }

        // 3. 发送异步消息，真正发放红包
        // 注意：这里只发送消息，不阻塞等待结果
        sendHongbaoAsync(userId, activityId, result);

        return HongbaoPreResult.success();
    }

    /**
     * 异步发放红包
     * 由独立的 consumer 处理，真正的资金扣减在这里
     */
    @Async("hongbaoExecutor")
    public void sendHongbaoAsync(Long userId, String activityId, Long remainCount) {
        // 异步处理：等待一小段时间后发放
        // 这样可以让请求快速响应，用户先看到「恭喜获得红包」
        // 实际金额可能几秒后才到账
        try {
            Thread.sleep(ThreadLocalRandom.current().nextInt(100, 500));
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 调用资金系统，真正扣减余额
        fundService.grantHongbao(userId, calculateAmount(remainCount));
    }
}

// 资金发放服务：幂等性保证
@Service
public class FundService {

    @Autowired private RedisTemplate<String, String> redisTemplate;

    /**
     * 发放红包：幂等设计，确保不会重复发放
     */
    public FundResult grantHongbao(Long userId, BigDecimal amount,
                                   String transactionId) {
        // 幂等 Key：每个 transactionId 只处理一次
        String idempotentKey = "fund:idempotent:" + transactionId;

        // SETNX 保证幂等
        Boolean success = redisTemplate.opsForValue()
            .setIfAbsent(idempotentKey, "PROCESSING",
                Duration.ofMinutes(30));

        if (Boolean.FALSE.equals(success)) {
            // 已处理过，直接返回成功（防重复）
            return FundResult.success("重复请求");
        }

        try {
            // 真正的资金操作
            return executeFundTransfer(userId, amount, transactionId);

        } catch (Exception e) {
            // 失败：删除幂等标记，允许重试
            redisTemplate.delete(idempotentKey);
            throw e;
        }
    }

    private FundResult executeFundTransfer(Long userId, BigDecimal amount,
                                            String transactionId) {
        // 1. 检查用户余额
        BigDecimal balance = getUserBalance(userId);
        if (balance.add(amount).compareTo(BigDecimal.ZERO) < 0) {
            return FundResult.failed("余额不足");
        }

        // 2. 开启分布式事务（两阶段提交）
        // 实际生产中使用 TCC 或 Saga 模式
        transactionTemplate.execute(status -> {
            // 扣减企业账户
            deductCorpAccount(amount);

            // 增加用户余额
            addUserBalance(userId, amount);

            // 记录流水
            saveTransactionLog(userId, transactionId, amount);

            return null;
        });

        return FundResult.success();
    }
}

// 降级策略：五级降级
public class DegradeStrategy {

    // 级别 1：关闭实时查询
    // 红包发放后，不实时更新用户余额，改为异步更新
    public void degradeLevel1() {
        redisTemplate.opsForValue().set(
            "config:degrade:realTimeBalance", "false",
            Duration.ofHours(4));
    }

    // 级别 2：关闭用户反馈
    // 用户摇到红包后，不实时显示金额，改为「红包已到账，请查收」
    public void degradeLevel2() {
        redisTemplate.opsForValue().set(
            "config:degrade:showAmount", "false",
            Duration.ofHours(4));
    }

    // 级别 3：关闭活动详情页
    // 减少非核心请求，释放服务器资源
    public void degradeLevel3() {
        redisTemplate.opsForValue().set(
            "config:degrade:activityPage", "false",
            Duration.ofHours(4));
    }

    // 级别 4：限流降级
    // 超出阈值的请求直接返回「系统繁忙」
    public void degradeLevel4(int threshold) {
        redisTemplate.opsForValue().set(
            "config:rateLimit:threshold",
            String.valueOf(threshold),
            Duration.ofHours(4));
    }

    // 级别 5：停止活动
    // 最后手段，通知春晚导演组
    public void degradeLevel5() {
        alertService.alertCritical("HongbaoActivityDowngrade");
    }
}