#活動 ID、活動名稱、活動開始時(shí)間、活動結(jié)束時(shí)間、活動狀態(tài)（進(jìn)行中、已結(jié)束等）、抽獎次數(shù)限制、活動描述
CREATE TABLE lottery_activity (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    activity_name VARCHAR(255) NOT NULL,
    start_time DATETIME NOT NULL,
    end_time DATETIME NOT NULL,
    status TINYINT NOT NULL COMMENT '0:進(jìn)行中, 1:已結(jié)束',
    description TEXT,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);

#獎品 ID、活動 ID（關(guān)聯(lián)活動表）、獎品名稱、獎品數(shù)量、獎品圖片地址、中獎概率
CREATE TABLE lottery_prize (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    activity_id BIGINT NOT NULL,
    prize_name VARCHAR(255) NOT NULL,
    prize_count INT NOT NULL,
    image_url VARCHAR(255),
    probability DECIMAL(5, 2) NOT NULL COMMENT '中獎概率，范圍0-1',
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (activity_id) REFERENCES lottery_activity(id)
);

#參與 ID、用戶 ID、活動 ID、抽獎時(shí)間、是否中獎、抽中獎品 ID
CREATE TABLE lottery_participation (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    user_id BIGINT NOT NULL,
    activity_id BIGINT NOT NULL,
    participate_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    is_winner TINYINT NOT NULL COMMENT '0:未中獎, 1:中獎',
    prize_id BIGINT,
    create_time DATETIME DEFAULT CURRENT_TIMESTAMP,
    update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
    FOREIGN KEY (activity_id) REFERENCES lottery_activity(id),
    FOREIGN KEY (prize_id) REFERENCES lottery_prize(id)
);

@Service
public class RandomLotteryService {

    public LotteryPrize randomDraw(List<LotteryPrize> prizes) {
        if (prizes == null || prizes.isEmpty()) {
            return null;
        }
        Random random = new Random();
        int index = random.nextInt(prizes.size());
        return prizes.get(index);
    }
}

@Service
public class ProbabilityLotteryService {

    public LotteryPrize probabilityDraw(List<LotteryPrize> prizes) {
        if (prizes == null || prizes.isEmpty()) {
            return null;
        }
        // 計(jì)算總概率
        double totalProbability = 0;
        for (LotteryPrize prize : prizes) {
            totalProbability += prize.getProbability();
        }

        // 生成0到總概率之間的隨機(jī)數(shù)
        Random random = new Random();
        double randomValue = random.nextDouble() * totalProbability;

        // 根據(jù)概率權(quán)重選擇獎品
        double currentProbability = 0;
        for (LotteryPrize prize : prizes) {
            currentProbability += prize.getProbability();
            if (randomValue < currentProbability) {
                return prize;
            }
        }
        return null;
    }
}

@Service
public class TieredLotteryService {

    public LotteryPrize tieredDraw(int drawCount, Map<Integer, List<LotteryPrize>> tieredPrizes) {
        for (Map.Entry<Integer, List<LotteryPrize>> entry : tieredPrizes.entrySet()) {
            if (drawCount >= entry.getKey()) {
                List<LotteryPrize> prizes = entry.getValue();
                if (prizes != null &&!prizes.isEmpty()) {
                    // 可以結(jié)合隨機(jī)抽獎或概率抽獎從對應(yīng)獎品池中抽取獎品
                    RandomLotteryService randomLotteryService = new RandomLotteryService();
                    return randomLotteryService.randomDraw(prizes);
                }
            }
        }
        return null;
    }
}

@Service
public class LotteryProcessService {

    public static final DateTimeFormatter DTF = DateTimeFormatter.ofPattern("yyyyMMdd");
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Autowired
    private DefaultRedisScript<Long> stockDeductLuaScript;

    @Autowired
    private DefaultRedisScript<Long> incrementIfNotExistLuaScript;

    @Autowired
    private RandomLotteryService randomLotteryService;

    @Autowired
    private ProbabilityLotteryService probabilityLotteryService;

    @Autowired
    private TieredLotteryService tieredLotteryService;

    @Autowired
    private LotteryActivityService lotteryActivityService;

    @Autowired
    private LotteryPrizeService lotteryPrizeService;

    @Autowired
    private LotteryParticipationService lotteryParticipationService;

    @Autowired
    private RedissonClient redissonClient;

    private static final String STOCK_KEY_PREFIX = "lottery:stock:";
    private static final String DRAW_COUNT_KEY_PREFIX = "lottery:drawCount:";
    private static final String LOCK_KEY_PREFIX = "lottery:lock:";

    public LotteryResult draw(Long userId, Long activityId, String lotteryType) {
        // 活動校驗(yàn)
        LotteryActivity activity = lotteryActivityService.getById(activityId);
        if (activity == null || activity.getStatus() != 0) {
            return new LotteryResult(false, null, "活動不存在或已結(jié)束");
        }

        // 檢查用戶抽獎次數(shù)
        if (!checkUserDrawCount(userId, activityId, activity.getDailyDrawLimit())) {
            return new LotteryResult(false, null, "今日抽獎次數(shù)已用完");
        }

        // 獲取獎品列表
        List<LotteryPrize> prizes = lotteryPrizeService.listByActivityId(activityId);
        if (prizes == null || prizes.isEmpty()) {
            return new LotteryResult(false, null, "獎品列表為空");
        }

        // 預(yù)熱獎品庫存到Redis
        warmUpPrizesStock(activityId, prizes);

        // 執(zhí)行抽獎邏輯
        RLock lock = redissonClient.getLock(LOCK_KEY_PREFIX + activityId + ":" + userId);
        try {
            // 嘗試獲取鎖，等待10秒，自動釋放時(shí)間30秒
            boolean locked = lock.tryLock(10, 30, TimeUnit.SECONDS);
            if (!locked) {
                return new LotteryResult(false, null, "系統(tǒng)繁忙，請稍后再試");
            }

            // 從Redis中扣減庫存
            LotteryPrize prize = deductStockAndDraw(userId, activityId, prizes, lotteryType);
            if (prize == null) {
                return new LotteryResult(false, null, "獎品已抽完");
            }

            // 記錄用戶參與抽獎信息
            recordLotteryParticipation(userId, activityId, prize);

            // 異步更新數(shù)據(jù)庫庫存
            asyncUpdateDbStock(prize.getId(), 1);

            return new LotteryResult(true, prize, "抽獎成功");
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new LotteryResult(false, null, "系統(tǒng)繁忙，請稍后再試");
        } finally {
            lock.unlock();
        }
    }

    /**
     * 檢查用戶抽獎次數(shù)
     */
    private boolean checkUserDrawCount(Long userId, Long activityId, int dailyLimit) {
        String drawCountKey = DRAW_COUNT_KEY_PREFIX + userId + ":" + activityId + ":" + DTF.format(LocalDate.now());

        // 使用Lua腳本原子性檢查并增加計(jì)數(shù)
        Long count = redisTemplate.execute(incrementIfNotExistLuaScript,
                Arrays.asList(drawCountKey),  24);

        return count != null && count <= dailyLimit;
    }

    /**
     * 預(yù)熱獎品庫存到Redis
     */
    private void warmUpPrizesStock(Long activityId, List<LotteryPrize> prizes) {
        for (LotteryPrize prize : prizes) {
            String stockKey = STOCK_KEY_PREFIX + activityId + ":" + prize.getId();
            // 如果Redis中不存在該獎品庫存，則從數(shù)據(jù)庫加載
            if (!redisTemplate.hasKey(stockKey)) {
                // 考慮到并發(fā)預(yù)熱，使用分布式鎖
                RLock lock = redissonClient.getLock("lottery:warmup:" + stockKey);
                try {
                    if (lock.tryLock(5, 10, TimeUnit.SECONDS)) {
                        // 再次檢查，避免其他線程已經(jīng)預(yù)熱
                        if (!redisTemplate.hasKey(stockKey)) {
                            // 從數(shù)據(jù)庫獲取當(dāng)前庫存
                            Integer dbStock = lotteryPrizeService.getStockById(prize.getId());
                            if (dbStock != null) {
                                redisTemplate.opsForValue().set(stockKey, dbStock);
                            }
                        }
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    /**
     * 扣減庫存并抽獎
     */
    private LotteryPrize deductStockAndDraw(Long userId, Long activityId,
                                            List<LotteryPrize> prizes, String lotteryType) {
        // 過濾掉庫存為0的獎品
        List<LotteryPrize> availablePrizes = new ArrayList<>();
        for (LotteryPrize prize : prizes) {
            String stockKey = STOCK_KEY_PREFIX + activityId + ":" + prize.getId();
            Integer stock = (Integer) redisTemplate.opsForValue().get(stockKey);
            if (stock != null && stock > 0) {
                availablePrizes.add(prize);
            }
        }

        if (availablePrizes.isEmpty()) {
            return null;
        }

        // 根據(jù)抽獎類型選擇抽獎算法
        LotteryPrize selectedPrize;
        switch (lotteryType) {
            case"random":
                selectedPrize = randomLotteryService.randomDraw(availablePrizes);
                break;
            case"probability":
                selectedPrize = probabilityLotteryService.probabilityDraw(availablePrizes);
                break;
            case"tiered":
                // 獲取用戶抽獎次數(shù)，用于階梯抽獎
                String drawCountKey = DRAW_COUNT_KEY_PREFIX + userId + ":" + activityId + ":" + LocalDate.now();
                Integer drawCount = (Integer) redisTemplate.opsForValue().get(drawCountKey);
                if (drawCount == null) drawCount = 0;

                // 獲取階梯獎品配置
                Map<Integer, List<LotteryPrize>> tieredPrizes = getTieredPrizes(activityId);
                selectedPrize = tieredLotteryService.tieredDraw(drawCount, tieredPrizes);
                break;
            default:
                selectedPrize = null;
        }

        if (selectedPrize == null) {
            return null;
        }

        // 使用Lua腳本原子性扣減庫存
        String stockKey = STOCK_KEY_PREFIX + activityId + ":" + selectedPrize.getId();
        Long result = redisTemplate.execute(stockDeductLuaScript, Arrays.asList(stockKey), 1);

        // 返回扣減成功的獎品
        return result != null && result > 0 ? selectedPrize : null;
    }

    /**
     * 記錄用戶參與抽獎信息
     */
    @Transactional
    public void recordLotteryParticipation(Long userId, Long activityId, LotteryPrize prize) {
        LotteryParticipation participation = new LotteryParticipation();
        participation.setUserId(userId);
        participation.setActivityId(activityId);
        participation.setWinner(prize != null ? 1 : 0);
        participation.setPrizeId(prize != null ? prize.getId() : null);
        lotteryParticipationService.save(participation);
    }

    /**
     * 異步更新數(shù)據(jù)庫庫存
     */
    @Async
    public void asyncUpdateDbStock(Long prizeId, int deductCount) {
        lotteryPrizeService.deductStock(prizeId, deductCount);
    }

    /**
     * 獲取階梯獎品配置
     */
    private Map<Integer, List<LotteryPrize>> getTieredPrizes(Long activityId) {
        // 從Redis緩存或數(shù)據(jù)庫獲取階梯獎品配置
        String tieredPrizesKey = "lottery:tieredPrizes:" + activityId;
        Map<Integer, List<LotteryPrize>> tieredPrizes =
                (Map<Integer, List<LotteryPrize>>) redisTemplate.opsForValue().get(tieredPrizesKey);

        if (tieredPrizes == null) {
            // 從數(shù)據(jù)庫加載
            tieredPrizes = lotteryPrizeService.getTieredPrizesByActivityId(activityId);
            // 緩存到Redis，有效期24小時(shí)
            if (tieredPrizes != null) {
                redisTemplate.opsForValue().set(tieredPrizesKey, tieredPrizes, 24, TimeUnit.HOURS);
            }
        }

        return tieredPrizes;
    }
}