JDWA Green-U 成就系统模块

@Data
@TableName("jdwa_achievement")
public class JDWAAchievement {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String achievementCode;
    private String achievementName;
    private String achievementType;
    private Integer achievementLevel;
    private String parentCode;
    private String description;
    private String badgeImage;
    private String achievementIcon;
    private Integer status;
    private Integer sortOrder;
    private Integer displayType;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    
    @TableField(exist = false)
    private List<JDWAAchievementCondition> conditions;
    
    @TableField(exist = false)
    private List<JDWAAchievementReward> rewards;
}

@Data
@TableName("jdwa_achievement_condition")
public class JDWAAchievementCondition {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long achievementId;
    private String achievementCode;
    private String conditionType;
    private String conditionKey;
    private String operator;
    private String valueType;
    private String targetValue;
    private String conditionLogic;
    private Integer conditionOrder;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_user_achievement")
public class JDWAUserAchievement {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long achievementId;
    private String achievementCode;
    private String currentValue;
    private String targetValue;
    private Integer progress;
    private Integer status;
    private LocalDateTime unlockTime;
    private LocalDateTime rewardTime;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
    
    @TableField(exist = false)
    private JDWAAchievement achievement;
}

@Data
@TableName("jdwa_achievement_reward")
public class JDWAAchievementReward {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long achievementId;
    private String achievementCode;
    private String rewardType;
    private String rewardKey;
    private String rewardValue;
    private String description;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

public class JDWAAchievementConstants {
    // 成就类型
    public static final String ACHIEVEMENT_TYPE_ACCUMULATIVE = "ACCUMULATIVE";  // 累计型
    public static final String ACHIEVEMENT_TYPE_COUNTING = "COUNTING";  // 计数型
    public static final String ACHIEVEMENT_TYPE_MILESTONE = "MILESTONE";  // 里程碑型
    public static final String ACHIEVEMENT_TYPE_COMBINATION = "COMBINATION";  // 组合型
    public static final String ACHIEVEMENT_TYPE_SOCIAL = "SOCIAL";  // 社交型
    
    // 成就状态
    public static final int ACHIEVEMENT_STATUS_IN_PROGRESS = 0;  // 进行中
    public static final int ACHIEVEMENT_STATUS_COMPLETED = 1;  // 已完成
    public static final int ACHIEVEMENT_STATUS_REWARDED = 2;  // 已领取奖励
    
    // 奖励类型
    public static final String REWARD_TYPE_POINTS = "POINTS";  // 积分奖励
    public static final String REWARD_TYPE_BADGE = "BADGE";  // 徽章奖励
    public static final String REWARD_TYPE_AVATAR_FRAME = "AVATAR_FRAME";  // 头像框
    public static final String REWARD_TYPE_TITLE = "TITLE";  // 称号
    public static final String REWARD_TYPE_PRIVILEGE = "PRIVILEGE";  // 特权
    
    // 操作符
    public static final String OPERATOR_EQ = "EQ";  // 等于
    public static final String OPERATOR_GT = "GT";  // 大于
    public static final String OPERATOR_LT = "LT";  // 小于
    public static final String OPERATOR_GTE = "GTE";  // 大于等于
    public static final String OPERATOR_LTE = "LTE";  // 小于等于
    public static final String OPERATOR_BETWEEN = "BETWEEN";  // 区间
    public static final String OPERATOR_IN = "IN";  // 包含于
} 

@RestController
@RequestMapping("/api/achievements")
public class JDWAAchievementController extends JDWABaseController {

    @Autowired
    private JDWAAchievementService achievementService;
    
    /**
     * 获取用户成就列表
     */
    @GetMapping("/list")
    public JDWAResult<Object> getUserAchievements(
            @RequestParam(required = false) String achievementType,
            @RequestParam(required = false) Integer status) {
        
        Long userId = getCurrentUserId();
        List<Map<String, Object>> achievements = achievementService.getUserAchievements(userId, achievementType, status);
        
        return JDWAResult.success("获取成功", achievements);
    }
    
    /**
     * 获取成就详情
     */
    @GetMapping("/detail/{achievementCode}")
    public JDWAResult<Object> getAchievementDetail(@PathVariable String achievementCode) {
        Long userId = getCurrentUserId();
        Map<String, Object> detail = achievementService.getAchievementDetail(userId, achievementCode);
        
        return JDWAResult.success("获取成功", detail);
    }
    
    /**
     * 刷新用户成就状态
     */
    @PostMapping("/refresh")
    public JDWAResult<Object> refreshAchievements() {
        Long userId = getCurrentUserId();
        List<String> unlockedAchievements = achievementService.refreshUserAchievements(userId);
        
        Map<String, Object> result = new HashMap<>();
        result.put("unlockedCount", unlockedAchievements.size());
        result.put("unlockedAchievements", unlockedAchievements);
        
        return JDWAResult.success("刷新成功", result);
    }
    
    /**
     * 领取成就奖励
     */
    @PostMapping("/reward/{achievementCode}")
    public JDWAResult<Object> getAchievementReward(@PathVariable String achievementCode) {
        Long userId = getCurrentUserId();
        Map<String, Object> rewards = achievementService.getAchievementReward(userId, achievementCode);
        
        return JDWAResult.success("奖励领取成功", rewards);
    }
    
    /**
     * 获取用户成就概览
     */
    @GetMapping("/overview")
    public JDWAResult<Object> getAchievementOverview() {
        Long userId = getCurrentUserId();
        Map<String, Object> overview = achievementService.getAchievementOverview(userId);
        
        return JDWAResult.success("获取成功", overview);
    }
    
    /**
     * 获取用户已解锁徽章列表
     */
    @GetMapping("/badges")
    public JDWAResult<Object> getUserBadges(
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Long userId = getCurrentUserId();
        Page<Map<String, Object>> badges = achievementService.getUserBadges(userId, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", badges);
    }
    
    /**
     * 设置展示徽章
     */
    @PostMapping("/badge/display")
    public JDWAResult<Object> setDisplayBadge(@RequestBody Map<String, Object> params) {
        Long userId = getCurrentUserId();
        String achievementCode = (String) params.get("achievementCode");
        Boolean display = (Boolean) params.get("display");
        
        achievementService.setDisplayBadge(userId, achievementCode, display);
        
        return JDWAResult.success("设置成功", null);
    }
    
    /**
     * 获取成就排行榜
     */
    @GetMapping("/leaderboard")
    public JDWAResult<Object> getAchievementLeaderboard(
            @RequestParam(defaultValue = "total") String type,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Page<Map<String, Object>> leaderboard = achievementService.getAchievementLeaderboard(type, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", leaderboard);
    }
}

public interface JDWAAchievementService {
    
    /**
     * 获取用户成就列表
     *
     * @param userId 用户ID
     * @param achievementType 成就类型（可选）
     * @param status 成就状态（可选）
     * @return 成就列表
     */
    List<Map<String, Object>> getUserAchievements(Long userId, String achievementType, Integer status);
    
    /**
     * 获取成就详情
     *
     * @param userId 用户ID
     * @param achievementCode 成就编码
     * @return 成就详情
     */
    Map<String, Object> getAchievementDetail(Long userId, String achievementCode);
    
    /**
     * 刷新用户成就状态
     * 
     * @param userId 用户ID
     * @return 新解锁的成就列表
     */
    List<String> refreshUserAchievements(Long userId);
    
    /**
     * 检查用户成就完成状态
     * 
     * @param userId 用户ID
     * @param achievementCode 成就编码
     * @return 是否完成
     */
    boolean checkAchievementCompletion(Long userId, String achievementCode);
    
    /**
     * 更新用户成就进度
     * 
     * @param userId 用户ID
     * @param conditionKey 条件键
     * @param value 当前值
     */
    void updateAchievementProgress(Long userId, String conditionKey, Object value);
    
    /**
     * 领取成就奖励
     * 
     * @param userId 用户ID
     * @param achievementCode 成就编码
     * @return 奖励信息
     */
    Map<String, Object> getAchievementReward(Long userId, String achievementCode);
    
    /**
     * 获取用户成就概览
     * 
     * @param userId 用户ID
     * @return 成就概览
     */
    Map<String, Object> getAchievementOverview(Long userId);
    
    /**
     * 获取用户已解锁徽章列表
     * 
     * @param userId 用户ID
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 徽章列表
     */
    Page<Map<String, Object>> getUserBadges(Long userId, Integer pageNum, Integer pageSize);
    
    /**
     * 设置展示徽章
     * 
     * @param userId 用户ID
     * @param achievementCode 成就编码
     * @param display 是否展示
     */
    void setDisplayBadge(Long userId, String achievementCode, Boolean display);
    
    /**
     * 获取成就排行榜
     * 
     * @param type 排行类型（total-总成就数，monthly-本月解锁数）
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 排行榜
     */
    Page<Map<String, Object>> getAchievementLeaderboard(String type, Integer pageNum, Integer pageSize);
    
    /**
     * 根据事件触发成就检查
     * 
     * @param userId 用户ID
     * @param eventType 事件类型
     * @param eventData 事件数据
     * @return 新解锁的成就列表
     */
    List<String> checkAchievementsByEvent(Long userId, String eventType, Map<String, Object> eventData);
}

@Slf4j
@Service
public class JDWAAchievementServiceImpl implements JDWAAchievementService {

    @Autowired
    private JDWAAchievementMapper achievementMapper;
    
    @Autowired
    private JDWAAchievementConditionMapper conditionMapper;
    
    @Autowired
    private JDWAUserAchievementMapper userAchievementMapper;
    
    @Autowired
    private JDWAAchievementRewardMapper rewardMapper;
    
    @Autowired
    private JDWAPointsService pointsService;
    
    @Autowired
    private JDWAUserService userService;
    
    @Override
    public List<Map<String, Object>> getUserAchievements(Long userId, String achievementType, Integer status) {
        // 查询所有有效成就
        List<JDWAAchievement> achievements = getActiveAchievements(achievementType);
        
        // 查询用户已有的成就记录
        Map<String, JDWAUserAchievement> userAchievements = getUserAchievementMap(userId);
        
        // 组装结果
        List<Map<String, Object>> result = new ArrayList<>();
        
        for (JDWAAchievement achievement : achievements) {
            // 如果指定了状态过滤，则跳过不符合的记录
            if (status != null) {
                JDWAUserAchievement userAchievement = userAchievements.get(achievement.getAchievementCode());
                if (userAchievement == null && status > 0) {
                    continue;  // 用户没有此成就记录，但要求已完成或已领取，跳过
                }
                if (userAchievement != null && userAchievement.getStatus() != status) {
                    continue;  // 状态不匹配，跳过
                }
            }
            
            Map<String, Object> map = new HashMap<>();
            map.put("id", achievement.getId());
            map.put("achievementCode", achievement.getAchievementCode());
            map.put("achievementName", achievement.getAchievementName());
            map.put("achievementType", achievement.getAchievementType());
            map.put("achievementLevel", achievement.getAchievementLevel());
            map.put("description", achievement.getDescription());
            map.put("badgeImage", achievement.getBadgeImage());
            map.put("achievementIcon", achievement.getAchievementIcon());
            
            // 设置成就状态信息
            JDWAUserAchievement userAchievement = userAchievements.get(achievement.getAchievementCode());
            if (userAchievement != null) {
                map.put("status", userAchievement.getStatus());
                map.put("progress", userAchievement.getProgress());
                map.put("currentValue", userAchievement.getCurrentValue());
                map.put("targetValue", userAchievement.getTargetValue());
                map.put("unlockTime", userAchievement.getUnlockTime());
            } else {
                map.put("status", JDWAAchievementConstants.ACHIEVEMENT_STATUS_IN_PROGRESS);
                map.put("progress", 0);
                map.put("currentValue", "0");
                
                // 获取目标值
                String targetValue = getAchievementTargetValue(achievement.getId());
                map.put("targetValue", targetValue);
                map.put("unlockTime", null);
            }
            
            result.add(map);
        }
        
        return result;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public List<String> refreshUserAchievements(Long userId) {
        log.info("刷新用户成就状态，用户ID: {}", userId);
        
        // 获取所有活跃的成就
        List<JDWAAchievement> achievements = getActiveAchievements(null);
        
        // 用户当前的成就状态
        Map<String, JDWAUserAchievement> userAchievements = getUserAchievementMap(userId);
        
        // 新解锁的成就列表
        List<String> unlockedAchievements = new ArrayList<>();
        
        // 检查每个成就
        for (JDWAAchievement achievement : achievements) {
            String achievementCode = achievement.getAchievementCode();
            
            // 跳过已完成的成就
            JDWAUserAchievement userAchievement = userAchievements.get(achievementCode);
            if (userAchievement != null && userAchievement.getStatus() > 0) {
                continue;
            }
            
            // 检查成就完成状态
            boolean completed = checkAchievementCompletionInternal(userId, achievement);
            
            if (completed) {
                // 成就完成，更新状态
                if (userAchievement == null) {
                    // 创建新的用户成就记录
                    userAchievement = new JDWAUserAchievement();
                    userAchievement.setUserId(userId);
                    userAchievement.setAchievementId(achievement.getId());
                    userAchievement.setAchievementCode(achievementCode);
                    userAchievement.setStatus(JDWAAchievementConstants.ACHIEVEMENT_STATUS_COMPLETED);
                    userAchievement.setUnlockTime(LocalDateTime.now());
                    userAchievement.setProgress(100);
                    userAchievement.setCurrentValue(getAchievementTargetValue(achievement.getId()));
                    userAchievement.setTargetValue(getAchievementTargetValue(achievement.getId()));
                    userAchievement.setCreateTime(LocalDateTime.now());
                    userAchievement.setUpdateTime(LocalDateTime.now());
                    
                    userAchievementMapper.insert(userAchievement);
                } else {
                    // 更新现有记录
                    userAchievement.setStatus(JDWAAchievementConstants.ACHIEVEMENT_STATUS_COMPLETED);
                    userAchievement.setUnlockTime(LocalDateTime.now());
                    userAchievement.setProgress(100);
                    userAchievement.setCurrentValue(getAchievementTargetValue(achievement.getId()));
                    userAchievement.setUpdateTime(LocalDateTime.now());
                    
                    userAchievementMapper.updateById(userAchievement);
                }
                
                unlockedAchievements.add(achievementCode);
                log.info("用户{}解锁成就：{}", userId, achievementCode);
            }
        }
        
        return unlockedAchievements;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Map<String, Object> getAchievementReward(Long userId, String achievementCode) {
        // 获取用户成就记录
        JDWAUserAchievement userAchievement = getUserAchievement(userId, achievementCode);
        
        if (userAchievement == null) {
            throw new JDWAServiceException("未找到相关成就记录");
        }
        
        // 检查成就状态
        if (userAchievement.getStatus() != JDWAAchievementConstants.ACHIEVEMENT_STATUS_COMPLETED) {
            if (userAchievement.getStatus() < JDWAAchievementConstants.ACHIEVEMENT_STATUS_COMPLETED) {
                throw new JDWAServiceException("成就尚未完成，无法领取奖励");
            } else {
                throw new JDWAServiceException("奖励已领取，请勿重复操作");
            }
        }
        
        // 获取成就奖励
        List<JDWAAchievementReward> rewards = getAchievementRewards(userAchievement.getAchievementId());
        
        if (rewards.isEmpty()) {
            throw new JDWAServiceException("该成就暂无奖励");
        }
        
        // 处理各类奖励
        Map<String, Object> result = new HashMap<>();
        for (JDWAAchievementReward reward : rewards) {
            processReward(userId, reward, result);
        }
        
        // 更新用户成就状态为已领取奖励
        userAchievement.setStatus(JDWAAchievementConstants.ACHIEVEMENT_STATUS_REWARDED);
        userAchievement.setRewardTime(LocalDateTime.now());
        userAchievement.setUpdateTime(LocalDateTime.now());
        userAchievementMapper.updateById(userAchievement);
        
        return result;
    }
    
    /**
     * 处理各类奖励发放
     */
    private void processReward(Long userId, JDWAAchievementReward reward, Map<String, Object> result) {
        String rewardType = reward.getRewardType();
        String rewardKey = reward.getRewardKey();
        String rewardValue = reward.getRewardValue();
        
        switch (rewardType) {
            case JDWAAchievementConstants.REWARD_TYPE_POINTS:
                // 积分奖励
                int points = Integer.parseInt(rewardValue);
                pointsService.addPoints(userId, points, rewardKey, "ACHIEVEMENT_REWARD", 
                        reward.getAchievementCode(), "成就奖励：" + reward.getDescription(), null);
                
                // 记录到结果
                result.put("points", points);
                result.put("pointsType", rewardKey);
                break;
                
            case JDWAAchievementConstants.REWARD_TYPE_BADGE:
                // 徽章奖励，记录已在用户成就表中
                result.put("badge", reward.getDescription());
                result.put("badgeImage", rewardValue);
                break;
                
            case JDWAAchievementConstants.REWARD_TYPE_AVATAR_FRAME:
                // 头像框奖励
                userService.addUserAvatarFrame(userId, rewardValue);
                result.put("avatarFrame", reward.getDescription());
                result.put("avatarFrameImage", rewardValue);
                break;
                
            case JDWAAchievementConstants.REWARD_TYPE_TITLE:
                // 称号奖励
                userService.addUserTitle(userId, rewardValue);
                result.put("title", reward.getDescription());
                break;
                
            case JDWAAchievementConstants.REWARD_TYPE_PRIVILEGE:
                // 特权奖励
                userService.addUserPrivilege(userId, rewardKey);
                result.put("privilege", reward.getDescription());
                break;
                
            default:
                log.warn("未知奖励类型：{}", rewardType);
        }
    }
    
    /**
     * 根据事件更新相关成就进度
     */
    @Override
    public List<String> checkAchievementsByEvent(Long userId, String eventType, Map<String, Object> eventData) {
        log.info("检查事件触发的成就，用户ID: {}, 事件类型: {}", userId, eventType);
        
        // 根据事件类型查找相关的条件键
        List<String> conditionKeys = getConditionKeysByEventType(eventType);
        
        if (conditionKeys.isEmpty()) {
            return Collections.emptyList();
        }
        
        // 更新相关成就的进度
        for (String conditionKey : conditionKeys) {
            Object value = eventData.get(conditionKey);
            if (value != null) {
                updateAchievementProgress(userId, conditionKey, value);
            }
        }
        
        // 检查成就是否完成
        return refreshUserAchievements(userId);
    }
    
    /**
     * 获取事件相关的条件键
     */
    private List<String> getConditionKeysByEventType(String eventType) {
        List<String> keys = new ArrayList<>();
        
        // 根据事件类型映射到相关的条件键
        switch (eventType) {
            case "USER_ACTIVITY":
                keys.add("total_activity_count");
                keys.add("total_walking_distance");
                keys.add("total_cycling_distance");
                keys.add("total_carbon_reduction");
                break;
                
            case "USER_CHECK_IN":
                keys.add("check_in_count");
                keys.add("consecutive_check_in");
                break;
                
            case "USER_INVITE":
                keys.add("invite_user_count");
                break;
                
            case "USER_SHARE":
                keys.add("share_count");
                break;
                
            // 其他事件类型...
        }
        
        return keys;
    }
}

@Component
public class JDWAAchievementCheckEngine {
    
    @Autowired
    private JDWAUserService userService;
    
    @Autowired
    private JDWAActivityService activityService;
    
    @Autowired
    private JDWACarbonReductionService carbonReductionService;
    
    /**
     * 检查成就条件是否满足
     *
     * @param userId 用户ID
     * @param conditions 条件列表
     * @return 是否满足所有条件
     */
    public boolean checkConditions(Long userId, List<JDWAAchievementCondition> conditions) {
        if (conditions == null || conditions.isEmpty()) {
            return false;
        }
        
        boolean isAnd = true;  // 默认为AND逻辑
        
        // 检查是否有OR逻辑
        for (JDWAAchievementCondition condition : conditions) {
            if ("OR".equals(condition.getConditionLogic())) {
                isAnd = false;
                break;
            }
        }
        
        if (isAnd) {
            // AND逻辑：所有条件必须满足
            return conditions.stream().allMatch(condition -> checkSingleCondition(userId, condition));
        } else {
            // OR逻辑：任一条件满足即可
            return conditions.stream().anyMatch(condition -> checkSingleCondition(userId, condition));
        }
    }
    
    /**
     * 检查单个条件
     *
     * @param userId 用户ID
     * @param condition 条件
     * @return 是否满足
     */
    private boolean checkSingleCondition(Long userId, JDWAAchievementCondition condition) {
        String conditionKey = condition.getConditionKey();
        String operator = condition.getOperator();
        String targetValue = condition.getTargetValue();
        
        // 获取当前值
        Object currentValue = getCurrentValue(userId, conditionKey);
        if (currentValue == null) {
            return false;
        }
        
        // 根据值类型和操作符比较
        return compareValues(currentValue, targetValue, operator, condition.getValueType());
    }
    
    /**
     * 获取条件对应的当前值
     */
    private Object getCurrentValue(Long userId, String conditionKey) {
        // 根据条件键获取相应的用户数据
        switch (conditionKey) {
            case "total_activity_count":
                return activityService.getUserActivityCount(userId);
                
            case "total_walking_distance":
                return activityService.getUserTotalDistance(userId, "WALKING");
                
            case "total_cycling_distance":
                return activityService.getUserTotalDistance(userId, "CYCLING");
                
            case "total_carbon_reduction":
                return carbonReductionService.getUserTotalCarbonReduction(userId);
                
            case "check_in_count":
                return userService.getUserCheckInCount(userId);
                
            case "consecutive_check_in":
                return userService.getUserConsecutiveCheckIn(userId);
                
            case "invite_user_count":
                return userService.getUserInviteCount(userId);
                
            case "share_count":
                return userService.getUserShareCount(userId);
                
            // 其他条件键...
                
            default:
                return null;
        }
    }
    
    /**
     * 比较值
     */
    private boolean compareValues(Object currentValue, String targetValue, String operator, String valueType) {
        // 根据值类型转换
        if ("NUMBER".equals(valueType)) {
            return compareNumberValues(currentValue, targetValue, operator);
        } else if ("DATE".equals(valueType)) {
            return compareDateValues(currentValue, targetValue, operator);
        } else if ("STRING".equals(valueType)) {
            return compareStringValues(currentValue, targetValue, operator);
        } else if ("BOOLEAN".equals(valueType)) {
            return compareBooleanValues(currentValue, targetValue, operator);
        }
        
        return false;
    }
    
    /**
     * 比较数值
     */
    private boolean compareNumberValues(Object currentValue, String targetValue, String operator) {
        try {
            BigDecimal current = new BigDecimal(String.valueOf(currentValue));
            
            if (JDWAAchievementConstants.OPERATOR_BETWEEN.equals(operator)) {
                // 区间比较
                String[] range = targetValue.split(",");
                BigDecimal min = new BigDecimal(range[0]);
                BigDecimal max = new BigDecimal(range[1]);
                return current.compareTo(min) >= 0 && current.compareTo(max) <= 0;
            } else if (JDWAAchievementConstants.OPERATOR_IN.equals(operator)) {
                // IN比较
                String[] values = targetValue.split(",");
                for (String value : values) {
                    if (current.compareTo(new BigDecimal(value)) == 0) {
                        return true;
                    }
                }
                return false;
            } else {
                // 单值比较
                BigDecimal target = new BigDecimal(targetValue);
                
                switch (operator) {
                    case JDWAAchievementConstants.OPERATOR_EQ:
                        return current.compareTo(target) == 0;
                    case JDWAAchievementConstants.OPERATOR_GT:
                        return current.compareTo(target) > 0;
                    case JDWAAchievementConstants.OPERATOR_LT:
                        return current.compareTo(target) < 0;
                    case JDWAAchievementConstants.OPERATOR_GTE:
                        return current.compareTo(target) >= 0;
                    case JDWAAchievementConstants.OPERATOR_LTE:
                        return current.compareTo(target) <= 0;
                    default:
                        return false;
                }
            }
        } catch (Exception e) {
            return false;
        }
    }
    
    // 其他比较方法省略...
}

/**
 * 事件发布示例 - 用户活动完成
 */
@Service
public class JDWAActivityServiceImpl implements JDWAActivityService {
    
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public JDWAActivity createActivity(Long userId, JDWAActivityRequest request) {
        // 创建活动记录...
        JDWAActivity activity = new JDWAActivity();
        activity.setUserId(userId);
        activity.setActivityType(request.getActivityType());
        activity.setDistance(request.getDistance());
        activity.setDuration(request.getDuration());
        
        // 计算碳减排量
        BigDecimal carbonReduction = calculateCarbonReduction(
                request.getActivityType(), request.getDistance());
        activity.setCarbonReduction(carbonReduction);
        
        // 保存活动记录
        save(activity);
        
        // 发布用户活动完成事件，触发成就检查
        Map<String, Object> eventData = new HashMap<>();
        eventData.put("activityId", activity.getId());
        eventData.put("activityType", activity.getActivityType());
        eventData.put("distance", activity.getDistance());
        eventData.put("duration", activity.getDuration());
        eventData.put("carbonReduction", activity.getCarbonReduction());
        eventData.put("total_activity_count", getUserActivityCount(userId));
        eventData.put("total_walking_distance", 
                "WALKING".equals(activity.getActivityType()) ? 
                getUserTotalDistance(userId, "WALKING") : null);
        eventData.put("total_cycling_distance", 
                "CYCLING".equals(activity.getActivityType()) ? 
                getUserTotalDistance(userId, "CYCLING") : null);
        eventData.put("total_carbon_reduction", getUserTotalCarbonReduction(userId));
        
        eventPublisher.publishEvent(new JDWAUserEvent(this, userId, "USER_ACTIVITY", eventData));
        
        return activity;
    }
}

/**
 * 事件监听器 - 成就检查
 */
@Component
@Slf4j
public class JDWAAchievementEventListener {
    
    @Autowired
    private JDWAAchievementService achievementService;
    
    @EventListener
    public void handleUserEvent(JDWAUserEvent event) {
        try {
            Long userId = event.getUserId();
            String eventType = event.getEventType();
            Map<String, Object> eventData = event.getEventData();
            
            // 根据事件类型触发成就检查
            List<String> unlockedAchievements = 
                    achievementService.checkAchievementsByEvent(userId, eventType, eventData);
            
            if (!unlockedAchievements.isEmpty()) {
                log.info("用户 {} 通过事件 {} 解锁了 {} 个成就", 
                        userId, eventType, unlockedAchievements.size());
            }
        } catch (Exception e) {
            // 成就处理发生异常不应影响主业务流程
            log.error("处理成就事件时发生异常", e);
        }
    }
}

/**
 * 成就解锁通知发送
 */
@Component
public class JDWAAchievementNotificationSender {
    
    @Autowired
    private JDWANotificationService notificationService;
    
    @Autowired
    private JDWAAchievementMapper achievementMapper;
    
    /**
     * 发送成就解锁通知
     */
    public void sendAchievementUnlockNotification(Long userId, List<String> achievementCodes) {
        if (achievementCodes == null || achievementCodes.isEmpty()) {
            return;
        }
        
        for (String achievementCode : achievementCodes) {
            // 查询成就信息
            JDWAAchievement achievement = achievementMapper.selectByCode(achievementCode);
            if (achievement == null) {
                continue;
            }
            
            // 构建通知内容
            Map<String, Object> content = new HashMap<>();
            content.put("achievementName", achievement.getAchievementName());
            content.put("achievementCode", achievement.getAchievementCode());
            content.put("achievementIcon", achievement.getAchievementIcon());
            content.put("description", achievement.getDescription());
            
            // 发送通知
            notificationService.sendNotification(
                    userId, 
                    "ACHIEVEMENT_UNLOCK", 
                    "恭喜解锁新成就：" + achievement.getAchievementName(), 
                    content);
        }
    }
}

/**
 * 定期成就回顾服务
 */
@Service
public class JDWAAchievementReviewService {
    
    @Autowired
    private JDWAUserAchievementMapper userAchievementMapper;
    
    @Autowired
    private JDWANotificationService notificationService;
    
    /**
     * 生成月度成就回顾
     */
    @Scheduled(cron = "0 0 8 1 * ?")  // 每月1号早上8点执行
    public void generateMonthlyAchievementReview() {
        // 获取上个月的日期范围
        LocalDate now = LocalDate.now();
        LocalDate firstDayOfLastMonth = now.minusMonths(1).withDayOfMonth(1);
        LocalDate lastDayOfLastMonth = now.withDayOfMonth(1).minusDays(1);
        
        // 查询活跃用户
        List<Long> activeUserIds = getActiveUsers(firstDayOfLastMonth, lastDayOfLastMonth);
        
        for (Long userId : activeUserIds) {
            try {
                // 查询用户上月解锁的成就
                List<JDWAUserAchievement> monthlyAchievements = 
                        userAchievementMapper.selectMonthlyUnlockedAchievements(
                                userId, 
                                firstDayOfLastMonth.atStartOfDay(), 
                                lastDayOfLastMonth.atTime(23, 59, 59));
                
                if (monthlyAchievements.isEmpty()) {
                    continue;
                }
                
                // 生成回顾内容
                Map<String, Object> content = generateReviewContent(userId, monthlyAchievements);
                
                // 发送成就回顾通知
                notificationService.sendNotification(
                        userId, 
                        "ACHIEVEMENT_REVIEW", 
                        "您上个月解锁了" + monthlyAchievements.size() + "个成就，点击查看回顾", 
                        content);
                
            } catch (Exception e) {
                // 单个用户处理异常不影响其他用户
                logger.error("为用户{}生成成就回顾时发生异常", userId, e);
            }
        }
    }
}