package com.ruoyi.energymeter.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.energymeter.constant.EnergyMeterConstants;
import com.ruoyi.energymeter.dto.DailyUsageRow;
import com.ruoyi.energymeter.dto.DataRangeRow;
import com.ruoyi.energymeter.dto.MeterUsageRow;
import com.ruoyi.energymeter.dto.MonthlyUsageRow;
import com.ruoyi.energymeter.mapper.EnergyMeterDeviceMapper;
import com.ruoyi.energymeter.mapper.EnergyMeterMeasurementMapper;
import com.ruoyi.energymeter.mapper.EnergyMeterSyncRunMapper;
import com.ruoyi.energymeter.pojo.EnergyMeterDevice;
import com.ruoyi.energymeter.pojo.EnergyMeterMeasurement;
import com.ruoyi.energymeter.pojo.EnergyMeterSyncRun;
import com.ruoyi.energymeter.provider.MeterProviderClient;
import com.ruoyi.energymeter.service.ElectricMeterDashboardService;
import com.ruoyi.energymeter.service.EnergyMonitorService;
import com.ruoyi.energymeter.util.EnergyMeterSupport;
import com.ruoyi.energymeter.vo.ElectricMeterDashboardVO;
import com.ruoyi.energymeter.vo.EnergyCollectionVO;
import com.ruoyi.energymeter.vo.EnergyRealtimeVO;
import com.ruoyi.energymeter.vo.EnergyReportVO;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.YearMonth;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 能耗数据采集、实时监控与统计分析实现。
 *
 * <p>统计口径与用能概览保持一致：只汇总 D 粒度的用量指标，表码（POINT）不参与累加；
 * 缺失日期保持 null，由前端显示为缺口而不是 0。</p>
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class EnergyMonitorServiceImpl implements EnergyMonitorService {

    private static final DateTimeFormatter DAY_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd");
    private static final DateTimeFormatter DATETIME_FORMAT = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    private static final List<String> ALL_TYPES = List.of(EnergyMeterConstants.TYPE_WATER,
            EnergyMeterConstants.TYPE_ELECTRIC, EnergyMeterConstants.TYPE_GAS);
    private static final int TREND_DAYS = 7;
    private static final int MAX_REPORT_DAYS = 366;

    private final EnergyMeterDeviceMapper deviceMapper;
    private final EnergyMeterMeasurementMapper measurementMapper;
    private final EnergyMeterSyncRunMapper runMapper;
    private final ElectricMeterDashboardService dashboardService;
    private final MeterProviderClient provider;

    /* ------------------------------------------------------------------ */
    /* 数据采集                                                             */
    /* ------------------------------------------------------------------ */

    @Override
    public EnergyCollectionVO collection() {
        LocalDate today = EnergyMeterSupport.today();
        EnergyCollectionVO vo = new EnergyCollectionVO();
        vo.setGeneratedAt(EnergyMeterSupport.now().format(DATETIME_FORMAT));
        vo.setToday(today.format(DAY_FORMAT));
        vo.setMockMode(provider.mockMode());

        List<EnergyMeterSyncRun> runs = runMapper.selectList(new LambdaQueryWrapper<EnergyMeterSyncRun>()
                .orderByDesc(EnergyMeterSyncRun::getId)
                .last("LIMIT 8"));
        int failed = 0;
        int pending = 0;
        for (EnergyMeterSyncRun run : runs) {
            EnergyCollectionVO.RunItem item = toRunItem(run);
            vo.getRuns().add(item);
            failed += nvl(item.getFailedTasks());
            pending += Math.max(0, nvl(item.getTotalTasks()) - nvl(item.getSuccessTasks())
                    - nvl(item.getEmptyTasks()) - nvl(item.getFailedTasks()));
        }
        vo.setFailedTaskCount(failed);
        vo.setPendingTaskCount(pending);

        for (String type : ALL_TYPES) {
            List<EnergyMeterDevice> devices = loadDevices(type);
            EnergyCollectionVO.Medium medium = new EnergyCollectionVO.Medium();
            medium.setMeterType(type);
            medium.setMeterName(mediumName(type));
            medium.setUnit(EnergyMeterConstants.unit(type));
            medium.setDeviceCount(devices.size());

            int providerCount = 0;
            int manualCount = 0;
            for (EnergyMeterDevice device : devices) {
                if (EnergyMeterConstants.isAutoCollect(device.getSourceType(), device.getSimulated())) {
                    providerCount++;
                } else {
                    manualCount++;
                }
            }
            medium.setProviderCount(providerCount);
            medium.setManualCount(manualCount);

            List<Long> ids = devices.stream().map(EnergyMeterDevice::getId).collect(Collectors.toList());
            DataRangeRow range = ids.isEmpty() ? null
                    : measurementMapper.selectDataRange(ids, EnergyMeterConstants.usageMetric(type));
            LocalDate dataStart = range == null || range.getMinTime() == null ? null : range.getMinTime().toLocalDate();
            LocalDate dataEnd = range == null || range.getMaxTime() == null ? null : range.getMaxTime().toLocalDate();
            medium.setDataStart(dataStart == null ? null : dataStart.format(DAY_FORMAT));
            medium.setDataEnd(dataEnd == null ? null : dataEnd.format(DAY_FORMAT));

            LocalDateTime lastSuccess = devices.stream()
                    .map(EnergyMeterDevice::getLastSuccessAt)
                    .filter(Objects::nonNull)
                    .max(LocalDateTime::compareTo)
                    .orElse(null);
            medium.setLastSuccessAt(lastSuccess == null ? null : lastSuccess.format(DATETIME_FORMAT));

            if (!ids.isEmpty() && dataEnd != null) {
                Integer latestDayMeters = measurementMapper.countMetersWithUsage(ids,
                        EnergyMeterConstants.usageMetric(type), dataEnd.atStartOfDay(),
                        dataEnd.plusDays(1).atStartOfDay());
                medium.setLatestDayMeters(latestDayMeters == null ? 0 : latestDayMeters);
            }

            Map<LocalDate, BigDecimal> daily = ids.isEmpty() ? Map.of() : toDayMap(measurementMapper.sumDailyUsage(ids,
                    EnergyMeterConstants.usageMetric(type), today.minusDays(TREND_DAYS - 1).atStartOfDay(),
                    today.plusDays(1).atStartOfDay()));
            medium.setCoveredDays(daily.size());
            medium.setExpectedDays(TREND_DAYS);
            medium.setCoverageRate(daily.isEmpty() ? BigDecimal.ZERO
                    : BigDecimal.valueOf(daily.size() * 100.0 / TREND_DAYS).setScale(1, RoundingMode.HALF_UP));

            // 在线口径：供应商标记在线，或最近 36 小时成功采集；模拟表再看最近数据日是否已生成
            boolean simulatedFresh = dataEnd != null && !dataEnd.isBefore(today.minusDays(1));
            int onlineCount = 0;
            for (EnergyMeterDevice device : devices) {
                if (isOnline(device)
                        || (EnergyMeterConstants.isSimulated(device.getSimulated()) && simulatedFresh)) {
                    onlineCount++;
                }
            }
            medium.setOnlineCount(onlineCount);

            boolean manualOnly = !devices.isEmpty() && providerCount == 0;
            boolean simulatedOnly = !devices.isEmpty()
                    && devices.stream().allMatch(d -> EnergyMeterConstants.isSimulated(d.getSimulated()));
            applyCollectionStatus(medium, devices.isEmpty(), dataEnd, lastSuccess, manualOnly, simulatedOnly, today);
            vo.getMedia().add(medium);
        }
        return vo;
    }

    private EnergyCollectionVO.RunItem toRunItem(EnergyMeterSyncRun run) {
        EnergyCollectionVO.RunItem item = new EnergyCollectionVO.RunItem();
        item.setId(run.getId());
        item.setRunKey(run.getRunKey());
        item.setTriggerType(run.getTriggerType());
        item.setTriggerTypeName(switch (StringUtils.defaultString(run.getTriggerType())) {
            case EnergyMeterConstants.RUN_SCHEDULED -> "定时同步";
            case EnergyMeterConstants.RUN_BACKFILL -> "历史补采";
            default -> "手动采集";
        });
        item.setStatus(run.getStatus());
        item.setStatusText(switch (StringUtils.defaultString(run.getStatus())) {
            case EnergyMeterConstants.RUN_SUCCESS -> "全部成功";
            case EnergyMeterConstants.RUN_PARTIAL -> "部分失败";
            case EnergyMeterConstants.RUN_FAILED -> "采集失败";
            case EnergyMeterConstants.RUN_RUNNING -> "采集中";
            default -> "待执行";
        });
        item.setRangeStart(run.getRangeStart() == null ? null : run.getRangeStart().format(DAY_FORMAT));
        item.setRangeEnd(run.getRangeEnd() == null ? null : run.getRangeEnd().format(DAY_FORMAT));
        item.setTotalTasks(nvl(run.getTotalTasks()));
        item.setSuccessTasks(nvl(run.getSuccessTasks()));
        item.setEmptyTasks(nvl(run.getEmptyTasks()));
        item.setFailedTasks(nvl(run.getFailedTasks()));
        item.setStartedAt(run.getStartedAt() == null ? null : run.getStartedAt().format(DATETIME_FORMAT));
        item.setFinishedAt(run.getFinishedAt() == null ? null : run.getFinishedAt().format(DATETIME_FORMAT));
        return item;
    }

    private void applyCollectionStatus(EnergyCollectionVO.Medium medium, boolean empty, LocalDate dataEnd,
                                       LocalDateTime lastSuccess, boolean manualOnly, boolean simulatedOnly,
                                       LocalDate today) {
        if (empty) {
            medium.setStatus("NO_DEVICE");
            medium.setStatusText("未接入设备");
            return;
        }
        if (dataEnd == null) {
            medium.setStatus("EMPTY");
            medium.setStatusText("暂无采集数据");
            return;
        }
        if (simulatedOnly) {
            if (dataEnd.isBefore(today.minusDays(1))) {
                medium.setStatus("PARTIAL");
                medium.setStatusText("自动采集数据滞后 " + ChronoUnit.DAYS.between(dataEnd, today) + " 天");
            } else {
                medium.setStatus("OK");
                medium.setStatusText("自动采集数据");
            }
            return;
        }
        if (manualOnly) {
            if (dataEnd.isBefore(today.minusDays(1))) {
                medium.setStatus("PARTIAL");
                medium.setStatusText("数据滞后 " + ChronoUnit.DAYS.between(dataEnd, today) + " 天");
            } else {
                medium.setStatus("OK");
                medium.setStatusText("手工抄表数据");
            }
            return;
        }
        if (lastSuccess == null || lastSuccess.isBefore(EnergyMeterSupport.now().minusHours(36))) {
            medium.setStatus("STALE");
            medium.setStatusText("超过 36 小时无成功采集");
            return;
        }
        if (dataEnd.isBefore(today.minusDays(1))) {
            medium.setStatus("PARTIAL");
            medium.setStatusText("数据滞后 " + ChronoUnit.DAYS.between(dataEnd, today) + " 天");
            return;
        }
        medium.setStatus("OK");
        medium.setStatusText("采集正常");
    }

    /**
     * 在线口径：供应商标记在线，或最近 36 小时内有成功采集。
     *
     * <p>第三方档案的在线标记只在绑定/验证时落库，长期不刷新，不能单独作为“在线”依据。</p>
     */
    private boolean isOnline(EnergyMeterDevice device) {
        if (Integer.valueOf(1).equals(device.getOnlineStatus())) {
            return true;
        }
        return device.getLastSuccessAt() != null
                && device.getLastSuccessAt().isAfter(EnergyMeterSupport.now().minusHours(36));
    }

    /* ------------------------------------------------------------------ */
    /* 实时监控                                                             */
    /* ------------------------------------------------------------------ */

    @Override
    public EnergyRealtimeVO realtime(Long meterId) {
        LocalDate today = EnergyMeterSupport.today();
        LocalDate windowStart = today.minusDays(TREND_DAYS);
        LocalDate monthStart = today.withDayOfMonth(1);

        EnergyRealtimeVO vo = new EnergyRealtimeVO();
        vo.setGeneratedAt(EnergyMeterSupport.now().format(DATETIME_FORMAT));
        vo.setToday(today.format(DAY_FORMAT));
        vo.setMockMode(provider.mockMode());
        vo.setMeterId(meterId);

        List<EnergyMeterDevice> devices;
        List<String> types;
        if (meterId != null) {
            EnergyMeterDevice device = requireDevice(meterId);
            devices = List.of(device);
            String type = EnergyMeterConstants.canonicalType(device.getMeterType());
            if (type == null) {
                throw new ServiceException("设备介质类型不合法");
            }
            types = List.of(type);
            vo.setScopeLabel(device.getDisplayName() + "（" + device.getMeterAddress() + "）");
        } else {
            devices = loadDevices(null);
            types = ALL_TYPES;
            vo.setScopeLabel("全部已接入表具（" + devices.size() + " 台）");
        }

        Map<String, Map<LocalDate, BigDecimal>> dailyByType = new HashMap<>();
        for (String type : types) {
            List<EnergyMeterDevice> typeDevices = devices.stream()
                    .filter(d -> type.equals(d.getMeterType()))
                    .collect(Collectors.toList());
            List<Long> ids = typeDevices.stream().map(EnergyMeterDevice::getId).collect(Collectors.toList());

            Map<LocalDate, BigDecimal> windowDaily = ids.isEmpty() ? Map.of()
                    : toDayMap(measurementMapper.sumDailyUsage(ids, EnergyMeterConstants.usageMetric(type),
                    windowStart.atStartOfDay(), today.plusDays(1).atStartOfDay()));
            dailyByType.put(type, windowDaily);

            EnergyRealtimeVO.Medium medium = new EnergyRealtimeVO.Medium();
            medium.setMeterType(type);
            medium.setMeterName(mediumName(type));
            medium.setUnit(EnergyMeterConstants.unit(type));
            medium.setDeviceCount(typeDevices.size());

            LocalDate latestDate = latestDate(windowDaily, today, windowStart);
            BigDecimal latest = latestDate == null ? null : windowDaily.get(latestDate);
            LocalDate previousDate = latestDate == null ? null
                    : latestDate(windowDaily, latestDate.minusDays(1), windowStart);
            BigDecimal previous = previousDate == null ? null : windowDaily.get(previousDate);

            boolean simulatedFresh = latestDate != null && !latestDate.isBefore(today.minusDays(1));
            medium.setOnlineCount((int) typeDevices.stream()
                    .filter(d -> isOnline(d)
                            || (EnergyMeterConstants.isSimulated(d.getSimulated()) && simulatedFresh))
                    .count());

            medium.setLatestUsage(latest);
            medium.setLatestUsageDate(latestDate == null ? null : latestDate.format(DAY_FORMAT));
            medium.setPreviousUsage(previous);
            medium.setPreviousUsageDate(previousDate == null ? null : previousDate.format(DAY_FORMAT));
            medium.setCompareRate(compareRate(latest, previous));

            BigDecimal monthTotal = null;
            if (!ids.isEmpty()) {
                Map<LocalDate, BigDecimal> monthDaily = toDayMap(measurementMapper.sumDailyUsage(ids,
                        EnergyMeterConstants.usageMetric(type), monthStart.atStartOfDay(),
                        today.plusDays(1).atStartOfDay()));
                monthTotal = sumValues(monthDaily.values());
                if (monthTotal != null) {
                    monthTotal = monthTotal.setScale(3, RoundingMode.HALF_UP);
                }
            }
            medium.setMonthTotal(monthTotal);

            List<BigDecimal> trendValues = new ArrayList<>();
            for (int i = TREND_DAYS - 1; i >= 0; i--) {
                BigDecimal value = windowDaily.get(today.minusDays(i));
                if (value != null) {
                    trendValues.add(value);
                }
            }
            medium.setAvgDaily(average(trendValues));
            medium.setPeakDaily(trendValues.stream().max(BigDecimal::compareTo).orElse(null));

            EnergyMeterMeasurement reading = null;
            for (EnergyMeterDevice device : typeDevices) {
                EnergyMeterMeasurement point = measurementMapper.selectLatestPoint(device.getId(),
                        EnergyMeterConstants.readingMetric(type));
                if (point != null && (reading == null || point.getMeasureTime().isAfter(reading.getMeasureTime()))) {
                    reading = point;
                }
            }
            if (reading != null) {
                medium.setLatestReading(reading.getMetricValue());
                medium.setLatestReadingTime(reading.getMeasureTime().format(DATETIME_FORMAT));
            }

            LocalDateTime lastSuccess = typeDevices.stream()
                    .map(EnergyMeterDevice::getLastSuccessAt)
                    .filter(Objects::nonNull)
                    .max(LocalDateTime::compareTo)
                    .orElse(null);
            medium.setLastSuccessAt(lastSuccess == null ? null : lastSuccess.format(DATETIME_FORMAT));

            boolean manualOnly = !typeDevices.isEmpty()
                    && typeDevices.stream().noneMatch(d ->
                    EnergyMeterConstants.isAutoCollect(d.getSourceType(), d.getSimulated()));
            boolean simulatedOnly = !typeDevices.isEmpty()
                    && typeDevices.stream().allMatch(d -> EnergyMeterConstants.isSimulated(d.getSimulated()));
            applyRealtimeStatus(medium, typeDevices.isEmpty(), latest, latestDate, lastSuccess,
                    manualOnly, simulatedOnly, today);
            vo.getMedia().add(medium);
        }

        /* 近 7 日趋势 */
        for (int i = TREND_DAYS - 1; i >= 0; i--) {
            LocalDate day = today.minusDays(i);
            EnergyRealtimeVO.TrendPoint point = new EnergyRealtimeVO.TrendPoint();
            point.setDay(day.format(DAY_FORMAT));
            point.setWater(dailyByType.getOrDefault(EnergyMeterConstants.TYPE_WATER, Map.of()).get(day));
            point.setElectric(dailyByType.getOrDefault(EnergyMeterConstants.TYPE_ELECTRIC, Map.of()).get(day));
            point.setGas(dailyByType.getOrDefault(EnergyMeterConstants.TYPE_GAS, Map.of()).get(day));
            vo.getTrend().add(point);
        }

        /* 电表实时曲线 */
        if (types.contains(EnergyMeterConstants.TYPE_ELECTRIC)) {
            EnergyRealtimeVO.Electric electric = buildElectric(meterId);
            vo.setElectric(electric);
            if (electric != null) {
                for (EnergyRealtimeVO.Medium medium : vo.getMedia()) {
                    if (EnergyMeterConstants.TYPE_ELECTRIC.equals(medium.getMeterType())) {
                        medium.setCurrentPower(electric.getCurrentPower());
                        medium.setPowerFactor(electric.getPowerFactor());
                    }
                }
            }
        }

        buildAlerts(vo, devices, today);
        return vo;
    }

    private EnergyRealtimeVO.Electric buildElectric(Long meterId) {
        ElectricMeterDashboardVO dashboard;
        try {
            dashboard = dashboardService.dashboard(meterId, 0);
        } catch (Exception e) {
            log.warn("实时监控查询电表 15 分钟数据失败：{}", e.getMessage());
            return null;
        }
        EnergyRealtimeVO.Electric electric = new EnergyRealtimeVO.Electric();
        electric.setRangeStart(dashboard.getToday() == null ? null : dashboard.getToday().getRangeStart());
        electric.setRangeEnd(dashboard.getToday() == null ? null : dashboard.getToday().getRangeEnd());
        electric.setTodayTotal(dashboard.getToday() == null ? null : dashboard.getToday().getTotal());
        electric.setYesterdaySamePeriodTotal(dashboard.getToday() == null ? null
                : dashboard.getToday().getYesterdaySamePeriodTotal());

        List<ElectricMeterDashboardVO.QuarterPoint> points = dashboard.getToday() == null
                ? List.of() : dashboard.getToday().getSeries();
        BigDecimal lastPower = null;
        BigDecimal lastFactor = null;
        for (ElectricMeterDashboardVO.QuarterPoint point : points) {
            EnergyRealtimeVO.CurvePoint curvePoint = new EnergyRealtimeVO.CurvePoint();
            curvePoint.setTime(point.getTime());
            curvePoint.setActive(point.getActive());
            if (point.getActive() == null) {
                electric.getSeries().add(curvePoint);
                continue;
            }
            // 15 分钟电量折算功率：kWh / 0.25h = kW
            BigDecimal power = point.getActive().multiply(BigDecimal.valueOf(4)).setScale(3, RoundingMode.HALF_UP);
            curvePoint.setPower(power);
            electric.getSeries().add(curvePoint);
            lastPower = power;
            lastFactor = powerFactor(power, point.getReactive());
        }
        electric.setCurrentPower(lastPower);
        electric.setPowerFactor(lastFactor);
        return electric;
    }

    private BigDecimal powerFactor(BigDecimal activePower, BigDecimal reactiveEnergy) {
        if (activePower == null) {
            return null;
        }
        BigDecimal reactivePower = reactiveEnergy == null ? BigDecimal.ZERO
                : reactiveEnergy.multiply(BigDecimal.valueOf(4));
        double p = activePower.doubleValue();
        double q = reactivePower.doubleValue();
        if (p <= 0 && q <= 0) {
            return null;
        }
        double factor = p / Math.sqrt(p * p + q * q);
        return BigDecimal.valueOf(Math.min(factor, 1.0)).setScale(3, RoundingMode.HALF_UP);
    }

    private void applyRealtimeStatus(EnergyRealtimeVO.Medium medium, boolean noDevice, BigDecimal latest,
                                     LocalDate latestDate, LocalDateTime lastSuccess, boolean manualOnly,
                                     boolean simulatedOnly, LocalDate today) {
        if (noDevice) {
            medium.setStatus("NO_DEVICE");
            medium.setStatusText("未接入设备");
            return;
        }
        if (latest == null && medium.getLatestReading() == null) {
            medium.setStatus("EMPTY");
            medium.setStatusText("暂无数据");
            return;
        }
        if (simulatedOnly) {
            if (latestDate != null && latestDate.isBefore(today.minusDays(1))) {
                medium.setStatus("STALE");
                medium.setStatusText("自动采集数据滞后");
            } else {
                medium.setStatus("OK");
                medium.setStatusText("自动采集数据");
            }
            return;
        }
        if (manualOnly) {
            if (latestDate != null && latestDate.isBefore(today.minusDays(1))) {
                medium.setStatus("STALE");
                medium.setStatusText("抄表数据滞后");
            } else {
                medium.setStatus("OK");
                medium.setStatusText("手工抄表数据");
            }
            return;
        }
        if (lastSuccess == null || lastSuccess.isBefore(EnergyMeterSupport.now().minusHours(36))) {
            medium.setStatus("STALE");
            medium.setStatusText("采集滞后");
            return;
        }
        medium.setStatus("OK");
        medium.setStatusText("运行正常");
    }

    private void buildAlerts(EnergyRealtimeVO vo, List<EnergyMeterDevice> devices, LocalDate today) {
        List<EnergyRealtimeVO.Alert> alerts = vo.getAlerts();
        for (EnergyRealtimeVO.Medium medium : vo.getMedia()) {
            if ("STALE".equals(medium.getStatus()) || "EMPTY".equals(medium.getStatus())) {
                alerts.add(alert("warning", medium.getMeterName() + "：" + medium.getStatusText()
                        + "，请检查设备或手动采集"));
            }
        }
        int deviceAlerts = 0;
        for (EnergyMeterDevice device : devices) {
            if (StringUtils.isNotBlank(device.getLastErrorCode()) && deviceAlerts < 3) {
                String message = StringUtils.isBlank(device.getLastErrorMessage())
                        ? device.getLastErrorCode() : device.getLastErrorMessage();
                alerts.add(alert("warning", "「" + device.getDisplayName() + "」最近一次采集失败：" + message));
                deviceAlerts++;
            }
        }
        if (Boolean.TRUE.equals(vo.getMockMode())) {
            alerts.add(alert("info", "当前为演示数据模式，采集结果由本地模拟生成，仅用于联调与页面演示。"));
        }
        if (alerts.size() > 6) {
            vo.setAlerts(new ArrayList<>(alerts.subList(0, 6)));
        }
    }

    private EnergyRealtimeVO.Alert alert(String level, String text) {
        EnergyRealtimeVO.Alert alert = new EnergyRealtimeVO.Alert();
        alert.setLevel(level);
        alert.setText(text);
        return alert;
    }

    /* ------------------------------------------------------------------ */
    /* 统计分析                                                             */
    /* ------------------------------------------------------------------ */

    @Override
    public EnergyReportVO report(String startDate, String endDate, String granularity, String meterType,
                                 String dimension) {
        LocalDate today = EnergyMeterSupport.today();
        LocalDate start = StringUtils.isBlank(startDate) ? today.withDayOfMonth(1) : parseDate(startDate, "开始日期");
        LocalDate end = StringUtils.isBlank(endDate) ? today : parseDate(endDate, "结束日期");
        if (end.isBefore(start)) {
            throw new ServiceException("结束日期不能早于开始日期");
        }
        if (ChronoUnit.DAYS.between(start, end) > MAX_REPORT_DAYS) {
            throw new ServiceException("统计跨度不能超过 " + MAX_REPORT_DAYS + " 天，请缩小时间范围");
        }

        String gran = "MONTH".equalsIgnoreCase(StringUtils.trim(granularity)) ? "MONTH" : "DAY";
        String dim = "DEVICE".equalsIgnoreCase(StringUtils.trim(dimension)) ? "DEVICE" : "MEDIUM";
        String filterType = StringUtils.isBlank(meterType) || "ALL".equalsIgnoreCase(meterType.trim())
                ? "ALL" : EnergyMeterConstants.canonicalType(meterType);
        if (filterType == null) {
            throw new ServiceException("能源类型只支持水表（WATER）、电表（ELECTRIC）或蒸汽表（GAS）");
        }
        List<String> types = "ALL".equals(filterType) ? ALL_TYPES : List.of(filterType);

        EnergyReportVO vo = new EnergyReportVO();
        vo.setGeneratedAt(EnergyMeterSupport.now().format(DATETIME_FORMAT));
        vo.setMockMode(provider.mockMode());
        vo.setStart(start.format(DAY_FORMAT));
        vo.setEnd(end.format(DAY_FORMAT));
        vo.setGranularity(gran);
        vo.setDimension(dim);
        vo.setMeterType(filterType);

        List<String> periods = buildPeriods(start, end, gran);
        vo.setPeriods(periods);
        vo.setTotalPeriods(periods.size());
        vo.setNote("统计口径：仅汇总日粒度用量，表码不参与累加；缺失周期按空值展示，不按 0 计算。");

        List<EnergyMeterDevice> devices = loadDevices(null).stream()
                .filter(d -> types.contains(d.getMeterType()))
                .collect(Collectors.toList());

        Map<String, Map<String, BigDecimal>> valuesByType = new HashMap<>();
        for (String type : types) {
            List<Long> ids = devices.stream()
                    .filter(d -> type.equals(d.getMeterType()))
                    .map(EnergyMeterDevice::getId)
                    .collect(Collectors.toList());
            Map<String, BigDecimal> values = new HashMap<>();
            if (!ids.isEmpty()) {
                if ("MONTH".equals(gran)) {
                    for (MonthlyUsageRow row : measurementMapper.sumMonthlyUsage(ids,
                            EnergyMeterConstants.usageMetric(type), start.atStartOfDay(),
                            end.plusDays(1).atStartOfDay())) {
                        if (row.getMonth() != null && row.getTotal() != null) {
                            values.put(row.getMonth(), row.getTotal());
                        }
                    }
                } else {
                    for (DailyUsageRow row : measurementMapper.sumDailyUsage(ids,
                            EnergyMeterConstants.usageMetric(type), start.atStartOfDay(),
                            end.plusDays(1).atStartOfDay())) {
                        if (row.getDay() != null && row.getTotal() != null) {
                            values.put(row.getDay(), row.getTotal());
                        }
                    }
                }
            }
            valuesByType.put(type, values);
        }

        int coveredPeriods = 0;
        for (String period : periods) {
            EnergyReportVO.PeriodRow row = new EnergyReportVO.PeriodRow();
            row.setPeriod(period);
            boolean hasValue = false;
            for (String type : types) {
                BigDecimal value = valuesByType.get(type).get(period);
                if (value != null) {
                    hasValue = true;
                }
                if (EnergyMeterConstants.isWater(type)) {
                    row.setWater(value);
                } else if (EnergyMeterConstants.isElectric(type)) {
                    row.setElectric(value);
                } else {
                    row.setGas(value);
                }
            }
            if (hasValue) {
                coveredPeriods++;
            }
            vo.getRows().add(row);
        }
        vo.setCoveredPeriods(coveredPeriods);

        Map<String, BigDecimal> mediumTotals = new HashMap<>();
        for (String type : types) {
            BigDecimal total = sumValues(valuesByType.get(type).values());
            mediumTotals.put(type, total);
            EnergyReportVO.MediumTotal mediumTotal = new EnergyReportVO.MediumTotal();
            mediumTotal.setMeterType(type);
            mediumTotal.setMeterName(mediumName(type));
            mediumTotal.setUnit(EnergyMeterConstants.unit(type));
            mediumTotal.setTotal(total == null ? null : total.setScale(3, RoundingMode.HALF_UP));
            mediumTotal.setDeviceCount((int) devices.stream()
                    .filter(d -> type.equals(d.getMeterType())).count());
            vo.getTotals().add(mediumTotal);
        }

        for (String type : types) {
            List<EnergyMeterDevice> typeDevices = devices.stream()
                    .filter(d -> type.equals(d.getMeterType()))
                    .collect(Collectors.toList());
            if (typeDevices.isEmpty()) {
                continue;
            }
            List<Long> ids = typeDevices.stream().map(EnergyMeterDevice::getId).collect(Collectors.toList());
            Map<Long, BigDecimal> usageMap = new HashMap<>();
            for (MeterUsageRow row : measurementMapper.sumUsageByMeter(ids, EnergyMeterConstants.usageMetric(type),
                    start.atStartOfDay(), end.plusDays(1).atStartOfDay())) {
                if (row.getMeterId() != null && row.getTotal() != null) {
                    usageMap.put(row.getMeterId(), row.getTotal());
                }
            }
            BigDecimal mediumTotal = mediumTotals.get(type);
            for (EnergyMeterDevice device : typeDevices) {
                EnergyReportVO.DeviceRow row = new EnergyReportVO.DeviceRow();
                row.setMeterId(device.getId());
                row.setMeterName(device.getDisplayName());
                row.setMeterAddress(device.getMeterAddress());
                row.setMeterType(type);
                row.setMeterTypeName(mediumName(type));
                row.setSourceTypeName(EnergyMeterConstants.isAutoCollect(device.getSourceType(), device.getSimulated())
                        ? "自动采集" : "手工抄表");
                row.setUnit(EnergyMeterConstants.unit(type));
                BigDecimal total = usageMap.get(device.getId());
                row.setTotal(total == null ? null : total.setScale(3, RoundingMode.HALF_UP));
                if (total != null && mediumTotal != null && mediumTotal.compareTo(BigDecimal.ZERO) > 0) {
                    row.setShare(total.multiply(BigDecimal.valueOf(100))
                            .divide(mediumTotal, 1, RoundingMode.HALF_UP));
                }
                vo.getDevices().add(row);
            }
        }
        vo.getDevices().sort(Comparator
                .comparingInt((EnergyReportVO.DeviceRow row) -> typeOrder(row.getMeterType()))
                .thenComparing(EnergyReportVO.DeviceRow::getTotal, Comparator.nullsLast(Comparator.reverseOrder()))
                .thenComparing(EnergyReportVO.DeviceRow::getMeterId));
        return vo;
    }

    private int typeOrder(String type) {
        if (EnergyMeterConstants.isWater(type)) {
            return 0;
        }
        if (EnergyMeterConstants.isElectric(type)) {
            return 1;
        }
        return 2;
    }

    private List<String> buildPeriods(LocalDate start, LocalDate end, String gran) {
        List<String> periods = new ArrayList<>();
        if ("MONTH".equals(gran)) {
            YearMonth month = YearMonth.from(start);
            YearMonth last = YearMonth.from(end);
            while (!month.isAfter(last)) {
                periods.add(month.toString());
                month = month.plusMonths(1);
            }
        } else {
            for (LocalDate day = start; !day.isAfter(end); day = day.plusDays(1)) {
                periods.add(day.format(DAY_FORMAT));
            }
        }
        return periods;
    }

    /* ------------------------------------------------------------------ */
    /* 工具                                                                 */
    /* ------------------------------------------------------------------ */

    private List<EnergyMeterDevice> loadDevices(String meterType) {
        LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
        Long tenantId = EnergyMeterSupport.currentTenantId();
        if (tenantId != null) {
            wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
        }
        if (StringUtils.isNotBlank(meterType)) {
            wrapper.eq(EnergyMeterDevice::getMeterType, meterType);
        }
        wrapper.eq(EnergyMeterDevice::getEnabled, 1)
                .eq(EnergyMeterDevice::getBindStatus, EnergyMeterConstants.BIND_VERIFIED)
                .orderByAsc(EnergyMeterDevice::getId);
        return deviceMapper.selectList(wrapper);
    }

    private EnergyMeterDevice requireDevice(Long meterId) {
        EnergyMeterDevice device = deviceMapper.selectById(meterId);
        if (device == null) {
            throw new ServiceException("设备不存在或已删除");
        }
        Long tenantId = EnergyMeterSupport.currentTenantId();
        if (tenantId != null && device.getTenantId() != null && !tenantId.equals(device.getTenantId())) {
            throw new ServiceException("无权访问该设备");
        }
        return device;
    }

    private String mediumName(String meterType) {
        if (EnergyMeterConstants.isWater(meterType)) {
            return "水表";
        }
        if (EnergyMeterConstants.isElectric(meterType)) {
            return "电表";
        }
        if (EnergyMeterConstants.isGas(meterType)) {
            return "蒸汽表";
        }
        return meterType;
    }

    private Map<LocalDate, BigDecimal> toDayMap(List<DailyUsageRow> rows) {
        Map<LocalDate, BigDecimal> map = new HashMap<>();
        for (DailyUsageRow row : rows) {
            if (row.getDay() != null && row.getTotal() != null) {
                map.put(LocalDate.parse(row.getDay()), row.getTotal());
            }
        }
        return map;
    }

    private LocalDate latestDate(Map<LocalDate, BigDecimal> daily, LocalDate from, LocalDate floor) {
        LocalDate day = from;
        while (!day.isBefore(floor)) {
            BigDecimal value = daily.get(day);
            if (value != null) {
                return day;
            }
            day = day.minusDays(1);
        }
        return null;
    }

    private BigDecimal compareRate(BigDecimal latest, BigDecimal previous) {
        if (latest == null || previous == null || previous.compareTo(BigDecimal.ZERO) <= 0) {
            return null;
        }
        return latest.subtract(previous)
                .multiply(BigDecimal.valueOf(100))
                .divide(previous, 1, RoundingMode.HALF_UP);
    }

    private BigDecimal sumValues(java.util.Collection<BigDecimal> values) {
        BigDecimal sum = BigDecimal.ZERO;
        boolean hasValue = false;
        for (BigDecimal value : values) {
            if (value != null) {
                sum = sum.add(value);
                hasValue = true;
            }
        }
        return hasValue ? sum : null;
    }

    private BigDecimal average(List<BigDecimal> values) {
        if (values == null || values.isEmpty()) {
            return null;
        }
        BigDecimal sum = BigDecimal.ZERO;
        for (BigDecimal value : values) {
            sum = sum.add(value);
        }
        return sum.divide(BigDecimal.valueOf(values.size()), 3, RoundingMode.HALF_UP);
    }

    private int nvl(Integer value) {
        return value == null ? 0 : value;
    }

    private LocalDate parseDate(String value, String label) {
        try {
            return LocalDate.parse(value.trim());
        } catch (Exception e) {
            throw new ServiceException(label + "格式应为 yyyy-MM-dd");
        }
    }
}