a-tuoheng-device/src/main/java/com/ruoyi/device/controller/StaticsController.java

package com.ruoyi.device.controller;

import com.ruoyi.common.core.domain.R;
import com.ruoyi.common.core.web.controller.BaseController;
import com.ruoyi.device.api.domain.StatisticsVO;
import com.ruoyi.device.api.enums.AircraftStatusEnum;
import com.ruoyi.device.api.enums.DockStatusEnum;
import com.ruoyi.device.api.enums.PayloadStatusEnum;
import com.ruoyi.device.service.api.IAircraftService;
import com.ruoyi.device.service.api.IBufferDeviceService;
import com.ruoyi.device.service.api.IDockService;
import com.ruoyi.device.service.api.IPayloadService;
import com.ruoyi.device.service.dto.AircraftDTO;
import com.ruoyi.device.service.dto.AircraftDetailDTO;
import com.ruoyi.device.service.dto.DockDTO;
import com.ruoyi.device.service.dto.DockDetailDTO;
import com.ruoyi.device.service.dto.PayloadDTO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 统计Controller
 *
 * @author ruoyi
 * @date 2026-01-23
 */
@RestController
@RequestMapping("/statistics")
public class StaticsController extends BaseController
{
    private static final Logger log = LoggerFactory.getLogger(StaticsController.class);

    @Autowired
    private IDockService dockService;

    @Autowired
    private IAircraftService aircraftService;

    @Autowired
    private IPayloadService payloadService;

    @Autowired
    private IBufferDeviceService bufferDeviceService;

    /**
     * 获取系统统计信息
     *
     * @return 统计信息
     */
    @GetMapping
    public R<StatisticsVO> getStatistics()
    {
        return R.ok(buildDjiStatisticsVO());
    }





    @GetMapping("/dji")
    public R<StatisticsVO> getDjiStatistics()
    {
        return R.ok(buildDjiStatisticsVO());
    }


    @GetMapping("/th")
    public R<StatisticsVO> getThStatistics()
    {
        StatisticsVO vo = new StatisticsVO();

        // 机场统计
        vo.setDockCount(0);
        vo.setIdleDockCount(0);
        vo.setWorkingDockCount(0);
        vo.setDebuggingDockCount(0);
        vo.setOfflineDockCount(0);

        // 无人机统计
        vo.setAircraftCount(0);
        vo.setPowerOnInCabinCount(0);
        vo.setPowerOffInCabinCount(0);
        vo.setInMissionCount(0);
        vo.setDebuggingAircraftCount(0);
        vo.setOfflineAircraftCount(0);

        // 挂载统计
        vo.setPayloadCount(0);
        vo.setOfflinePayloadCount(0);

        return R.ok(vo);
    }

    private StatisticsVO buildDjiStatisticsVO (){
        log.info("========== 开始统计DJI设备信息 ==========");
        StatisticsVO vo = new StatisticsVO();

        // 获取所有机场
        List<DockDTO> docks = dockService.selectDockList(new DockDTO());
        vo.setDockCount(docks != null ? docks.size() : 0);
        log.info("机场总数: {}", vo.getDockCount());

        // 批量获取机场详情 - 优化：从N次查询减少到1次批量查询
        Map<Long, DockDetailDTO> dockDetailsMap = null;
        if (docks != null && !docks.isEmpty()) {
            List<Long> dockIds = docks.stream()
                    .map(DockDTO::getDockId)
                    .collect(Collectors.toList());
            dockDetailsMap = bufferDeviceService.getDockDetailsByIds(dockIds);
        }

        // 统计各状态机场数量
        int idleCount = 0;
        int workingCount = 0;
        int debuggingCount = 0;
        int offlineCount = 0;

        if (docks != null && dockDetailsMap != null) {
            log.info("---------- 开始统计机场状态 ----------");
            for (DockDTO dock : docks) {
                DockDetailDTO dockDetail = dockDetailsMap.get(dock.getDockId());
                if (dockDetail != null && dockDetail.getDockStatus() != null) {
                    String status = dockDetail.getDockStatus();
                    log.info("机场[ID:{}, Name:{}] 状态: {}", dock.getDockId(), dock.getDockName(), status);
                    if (DockStatusEnum.IDLE.getCode().equalsIgnoreCase(status)) {
                        idleCount++;
                        log.debug("  -> 匹配到IDLE状态");
                    } else if (DockStatusEnum.WORKING.getCode().equalsIgnoreCase(status)) {
                        workingCount++;
                        log.info("  -> 匹配到WORKING状态 (任务中)");
                    } else if (DockStatusEnum.Debugging.getCode().equalsIgnoreCase(status)) {
                        debuggingCount++;
                        log.debug("  -> 匹配到Debugging状态");
                    } else {
                        offlineCount++;
                        log.debug("  -> 其他状态，归类为离线");
                    }
                }
            }
        }

        vo.setIdleDockCount(idleCount);
        vo.setWorkingDockCount(workingCount);
        vo.setDebuggingDockCount(debuggingCount);
        vo.setOfflineDockCount(offlineCount);

        log.info("机场状态统计结果 -> 空闲:{}, 任务中:{}, 调试:{}, 离线:{}", idleCount, workingCount, debuggingCount, offlineCount);

        // 获取所有无人机
        List<AircraftDTO> aircrafts = aircraftService.selectAircraftList(new AircraftDTO());
        vo.setAircraftCount(aircrafts != null ? aircrafts.size() : 0);
        log.info("无人机总数: {}", vo.getAircraftCount());

        // 批量获取无人机详情 - 优化：从N次查询减少到1次批量查询
        Map<Long, AircraftDetailDTO> aircraftDetailsMap = null;
        if (aircrafts != null && !aircrafts.isEmpty()) {
            List<Long> aircraftIds = aircrafts.stream()
                    .map(AircraftDTO::getAircraftId)
                    .collect(Collectors.toList());
            aircraftDetailsMap = bufferDeviceService.getAircraftDetailsByIds(aircraftIds);
        }

        // 统计各状态无人机数量
        int powerOnInCabinCount = 0;
        int powerOffInCabinCount = 0;
        int inMissionCount = 0;
        int debuggingAircraftCount = 0;
        int offlineAircraftCount = 0;

        if (aircrafts != null && aircraftDetailsMap != null) {
            log.info("---------- 开始统计无人机状态 ----------");
            for (AircraftDTO aircraft : aircrafts) {
                AircraftDetailDTO aircraftDetail = aircraftDetailsMap.get(aircraft.getAircraftId());
                if (aircraftDetail != null && aircraftDetail.getAircraftStatus() != null) {
                    String status = aircraftDetail.getAircraftStatus();
                    log.info("无人机[ID:{}, Name:{}] 状态: {}", aircraft.getAircraftId(), aircraft.getAircraftName(), status);
                    if (AircraftStatusEnum.POWER_ON_IN_CABIN.getCode().equalsIgnoreCase(status)) {
                        powerOnInCabinCount++;
                        log.debug("  -> 匹配到舱内开机状态");
                    } else if (AircraftStatusEnum.POWER_OFF_IN_CABIN.getCode().equalsIgnoreCase(status)) {
                        powerOffInCabinCount++;
                        log.debug("  -> 匹配到舱内关机状态");
                    } else if (AircraftStatusEnum.IN_MISSION.getCode().equalsIgnoreCase(status)) {
                        inMissionCount++;
                        log.info("  -> 匹配到IN_MISSION状态 (任务中)");
                    } else if (AircraftStatusEnum.DEBUGGING.getCode().equalsIgnoreCase(status)) {
                        debuggingAircraftCount++;
                        log.debug("  -> 匹配到调试状态");
                    } else if (AircraftStatusEnum.OFFLINE.getCode().equalsIgnoreCase(status)) {
                        offlineAircraftCount++;
                        log.debug("  -> 匹配到离线状态");
                    }   else {
                        offlineAircraftCount++;
                        log.debug("  -> 其他状态，归类为离线");
                    }
                }
            }
        }

        vo.setPowerOnInCabinCount(powerOnInCabinCount);
        vo.setPowerOffInCabinCount(powerOffInCabinCount);
        vo.setInMissionCount(inMissionCount);
        vo.setDebuggingAircraftCount(debuggingAircraftCount);
        vo.setOfflineAircraftCount(offlineAircraftCount);

        log.info("无人机状态统计结果 -> 舱内开机:{}, 舱内关机:{}, 任务中:{}, 调试:{}, 离线:{}",
                powerOnInCabinCount, powerOffInCabinCount, inMissionCount, debuggingAircraftCount, offlineAircraftCount);

        // 获取所有挂载
        List<PayloadDTO> payloads = payloadService.selectPayloadList(new PayloadDTO());
        vo.setPayloadCount(payloads != null ? payloads.size() : 0);

        // 统计离线挂载数量（暂时设置为0，因为挂载状态需要从实时数据获取）
        vo.setOfflinePayloadCount(0);

        log.info("========== DJI设备统计完成 ==========");
        log.info("最终统计结果: 机场总数={}, 任务中机场={}, 无人机总数={}, 任务中无人机={}",
                vo.getDockCount(), vo.getWorkingDockCount(), vo.getAircraftCount(), vo.getInMissionCount());

        return vo;
    }
}