feat: 新增eq_kwh综合统计查询接口

@@ -193,4 +193,19 @@ public class HealthController {
             @RequestParam(defaultValue = "12") Integer pageSize) {
             @RequestParam(defaultValue = "12") Integer pageSize) {
         return energySearchService.queryEnergyTimelineStatus(date, pageNo, pageSize);
         return energySearchService.queryEnergyTimelineStatus(date, pageNo, pageSize);
     }
     }
+
+    /**
+     * eq_kwh综合统计查询
+     * 查询指定日期范围内所有设备的稼动率、各状态时长、异常排名等
+     *
+     * @param startDate 开始日期 yyyy-MM-dd
+     * @param endDate   结束日期 yyyy-MM-dd
+     * @return 包含: 总稼动率、各状态时间(xxx.xx时)、当前运行状态、异常机台排名、每设备0/1/2/3状态时间
+     */
+    @GetMapping("/energy/eqKwhStatistics")
+    public Map<String, Object> eqKwhStatistics(
+            @RequestParam String startDate,
+            @RequestParam String endDate) {
+        return energySearchService.queryEqKwhStatistics(startDate, endDate);
+    }
 }
 }

@@ -545,4 +545,334 @@ public class EnergySearchService {
         sb.append(s).append("秒");
         sb.append(s).append("秒");
         return sb.toString();
         return sb.toString();
     }
     }
+
+    /**
+     * 格式化时长为 xxx.xx 时
+     */
+    private static String formatDurationToHours(long totalSeconds) {
+        double hours = totalSeconds / 3600.0;
+        return String.format("%.2f时", hours);
+    }
+
+    // ==================== eq_kwh 综合统计查询 ====================
+
+    /**
+     * 查询 eq_kwh 表的综合统计数据
+     * 返回：
+     *   1. 所有设备的总的稼动率 + 每个状态的时间(xxx.xx时)
+     *   2. 当前设备的运行状态
+     *   3. 异常机台排名(待机+停机时间最长往下排, xx时xx分xx秒)
+     *   4. 每个设备统计时间内的总的0/1/2/3的时间(xx时xx分xx秒)
+     *
+     * @param startDate 开始日期 yyyy-MM-dd
+     * @param endDate   结束日期 yyyy-MM-dd
+     */
+    public Map<String, Object> queryEqKwhStatistics(String startDate, String endDate) {
+        log.info("========== [eq_kwh综合统计] startDate={}, endDate={} ==========", startDate, endDate);
+
+        if (!StringUtils.hasText(startDate) || !StringUtils.hasText(endDate)) {
+            return Map.of(
+                    "code", 400, "msg", "参数错误: startDate和endDate必填",
+                    "data", Map.of()
+            );
+        }
+
+        // 1. 构建日期列表
+        List<String> dateList = buildDateList(startDate, endDate);
+        if (dateList.isEmpty()) {
+            return buildEmptyEqKwhStats();
+        }
+        log.info("日期范围共 {} 天: {} ~ {}", dateList.size(), dateList.get(0), dateList.get(dateList.size() - 1));
+
+        // 2. 获取所有设备列表及名称
+        Map<String, String> deviceNameMap = queryAllEnergyDeviceNames();
+
+        // 3. 从 eq_kwh 表批量查询所有设备在指定日期范围内的数据
+        List<Map<String, Object>> allRawData = queryEqKwhBatch(dateList);
+        log.info("eq_kwh 批量查询返回 {} 条原始记录", allRawData.size());
+
+        // 4. 按 dtuSn 分组聚合数据，计算每个设备的各状态时长
+        Map<String, DeviceStatResult> deviceStatMap = aggregateByDevice(allRawData, deviceNameMap);
+
+        // 确保所有设备都在结果中（无数据的设为0）
+        for (String sn : deviceNameMap.keySet()) {
+            if (!deviceStatMap.containsKey(sn)) {
+                deviceStatMap.put(sn, new DeviceStatResult(sn, deviceNameMap.getOrDefault(sn, "")));
+            }
+        }
+
+        // 5. 计算全局汇总
+        return buildEqKwhStatisticsResult(deviceStatMap, deviceNameMap);
+    }
+
+    /** 设备统计内部结构 */
+    static class DeviceStatResult {
+        String dtuSn;
+        String deviceName;
+        long status0; // 离线时长(秒)
+        long status1; // 停机时长(秒)
+        long status2; // 待机时长(秒)
+        long status3; // 运行时长(秒)
+        double totalKwh; // 总用电量
+
+        DeviceStatResult(String dtuSn, String deviceName) {
+            this.dtuSn = dtuSn;
+            this.deviceName = deviceName;
+        }
+
+        /** 总时长(秒) */
+        long totalDuration() { return status0 + status1 + status2 + status3; }
+        /** 异常时长 = 停机 + 待机 */
+        long abnormalDuration() { return status1 + status2; }
+        /** 稼动分母 = 停机 + 待机 + 运行 (排除离线) */
+        long activeDuration() { return status1 + status2 + status3; }
+    }
+
+    /** 构建空结果 */
+    private Map<String, Object> buildEmptyEqKwhStats() {
+        return Map.of(
+                "code", 200, "msg", "请求成功", "data",
+                Map.of(
+                        "summary", Map.of(
+                                "availabilityRate", "0.00%",
+                                "totalStatusDuration", Map.of(
+                                        "status0", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                        "status1", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                        "status2", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时"),
+                                        "status3", Map.of("durationFormatted", "0时0分0秒", "durationSeconds", 0L, "durationHours", "0.00时")
+                                )
+                        ),
+                        "currentStatus", Map.of("0", 0, "1", 0, "2", 0, "3", 0),
+                        "abnormalRanking", List.of(),
+                        "deviceList", List.of()
+                )
+        );
+    }
+
+    /** 获取能耗设备表所有dtuSn及名称 */
+    private Map<String, String> queryAllEnergyDeviceNames() {
+        String sql = "SELECT dtuSn, deviceName FROM " + energyTableName + " WHERE corp_code = ? ORDER BY dtuSn";
+        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, energyCorpCode);
+        Map<String, String> result = new LinkedHashMap<>(rows.size());
+        for (Map<String, Object> row : rows) {
+            result.put((String) row.get("dtuSn"), (String) row.get("deviceName"));
+        }
+        return result;
+    }
+
+    /** 构建连续日期列表 */
+    private List<String> buildDateList(String startDate, String endDate) {
+        List<String> result = new ArrayList<>();
+        try {
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+            Calendar cur = Calendar.getInstance();
+            cur.setTime(sdf.parse(startDate));
+            Calendar endCal = Calendar.getInstance();
+            endCal.setTime(sdf.parse(endDate));
+            while (!cur.after(endCal)) {
+                result.add(sdf.format(cur.getTime()));
+                cur.add(Calendar.DAY_OF_MONTH, 1);
+            }
+        } catch (Exception e) {
+            log.error("日期解析失败: {} ~ {}", startDate, endDate, e);
+        }
+        return result;
+    }
+
+    /** 从 eq_kwh 表批量查询指定日期范围的所有记录 */
+    private List<Map<String, Object>> queryEqKwhBatch(List<String> dateList) {
+        if (dateList.isEmpty()) return Collections.emptyList();
+
+        StringBuilder sql = new StringBuilder(
+                "SELECT dtuSn, use_date, description FROM " + eqKwhTableName +
+                        " WHERE corp_code = ? AND use_date IN (");
+        List<Object> params = new ArrayList<>();
+        params.add(energyCorpCode);
+
+        for (String d : dateList) { sql.append("?,"); params.add(d + " 00:00:00"); }
+        sql.deleteCharAt(sql.length() - 1).append(")");
+        sql.append(" ORDER BY dtuSn, use_date");
+
+        return jdbcTemplate.queryForList(sql.toString(), params.toArray());
+    }
+
+    /** 按 dtuSn 分组聚合各状态时长 */
+    private Map<String, DeviceStatResult> aggregateByDevice(List<Map<String, Object>> rawData,
+                                                            Map<String, String> deviceNameMap) {
+        Map<String, DeviceStatResult> resultMap = new LinkedHashMap<>();
+
+        for (Map<String, Object> row : rawData) {
+            String sn = (String) row.get("dtuSn");
+            String desc = row.get("description") != null ? String.valueOf(row.get("description")) : "";
+
+            DeviceStatResult dsr = resultMap.computeIfAbsent(sn,
+                    k -> new DeviceStatResult(k, deviceNameMap.getOrDefault(k, "")));
+
+            if (!StringUtils.hasText(desc)) continue;
+
+            try {
+                JSONArray dataArray = JSON.parseArray(desc);
+                if (dataArray == null) continue;
+
+                for (int i = 0; i < dataArray.size(); i++) {
+                    JSONObject item = dataArray.getJSONObject(i);
+                    if (item == null) continue;
+
+                    // 用电量
+                    Double value = item.getDouble("value");
+                    if (value != null) dsr.totalKwh += value;
+
+                    // 各状态时长: 0-离线, 1-停机, 2-待机, 3-运行
+                    for (int sk = 0; sk <= 3; sk++) {
+                        Long dur = item.getLong(String.valueOf(sk));
+                        if (dur != null && dur > 0) {
+                            switch (sk) {
+                                case 0 -> dsr.status0 += dur;
+                                case 1 -> dsr.status1 += dur;
+                                case 2 -> dsr.status2 += dur;
+                                case 3 -> dsr.status3 += dur;
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.warn("解析eq_kwh description异常 - dtuSn:{}", sn, e);
+            }
+        }
+
+        return resultMap;
+    }
+
+    /** 构建最终统计结果 */
+    private Map<String, Object> buildEqKwhStatisticsResult(Map<String, DeviceStatResult> deviceStatMap,
+                                                           Map<String, String> deviceNameMap) {
+        // ---- 全局汇总 ----
+        long totalS0 = 0, totalS1 = 0, totalS2 = 0, totalS3 = 0;
+        double totalKwhSum = 0;
+
+        // ---- 设备详情列表 ----
+        List<Map<String, Object>> deviceList = new ArrayList<>(deviceStatMap.size());
+
+        for (Map.Entry<String, DeviceStatResult> entry : deviceStatMap.entrySet()) {
+            DeviceStatResult dsr = entry.getValue();
+
+            totalS0 += dsr.status0; totalS1 += dsr.status1;
+            totalS2 += dsr.status2; totalS3 += dsr.status3;
+            totalKwhSum += dsr.totalKwh;
+
+            // 单设备稼动率 = 运行 / (停机+待机+运行)
+            long active = dsr.activeDuration();
+            double devRate = active > 0 ? Math.round(dsr.status3 * 10000.0 / active) / 100.0 : 0.0;
+
+            Map<String, Object> devItem = new LinkedHashMap<>();
+            devItem.put("dtuSn", dsr.dtuSn);
+            devItem.put("deviceName", dsr.deviceName);
+            // 各状态时长 - 格式化为 xx时xx分xx秒
+            devItem.put("status0", Map.of(
+                    "durationFormatted", formatDuration(dsr.status0),
+                    "durationSeconds", dsr.status0,
+                    "durationHours", formatDurationToHours(dsr.status0)
+            ));
+            devItem.put("status1", Map.of(
+                    "durationFormatted", formatDuration(dsr.status1),
+                    "durationSeconds", dsr.status1,
+                    "durationHours", formatDurationToHours(dsr.status1)
+            ));
+            devItem.put("status2", Map.of(
+                    "durationFormatted", formatDuration(dsr.status2),
+                    "durationSeconds", dsr.status2,
+                    "durationHours", formatDurationToHours(dsr.status2)
+            ));
+            devItem.put("status3", Map.of(
+                    "durationFormatted", formatDuration(dsr.status3),
+                    "durationSeconds", dsr.status3,
+                    "durationHours", formatDurationToHours(dsr.status3)
+            ));
+            devItem.put("totalDurationFormatted", formatDuration(dsr.totalDuration()));
+            devItem.put("totalDurationSeconds", dsr.totalDuration());
+            devItem.put("totalDurationHours", formatDurationToHours(dsr.totalDuration()));
+            devItem.put("totalKwh", Math.round(dsr.totalKwh * 100.0) / 100.0);
+            devItem.put("availabilityRate", String.format("%.2f%%", devRate));
+            devItem.put("availabilityRateValue", devRate);
+            // 异常时长用于排序(内部字段，后面移除)
+            devItem.put("_abnormalDur", dsr.abnormalDuration());
+
+            deviceList.add(devItem);
+        }
+
+        // ---- ① 总稼动率 ----
+        long totalActive = totalS1 + totalS2 + totalS3;
+        double overallAvailabilityRate = totalActive > 0
+                ? Math.round(totalS3 * 10000.0 / totalActive) / 100.0 : 0.0;
+
+        // ---- ② 当前设备运行状态（从energy表查） ----
+        Map<String, Integer> currentStatus = queryCurrentRunStatus();
+
+        // ---- ③ 异常机台排名(按 停机+待机 降序) ----
+        deviceList.sort((a, b) -> Long.compare(
+                ((Number) b.get("_abnormalDur")).longValue(),
+                ((Number) a.get("_abnormalDur")).longValue()
+        ));
+        // 移除辅助字段
+        for (Map<String, Object> d : deviceList) {
+            d.remove("_abnormalDur");
+        }
+
+        return Map.of(
+                "code", 200, "msg", "请求成功", "data",
+                Map.of(
+                        "summary", Map.of(
+                                "availabilityRate", String.format("%.2f%%", overallAvailabilityRate),
+                                "availabilityRateValue", overallAvailabilityRate,
+                                "totalDevices", deviceNameMap.size(),
+                                "totalKwh", Math.round(totalKwhSum * 100.0) / 100.0,
+                                "totalStatusDuration", Map.of(
+                                        "status0", Map.of(
+                                                "durationFormatted", formatDuration(totalS0),
+                                                "durationSeconds", totalS0,
+                                                "durationHours", formatDurationToHours(totalS0)
+                                        ),
+                                        "status1", Map.of(
+                                                "durationFormatted", formatDuration(totalS1),
+                                                "durationSeconds", totalS1,
+                                                "durationHours", formatDurationToHours(totalS1)
+                                        ),
+                                        "status2", Map.of(
+                                                "durationFormatted", formatDuration(totalS2),
+                                                "durationSeconds", totalS2,
+                                                "durationHours", formatDurationToHours(totalS2)
+                                        ),
+                                        "status3", Map.of(
+                                                "durationFormatted", formatDuration(totalS3),
+                                                "durationSeconds", totalS3,
+                                                "durationHours", formatDurationToHours(totalS3)
+                                        )
+                                )
+                        ),
+                        "currentStatus", currentStatus,
+                        "abnormalRanking", deviceList,
+                        "deviceList", deviceList
+                )
+        );
+    }
+
+    /** 查询当前设备运行状态分布(从energy表) runStatus: 0-离线, 1-停机, 2-待机, 3-运行 */
+    private Map<String, Integer> queryCurrentRunStatus() {
+        String sql = "SELECT runStatus, COUNT(*) as cnt FROM " + energyTableName +
+                " WHERE corp_code = ? GROUP BY runStatus";
+        List<Map<String, Object>> rows = jdbcTemplate.queryForList(sql, energyCorpCode);
+
+        int s0 = 0, s1 = 0, s2 = 0, s3 = 0;
+        for (Map<String, Object> row : rows) {
+            String key = String.valueOf(row.get("runStatus"));
+            int cnt = ((Number) row.get("cnt")).intValue();
+            switch (key) {
+                case "0" -> s0 = cnt;
+                case "1" -> s1 = cnt;
+                case "2" -> s2 = cnt;
+                case "3" -> s3 = cnt;
+            }
+        }
+        return Map.of("0", s0, "1", s1, "2", s2, "3", s3);
+    }
 }
 }