JDWA Green-U 碳减排统计模块

@Data
@TableName("jdwa_carbon_record")
public class JDWACarbonRecord {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private Long activityId;
    private BigDecimal carbonAmount;
    private String recordType;
    private String description;
    private LocalDateTime createTime;
}

@Data
@TableName("jdwa_carbon_stats")
public class JDWACarbonStats {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String statsType;
    private LocalDate statsDate;
    private String activityType;
    private Integer recordCount;
    private BigDecimal totalDistance;
    private BigDecimal totalCarbon;
    private BigDecimal avgCarbon;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
@TableName("jdwa_carbon_report")
public class JDWACarbonReport {
    @TableId(type = IdType.AUTO)
    private Long id;
    private Long userId;
    private String reportType;
    private LocalDate reportDate;
    private LocalDate startDate;
    private LocalDate endDate;
    private BigDecimal totalCarbon;
    private Integer totalActivities;
    private String activityStats;
    private String envImpact;
    private String certificationCode;
    private Integer status;
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

@Data
public class CarbonStatsSummary {
    private Long userId;
    private BigDecimal totalCarbon;
    private BigDecimal dailyAvgCarbon;
    private BigDecimal weeklyAvgCarbon;
    private BigDecimal monthlyAvgCarbon;
    private Integer totalActivities;
    private Map<String, BigDecimal> carbonByActivityType;
    private List<DateCarbonStats> dailyStats;
    private List<DateCarbonStats> weeklyStats;
    private List<DateCarbonStats> monthlyStats;
}

@Data
public class DateCarbonStats {
    private LocalDate date;
    private BigDecimal carbonAmount;
    private Integer activityCount;
}

@Data
public class EnvImpactData {
    private BigDecimal carbonAmount;
    private BigDecimal treeEquivalent;
    private BigDecimal fuelSaved;
    private BigDecimal electricitySaved;
}

@RestController
@RequestMapping("/api/carbon")
public class JDWACarbonController extends JDWABaseController {

    @Autowired
    private JDWACarbonService carbonService;
    
    /**
     * 获取碳减排记录列表
     */
    @GetMapping("/records")
    public JDWAResult<Object> getCarbonRecords(
            @RequestParam(required = false) String recordType,
            @RequestParam(required = false) String startDate,
            @RequestParam(required = false) String endDate,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Long userId = getCurrentUserId();
        Page<JDWACarbonRecord> page = carbonService.getCarbonRecords(
                userId, recordType, startDate, endDate, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", page);
    }
    
    /**
     * 获取碳减排统计摘要
     */
    @GetMapping("/stats/summary")
    public JDWAResult<Object> getCarbonStatsSummary(
            @RequestParam(required = false) String period,
            @RequestParam(required = false) String startDate,
            @RequestParam(required = false) String endDate) {
        
        Long userId = getCurrentUserId();
        CarbonStatsSummary summary = carbonService.getCarbonStatsSummary(
                userId, period, startDate, endDate);
        
        return JDWAResult.success("获取成功", summary);
    }
    
    /**
     * 获取环境影响数据
     */
    @GetMapping("/impact")
    public JDWAResult<Object> getEnvironmentalImpact() {
        Long userId = getCurrentUserId();
        EnvImpactData impact = carbonService.calculateEnvironmentalImpact(userId);
        
        return JDWAResult.success("获取成功", impact);
    }
    
    /**
     * 生成碳减排报告
     */
    @PostMapping("/report/generate")
    public JDWAResult<Object> generateCarbonReport(
            @RequestBody Map<String, Object> params) {
        
        Long userId = getCurrentUserId();
        String reportType = (String) params.get("reportType");
        String reportDate = (String) params.get("reportDate");
        
        JDWACarbonReport report = carbonService.generateCarbonReport(
                userId, reportType, reportDate);
        
        return JDWAResult.success("报告生成成功", report);
    }
    
    /**
     * 获取碳减排报告列表
     */
    @GetMapping("/reports")
    public JDWAResult<Object> getCarbonReports(
            @RequestParam(required = false) String reportType,
            @RequestParam(defaultValue = "1") Integer pageNum,
            @RequestParam(defaultValue = "10") Integer pageSize) {
        
        Long userId = getCurrentUserId();
        Page<JDWACarbonReport> page = carbonService.getCarbonReports(
                userId, reportType, pageNum, pageSize);
        
        return JDWAResult.success("获取成功", page);
    }
    
    /**
     * 获取碳减排报告详情
     */
    @GetMapping("/report/{id}")
    public JDWAResult<Object> getCarbonReportDetail(@PathVariable Long id) {
        Long userId = getCurrentUserId();
        JDWACarbonReport report = carbonService.getCarbonReportDetail(userId, id);
        
        if (report == null) {
            return JDWAResult.notFound("报告不存在");
        }
        
        return JDWAResult.success("获取成功", report);
    }
}

public interface JDWACarbonService {
    
    /**
     * 记录碳减排
     *
     * @param userId 用户ID
     * @param activityId 活动ID
     * @param carbonAmount 碳减排量
     * @param recordType 记录类型
     * @param description 描述
     * @return 碳减排记录
     */
    JDWACarbonRecord recordCarbonReduction(Long userId, Long activityId, 
            BigDecimal carbonAmount, String recordType, String description);
    
    /**
     * 获取用户碳减排记录列表
     *
     * @param userId 用户ID
     * @param recordType 记录类型
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页碳减排记录列表
     */
    Page<JDWACarbonRecord> getCarbonRecords(Long userId, String recordType, 
            String startDate, String endDate, Integer pageNum, Integer pageSize);
    
    /**
     * 获取碳减排统计摘要
     *
     * @param userId 用户ID
     * @param period 统计周期
     * @param startDate 开始日期
     * @param endDate 结束日期
     * @return 统计摘要
     */
    CarbonStatsSummary getCarbonStatsSummary(Long userId, String period, 
            String startDate, String endDate);
    
    /**
     * 计算环境影响数据
     *
     * @param userId 用户ID
     * @return 环境影响数据
     */
    EnvImpactData calculateEnvironmentalImpact(Long userId);
    
    /**
     * 生成碳减排报告
     *
     * @param userId 用户ID
     * @param reportType 报告类型
     * @param reportDate 报告日期
     * @return 碳减排报告
     */
    JDWACarbonReport generateCarbonReport(Long userId, String reportType, String reportDate);
    
    /**
     * 获取碳减排报告列表
     *
     * @param userId 用户ID
     * @param reportType 报告类型
     * @param pageNum 页码
     * @param pageSize 每页大小
     * @return 分页碳减排报告列表
     */
    Page<JDWACarbonReport> getCarbonReports(Long userId, String reportType, 
            Integer pageNum, Integer pageSize);
    
    /**
     * 获取碳减排报告详情
     *
     * @param userId 用户ID
     * @param reportId 报告ID
     * @return 碳减排报告详情
     */
    JDWACarbonReport getCarbonReportDetail(Long userId, Long reportId);
    
    /**
     * 更新碳减排统计数据
     *
     * @param executeDate 执行日期
     */
    void updateCarbonStats(LocalDate executeDate);
}

@Slf4j
@Service
public class JDWACarbonServiceImpl implements JDWACarbonService {
    
    @Autowired
    private JDWACarbonRecordMapper carbonRecordMapper;
    
    @Autowired
    private JDWACarbonStatsMapper carbonStatsMapper;
    
    @Autowired
    private JDWACarbonReportMapper carbonReportMapper;
    
    @Autowired
    private JDWAActivityMapper activityMapper;
    
    @Autowired
    private JDWAUserService userService;
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public JDWACarbonRecord recordCarbonReduction(Long userId, Long activityId, 
            BigDecimal carbonAmount, String recordType, String description) {
        
        // 创建碳减排记录
        JDWACarbonRecord record = new JDWACarbonRecord();
        record.setUserId(userId);
        record.setActivityId(activityId);
        record.setCarbonAmount(carbonAmount);
        record.setRecordType(recordType);
        record.setDescription(description);
        
        carbonRecordMapper.insert(record);
        
        // 异步更新统计数据
        // 实际实现可以使用Spring的@Async或消息队列
        updateDailyCarbonStats(userId, LocalDate.now(), recordType, carbonAmount);
        
        return record;
    }
    
    // ... 其他接口实现 ...
    
    @Override
    public CarbonStatsSummary getCarbonStatsSummary(Long userId, String period, 
            String startDate, String endDate) {
        
        CarbonStatsSummary summary = new CarbonStatsSummary();
        summary.setUserId(userId);
        
        // 处理日期范围
        LocalDate start = null;
        LocalDate end = LocalDate.now();
        
        if (StringUtils.hasText(period)) {
            // 根据周期设置日期范围
            switch (period.toLowerCase()) {
                case "week":
                    start = end.minusWeeks(1);
                    break;
                case "month":
                    start = end.minusMonths(1);
                    break;
                case "year":
                    start = end.minusYears(1);
                    break;
                default:
                    start = end.minusDays(30); // 默认30天
                    break;
            }
        } else {
            // 自定义日期范围
            if (StringUtils.hasText(startDate)) {
                start = LocalDate.parse(startDate);
            } else {
                start = end.minusDays(30); // 默认30天
            }
            
            if (StringUtils.hasText(endDate)) {
                end = LocalDate.parse(endDate);
            }
        }
        
        // 查询总碳减排量
        BigDecimal totalCarbon = carbonRecordMapper.sumCarbonAmountByUserIdAndDateRange(
                userId, start, end.plusDays(1));
        summary.setTotalCarbon(totalCarbon != null ? totalCarbon : BigDecimal.ZERO);
        
        // 查询总活动次数
        Integer totalActivities = carbonRecordMapper.countRecordsByUserIdAndDateRange(
                userId, start, end.plusDays(1));
        summary.setTotalActivities(totalActivities != null ? totalActivities : 0);
        
        // 按活动类型统计碳减排量
        Map<String, BigDecimal> carbonByType = carbonRecordMapper.sumCarbonAmountByUserIdGroupByType(
                userId, start, end.plusDays(1));
        summary.setCarbonByActivityType(carbonByType != null ? carbonByType : new HashMap<>());
        
        // 日均碳减排量
        long days = ChronoUnit.DAYS.between(start, end) + 1;
        if (totalCarbon != null && days > 0) {
            BigDecimal dailyAvg = totalCarbon.divide(
                    BigDecimal.valueOf(days), 2, RoundingMode.HALF_UP);
            summary.setDailyAvgCarbon(dailyAvg);
        } else {
            summary.setDailyAvgCarbon(BigDecimal.ZERO);
        }
        
        // 获取日统计数据
        List<DateCarbonStats> dailyStats = carbonStatsMapper.getDailyCarbonStatsByUserIdAndDateRange(
                userId, start, end.plusDays(1));
        summary.setDailyStats(dailyStats != null ? dailyStats : new ArrayList<>());
        
        // 获取周统计数据
        List<DateCarbonStats> weeklyStats = carbonStatsMapper.getWeeklyCarbonStatsByUserIdAndDateRange(
                userId, start, end.plusDays(1));
        summary.setWeeklyStats(weeklyStats != null ? weeklyStats : new ArrayList<>());
        
        // 获取月统计数据
        List<DateCarbonStats> monthlyStats = carbonStatsMapper.getMonthlyCarbonStatsByUserIdAndDateRange(
                userId, start, end.plusDays(1));
        summary.setMonthlyStats(monthlyStats != null ? monthlyStats : new ArrayList<>());
        
        // 计算周均值
        BigDecimal weeklyTotal = weeklyStats.stream()
                .map(DateCarbonStats::getCarbonAmount)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        int weekCount = weeklyStats.size();
        summary.setWeeklyAvgCarbon(weekCount > 0 ? 
                weeklyTotal.divide(BigDecimal.valueOf(weekCount), 2, RoundingMode.HALF_UP) : 
                BigDecimal.ZERO);
        
        // 计算月均值
        BigDecimal monthlyTotal = monthlyStats.stream()
                .map(DateCarbonStats::getCarbonAmount)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        int monthCount = monthlyStats.size();
        summary.setMonthlyAvgCarbon(monthCount > 0 ? 
                monthlyTotal.divide(BigDecimal.valueOf(monthCount), 2, RoundingMode.HALF_UP) : 
                BigDecimal.ZERO);
        
        return summary;
    }
    
    @Override
    public EnvImpactData calculateEnvironmentalImpact(Long userId) {
        // 获取用户总碳减排量
        BigDecimal totalCarbon = carbonRecordMapper.sumCarbonAmountByUserId(userId);
        
        if (totalCarbon == null) {
            totalCarbon = BigDecimal.ZERO;
        }
        
        EnvImpactData impact = new EnvImpactData();
        impact.setCarbonAmount(totalCarbon);
        
        // 计算环境影响指标
        // 1棵树每年约吸收25kg CO2
        BigDecimal treeEquivalent = totalCarbon.divide(
                new BigDecimal("25"), 2, RoundingMode.HALF_UP);
        impact.setTreeEquivalent(treeEquivalent);
        
        // 1升汽油燃烧产生约2.3kg CO2
        BigDecimal fuelSaved = totalCarbon.divide(
                new BigDecimal("2.3"), 2, RoundingMode.HALF_UP);
        impact.setFuelSaved(fuelSaved);
        
        // 1度电平均产生约0.5kg CO2（因地区而异）
        BigDecimal electricitySaved = totalCarbon.divide(
                new BigDecimal("0.5"), 2, RoundingMode.HALF_UP);
        impact.setElectricitySaved(electricitySaved);
        
        return impact;
    }
    
    @Override
    @Transactional(rollbackFor = Exception.class)
    public JDWACarbonReport generateCarbonReport(Long userId, String reportType, String reportDate) {
        // 检查是否已存在相同报告
        LocalDate date = StringUtils.hasText(reportDate) ? 
                LocalDate.parse(reportDate) : LocalDate.now();
        
        LambdaQueryWrapper<JDWACarbonReport> checkWrapper = new LambdaQueryWrapper<>();
        checkWrapper.eq(JDWACarbonReport::getUserId, userId)
                .eq(JDWACarbonReport::getReportType, reportType)
                .eq(JDWACarbonReport::getReportDate, date);
        
        JDWACarbonReport existReport = carbonReportMapper.selectOne(checkWrapper);
        if (existReport != null) {
            return existReport;
        }
        
        // 计算报告日期范围
        LocalDate startDate;
        LocalDate endDate = date;
        
        switch (reportType.toUpperCase()) {
            case "MONTHLY":
                startDate = date.withDayOfMonth(1);
                break;
            case "QUARTERLY":
                int quarter = (date.getMonthValue() - 1) / 3;
                startDate = date.withMonth(quarter * 3 + 1).withDayOfMonth(1);
                break;
            case "YEARLY":
                startDate = date.withDayOfYear(1);
                break;
            default:
                throw new JDWAServiceException("不支持的报告类型: " + reportType);
        }
        
        // 创建报告记录
        JDWACarbonReport report = new JDWACarbonReport();
        report.setUserId(userId);
        report.setReportType(reportType);
        report.setReportDate(date);
        report.setStartDate(startDate);
        report.setEndDate(endDate);
        report.setStatus(0); // 生成中
        
        // 统计数据
        BigDecimal totalCarbon = carbonRecordMapper.sumCarbonAmountByUserIdAndDateRange(
                userId, startDate, endDate.plusDays(1));
        report.setTotalCarbon(totalCarbon != null ? totalCarbon : BigDecimal.ZERO);
        
        Integer totalActivities = carbonRecordMapper.countRecordsByUserIdAndDateRange(
                userId, startDate, endDate.plusDays(1));
        report.setTotalActivities(totalActivities != null ? totalActivities : 0);
        
        // 活动统计数据
        Map<String, Object> activityStats = new HashMap<>();
        
        // 按活动类型统计
        Map<String, BigDecimal> carbonByType = carbonRecordMapper.sumCarbonAmountByUserIdGroupByType(
                userId, startDate, endDate.plusDays(1));
        activityStats.put("carbonByType", carbonByType);
        
        // 按日期统计
        List<DateCarbonStats> dailyStats = carbonStatsMapper.getDailyCarbonStatsByUserIdAndDateRange(
                userId, startDate, endDate.plusDays(1));
        activityStats.put("dailyStats", dailyStats);
        
        report.setActivityStats(JSON.toJSONString(activityStats));
        
        // 环境影响数据
        EnvImpactData impact = calculateEnvironmentalImpact(userId);
        report.setEnvImpact(JSON.toJSONString(impact));
        
        // 生成证书编码
        String certCode = generateCertificationCode(userId, reportType, date);
        report.setCertificationCode(certCode);
        
        // 更新状态为已生成
        report.setStatus(1);
        
        // 保存报告
        carbonReportMapper.insert(report);
        
        return report;
    }
    
    /**
     * 生成证书编码
     */
    private String generateCertificationCode(Long userId, String reportType, LocalDate date) {
        String dateStr = date.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
        String typeCode = reportType.substring(0, 1); // M/Q/Y
        String randomCode = UUID.randomUUID().toString().substring(0, 6).toUpperCase();
        
        return String.format("CR-%s-%s-%s-%s", typeCode, userId, dateStr, randomCode);
    }
    
    /**
     * 更新日统计数据
     */
    private void updateDailyCarbonStats(Long userId, LocalDate date, 
            String recordType, BigDecimal carbonAmount) {
        
        // 获取当日统计记录
        LambdaQueryWrapper<JDWACarbonStats> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(JDWACarbonStats::getUserId, userId)
                .eq(JDWACarbonStats::getStatsType, "DAY")
                .eq(JDWACarbonStats::getStatsDate, date)
                .eq(recordType != null, JDWACarbonStats::getActivityType, recordType);
        
        JDWACarbonStats stats = carbonStatsMapper.selectOne(queryWrapper);
        
        if (stats == null) {
            // 新建统计记录
            stats = new JDWACarbonStats();
            stats.setUserId(userId);
            stats.setStatsType("DAY");
            stats.setStatsDate(date);
            
            stats.setRecordCount(1);
            stats.setTotalDistance(carbonAmount);
            stats.setTotalCarbon(carbonAmount);
            stats.setAvgCarbon(carbonAmount);
            stats.setCreateTime(LocalDateTime.now());
            stats.setUpdateTime(LocalDateTime.now());
        } else {
            // 更新统计记录
            stats.setRecordCount(stats.getRecordCount() + 1);
            stats.setTotalDistance(stats.getTotalDistance().add(carbonAmount));
            stats.setTotalCarbon(stats.getTotalCarbon().add(carbonAmount));
            stats.setAvgCarbon((stats.getTotalCarbon().add(carbonAmount)).divide(
                    BigDecimal.valueOf(stats.getRecordCount() + 1), 2, RoundingMode.HALF_UP));
            stats.setUpdateTime(LocalDateTime.now());
        }
        
        carbonStatsMapper.updateById(stats);
    }

    /**
     * 更新所有用户的碳减排统计数据（定时任务）
     */
    @Scheduled(cron = "0 5 0 * * ?") // 每天凌晨0:05执行
    public void updateAllUserCarbonStats() {
        LocalDate yesterday = LocalDate.now().minusDays(1);
        log.info("开始更新{}的碳减排统计数据", yesterday);
        
        try {
            // 更新日统计数据
            updateDailyCarbonStats(yesterday);
            
            // 当天是周一，更新上周统计
            if (yesterday.getDayOfWeek() == DayOfWeek.SUNDAY) {
                LocalDate weekStart = yesterday.minusDays(6); // 上周一
                updateWeeklyCarbonStats(weekStart, yesterday);
            }
            
            // 当天是月末，更新当月统计
            if (yesterday.getDayOfMonth() == yesterday.lengthOfMonth()) {
                LocalDate monthStart = yesterday.withDayOfMonth(1);
                updateMonthlyCarbonStats(monthStart, yesterday);
            }
            
            // 当天是年末，更新当年统计
            if (yesterday.getDayOfYear() == yesterday.lengthOfYear()) {
                LocalDate yearStart = yesterday.withDayOfYear(1);
                updateYearlyCarbonStats(yearStart, yesterday);
            }
            
            log.info("{}的碳减排统计数据更新完成", yesterday);
        } catch (Exception e) {
            log.error("更新碳减排统计数据失败: {}", e.getMessage(), e);
        }
    }
}

/**
 * 更新所有用户的碳减排统计数据（定时任务）
 */
@Scheduled(cron = "0 5 0 * * ?") // 每天凌晨0:05执行
public void updateAllUserCarbonStats() {
    LocalDate yesterday = LocalDate.now().minusDays(1);
    log.info("开始更新{}的碳减排统计数据", yesterday);
    
    try {
        // 更新日统计数据
        updateDailyCarbonStats(yesterday);
        
        // 当天是周一，更新上周统计
        if (yesterday.getDayOfWeek() == DayOfWeek.SUNDAY) {
            LocalDate weekStart = yesterday.minusDays(6); // 上周一
            updateWeeklyCarbonStats(weekStart, yesterday);
        }
        
        // 当天是月末，更新当月统计
        if (yesterday.getDayOfMonth() == yesterday.lengthOfMonth()) {
            LocalDate monthStart = yesterday.withDayOfMonth(1);
            updateMonthlyCarbonStats(monthStart, yesterday);
        }
        
        // 当天是年末，更新当年统计
        if (yesterday.getDayOfYear() == yesterday.lengthOfYear()) {
            LocalDate yearStart = yesterday.withDayOfYear(1);
            updateYearlyCarbonStats(yearStart, yesterday);
        }
        
        log.info("{}的碳减排统计数据更新完成", yesterday);
    } catch (Exception e) {
        log.error("更新碳减排统计数据失败: {}", e.getMessage(), e);
    }
}

@Cacheable(value = "carbonStats", key = "#userId + '-' + #period", unless = "#result == null")
public CarbonStatsSummary getCarbonStatsSummary(Long userId, String period, 
        String startDate, String endDate) {
    // 实现逻辑...
}