radarBackend/src/main/java/com/example/backend/service/RadarStatusService.java

package com.example.backend.service;

import com.example.backend.dds.TestSubscriber;
import com.example.backend.dds.TestPublisher;
import com.example.backend.model.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.concurrent.*;

import jakarta.annotation.PostConstruct;

@Service
public class RadarStatusService {

    private static final Logger logger = LoggerFactory.getLogger(RadarStatusService.class);

    ExecutorService e = Executors.newSingleThreadExecutor();
    
    private final Map<String, RadarStatus> platformRadarMap = new ConcurrentHashMap<>();
    private final Map<String, List<RadarParam>> platformParamsMap = new ConcurrentHashMap<>();
    private final Map<String, Queue<RadarTarget>> platformTargetsMap = new ConcurrentHashMap<>();
    private final Map<String, MessageStatus> messageStatusMap = new ConcurrentHashMap<>();
    private final Map<String, List<Message>> messageList = new ConcurrentHashMap<>();
    private final Map<String, List<Message>> outmessageList = new ConcurrentHashMap<>();
    private final Map<String, List<ecmParams>> ecmParamsList = new ConcurrentHashMap<>();
    private final Map<String, ecmStatus> ecmStatusList = new ConcurrentHashMap<>();


    public final TestSubscriber subscriber = new TestSubscriber();


    public final TestPublisher publisher = new TestPublisher();

    
    // 设置队列最大容量
    private static final int MAX_QUEUE_SIZE = 100;

    public RadarStatusService() throws Exception {

    }

    @Async
    @Scheduled(fixedRate = 6000) // 每3秒执行一次
    public void checkInitStateTask() {
        if (subscriber != null && subscriber.listener != null) {
            try {//发送心跳信息
                publisher.publishMessage(
                        "5",
                        "8",
                        "这是心跳信息"
                );

            } catch (Exception e) {

            }
        synchronized (subscriber.listener) {
            // 读写操作
                // 根据你的具体业务逻辑判断状态
                if(subscriber.listener.isInit==0){
                    this.messageList.clear();
                    this.messageStatusMap.clear();
                    this.outmessageList.clear();
                    this.ecmParamsList.clear();
                }
                if (subscriber.listener.isInit==1&&subscriber.listener.isRecall==1) {
                    try {
                        subscriber.listener.isRecall=0;

                        publisher.publishMessage(
                                "5",
                                "11",
                                "这是初始化应答"
                        );

                    } catch (Exception e) {

                    }  // 回复初始化应答
                    subscriber.listener.isRecall=0;
                    init();
                }
                if(subscriber.listener.isInit==1){
                    checkTargets();
                }
                if(subscriber.listener.isInit==0){
                    //未初始化，发送初始化请求
                    try {
                        publisher.publishMessage(
                                "5",
                                "12",
                                "这是初始化请求"
                        );

                    } catch (Exception e) {

                    }  // 回复初始化应答
                }
                if(subscriber.listener.isTeam==0&&subscriber.listener.isInit==1){
                    //未分组，发送网络分组请求
                    try {
                        publisher.publishMessage(
                                "5",
                                "41",
                                "这是网络分组请求"
                        );

                    } catch (Exception e) {

                    }
                }
                if(subscriber.listener.isTeam==1&&subscriber.listener.isInit==1&&subscriber.listener.isCoopParamsInit==0){
                    //未初始化参数 发送请求
                    try {
                        publisher.publishMessage(
                                "5",
                                "101",
                                "这是分组参数初始化请求"
                        );

                    } catch (Exception e) {

                    }
                }
            }
        }
    }

    @PostConstruct
    public void init() {
        // 初始化默认平台的状态和参数
        for(String key : subscriber.listener.radarPositionMap.keySet()){
            initializePlatform(key);
        }

    }

    public Set<String> getPlatforms(){
        return subscriber.listener.radarPositionMap.keySet();
    }

    // 初始化平台数据
    private void initializePlatform(String platformId) {
        logger.info("初始化平台 {} 的数据", platformId);
        platformRadarMap.put(platformId, initDefaultPlatform(platformId));
        platformParamsMap.put(platformId, initDefaultParams());
        Queue<RadarTarget> queue = new ConcurrentLinkedQueue<>();
        platformTargetsMap.put(platformId, queue);
        MessageStatus m = new MessageStatus();
        messageStatusMap.put(platformId,m);
        ecmParamsList.put(platformId,new ArrayList<>());

        sdrStatus s = new sdrStatus();
        if(platformId.equals(subscriber.listener.realJamID)||platformId.equals(subscriber.listener.realRadarID)){
            s.platformStatus = "离线";
            s.serviceStatus = "无法提供";
            s.jamingPolicy = "无";
            s.investingPolicy = "无";
            subscriber.listener.sdrStatueMap.put(platformId,s);
        }
        else{
            s.platformStatus = "此设备并未采用半实物设备模拟";
            s.serviceStatus = "此设备并未采用半实物设备模拟";
            s.jamingPolicy = "此设备并未采用半实物设备模拟";
            s.investingPolicy = "此设备并未采用半实物设备模拟";
            subscriber.listener.sdrStatueMap.put(platformId,s);
        }
    }

    public List<Map<String, Object>> getRadarStatus(String platformId) {
        logger.info("获取平台 {} 的雷达状态", platformId);
        RadarStatus status = platformRadarMap.computeIfAbsent(platformId, this::initDefaultPlatform);
        return convertToKeyValueList(status);
    }

    public String getIsReal(String platformId) {
        logger.info("获取平台 {} 的是否半实物", platformId);
        Position p = subscriber.listener.positionMap.get(platformId);
        String s = p.isReal.equals("2") ? "是" : "否";
        return s;
    }

    public RadarStatus updateRadarStatus(String platformId, RadarStatus updatedStatus) {
        if (updatedStatus == null) {
            logger.error("尝试更新空的雷达状态");
            throw new IllegalArgumentException("雷达状态不能为空");
        }
        logger.info("更新平台 {} 的雷达状态", platformId);
        updatedStatus.setPlatformId(platformId);
        platformRadarMap.put(platformId, updatedStatus);
        try {
            publisher.publishMessage(
                    "RadarSystem",
                    "DetectionUpdate",
                    "XYH"
            );

        } catch (Exception e) {

        }
        return updatedStatus;
    }

    // 辅助方法，创建一个 key-value 对
    private Map<String, Object> createKeyValue(String key, Object value) {
        Map<String, Object> map = new HashMap<>();
        map.put("key", key);
        map.put("value", value);
        return map;
    }

    // 将雷达状态转换为前端需要的格式
    private List<Map<String, Object>> convertToKeyValueList(RadarStatus status) {
        List<Map<String, Object>> radarStatusList = new ArrayList<>();
        
        // 添加平台ID到返回数据中
        radarStatusList.add(createKeyValue("平台编号", status.getPlatformId()));
        
        // 只包含雷达状态数据
        radarStatusList.add(createKeyValue("型号", status.getModel()));
        radarStatusList.add(createKeyValue("序号", status.getSerialNumber()));
        radarStatusList.add(createKeyValue("类型", status.getType()));
        radarStatusList.add(createKeyValue("连接方式", status.getConnectionType()));
        radarStatusList.add(createKeyValue("开机时间", status.getStartupTime()));
        radarStatusList.add(createKeyValue("发现概率(%)", status.getDetectionProbability()));
        radarStatusList.add(createKeyValue("虚警率(%)", status.getFalseAlarmRate()));
        radarStatusList.add(createKeyValue("扫描周期(s)", status.getScanCycle()));
        radarStatusList.add(createKeyValue("波束指向方位角", status.getBeamAzimuth()));
        radarStatusList.add(createKeyValue("波束指向俯仰角", status.getBeamElevation()));
        radarStatusList.add(createKeyValue("天线最大增益(dB)", status.getAntennaGain()));
        radarStatusList.add(createKeyValue("副瓣增益(dB)", status.getSideLobeGain()));
        
        return radarStatusList;
    }

    private RadarStatus initDefaultPlatform(String platformId) {
        RadarStatus defaultStatus = new RadarStatus();
        defaultStatus.setPlatformId(platformId);
        defaultStatus.setModel("默认型号测试数据");
        defaultStatus.setSerialNumber("000000");
        defaultStatus.setType("默认类型");
        defaultStatus.setConnectionType("TCP");
        defaultStatus.setStartupTime("2024-01-01 00:00:00");
        defaultStatus.setDetectionProbability(90.0);
        defaultStatus.setFalseAlarmRate(0.1);
        defaultStatus.setScanCycle(10);
        defaultStatus.setBeamAzimuth(0);
        defaultStatus.setBeamElevation(0);
        defaultStatus.setAntennaGain(30.0);
        defaultStatus.setSideLobeGain(-20.0);
        return defaultStatus;
    }

    // 获取雷达参数
    public List<RadarParam> getRadarParams(String platformId) {
        logger.info("获取平台 {} 的雷达参数", platformId);
        return platformParamsMap.computeIfAbsent(platformId, k -> {
            logger.info("平台 {} 不存在，创建默认参数", platformId);
            return initDefaultParams();
        });
    }

    // 更新雷达参数
    public List<RadarParam> updateRadarParams(String platformId, List<RadarParam> radarParams) {
        if (radarParams == null || radarParams.isEmpty()) {
            logger.error("尝试更新空的雷达参数列表");
            throw new IllegalArgumentException("雷达参数不能为空");
        }

        logger.info("更新平台 {} 的雷达参数，参数数量: {}", platformId, radarParams.size());
        // 验证参数的合法性
        validateRadarParams(radarParams);
        // 存储参数
        platformParamsMap.put(platformId, new ArrayList<>(radarParams));
        try {
            publisher.publishMessage(
                    "RadarSystem",
                    "DetectionUpdate",
                    "XYH"
            );

        } catch (Exception e) {

        }
        System.out.println(subscriber.getText());
        return radarParams;
    }

    // 获取位置信息
    public Position getPositionById(String platformId) {
        for(String key : subscriber.listener.radarPositionMap.keySet()){
            if(key.equals(platformId)){
                return subscriber.listener.radarPositionMap.get(key);
            }
        }
        return null;
    }

    // 验证雷达参数的合法性
    private void validateRadarParams(List<RadarParam> params) {
        if (params.stream().anyMatch(p -> p.getKey() == null || p.getKey().trim().isEmpty())) {
            throw new IllegalArgumentException("参数键不能为空");
        }
        if (params.stream().anyMatch(p -> p.getValue() == null)) {
            throw new IllegalArgumentException("参数值不能为空");
        }
    }

    // 初始化默认参数
    private List<RadarParam> initDefaultParams() {
        List<RadarParam> defaultParams = new ArrayList<>();
        defaultParams.add(new RadarParam("开关机状态", "打开"));
        defaultParams.add(new RadarParam("抗干扰措施", "频率捷变"));
        defaultParams.add(new RadarParam("工作模式", "搜索"));
        defaultParams.add(new RadarParam("脉冲参数", "自动"));
        defaultParams.add(new RadarParam("方位扫描中心(°)", "0"));
        defaultParams.add(new RadarParam("俯仰扫描中心(°)", "0"));
        defaultParams.add(new RadarParam("波束宽度(°)", "2"));
        defaultParams.add(new RadarParam("方位扫描范围(°)", "10"));
        defaultParams.add(new RadarParam("俯仰扫描范围(°)", "10"));
        defaultParams.add(new RadarParam("发射机功率(W)", "100"));
        return defaultParams;
    }

    // 修改获取目标数据的方法
    public List<RadarTarget> getRadarTargets(String platformId) {
        logger.info("获取平台 {} 的目标数据", platformId);
        Queue<RadarTarget> queue = platformTargetsMap.computeIfAbsent(platformId, k -> {
            logger.info("平台 {} 不存在", platformId);
            Queue<RadarTarget> newQueue = new ConcurrentLinkedQueue<>();
            return newQueue;
        });
        return new ArrayList<>(queue);
    }

    // 修改更新目标数据的方法
    public List<RadarTarget> updateRadarTargets(String platformId, List<RadarTarget> targets) {
        if (targets == null || targets.isEmpty()) {
            logger.error("尝试更新空的目标数据列表");
            throw new IllegalArgumentException("目标数据不能为空");
        }

        logger.info("更新平台 {} 的目标数据，目标数量: {}", platformId, targets.size());
        validateRadarTargets(targets);

        Queue<RadarTarget> queue = platformTargetsMap.computeIfAbsent(
            platformId, 
            k -> new ConcurrentLinkedQueue<>()
        );

        // 添加新数据到队列
        for (RadarTarget target : targets) {
            queue.offer(target);
            // 如果队列超出最大容量，移除最旧的数据
            while (queue.size() > MAX_QUEUE_SIZE) {
                queue.poll();
            }
        }

        return new ArrayList<>(queue);
    }

    // 添加清除目标数据的方法
    public void clearRadarTargets(String platformId) {
        logger.info("清除平台 {} 的目标数据", platformId);
        Queue<RadarTarget> queue = platformTargetsMap.get(platformId);
        if (queue != null) {
            queue.clear();
        }
    }

    // 添加获取队列大小的方法
    public int getRadarTargetsCount(String platformId) {
        Queue<RadarTarget> queue = platformTargetsMap.get(platformId);
        return queue != null ? queue.size() : 0;
    }

    // 验证目标数据的合法性
    private void validateRadarTargets(List<RadarTarget> targets) {
        for (RadarTarget target : targets) {
            if (target.getTargetId() == null) {
                throw new IllegalArgumentException("目标ID不能为空");
            }
            if (target.getSimTime() == null || target.getSimTime().trim().isEmpty()) {
                throw new IllegalArgumentException("仿真时间不能为空");
            }
        }
    }

    //获取消息数据 链路状态相关方法
    public MessageStatus getMsgStatusById(String PlatformID){

        return subscriber.listener.messageStatusMap.get(PlatformID);
    }

    public void setMsgStatusById(String PlatformID,MessageStatus m){
        // messageStatusMap.put(PlatformID,m);
        subscriber.listener.messageStatusMap.put(PlatformID,m);
        publisher.publishMessage("5","9",PlatformID+" "+m.startUp+" "+m.quite+" "+m.mode);

    }

    public List<Message> getMsgListById(String PlatformID){
        return subscriber.listener.messageList.get(PlatformID);
    }

    public void setMsgListById(String PlatformID,Message m){
        List<Message> list = messageList.get(PlatformID);
        list.add(m);
        messageList.put(PlatformID,list);
    }

    public List<Message> getOutMsgListById(String PlatformID){
        return outmessageList.get(PlatformID);
    }

    public void setOutMsgListById(String PlatformID,Message m){
        List<Message> list = outmessageList.get(PlatformID);
        list.add(m);
        outmessageList.put(PlatformID,list);
    }
//---------------------------------

    //平台发送消息给平台方法
    public void sendMessageToOther(String platformID,Message msg,String other,String subject){
        publisher.publishMessage(platformID+" "+"3"+" "+other,subject,msg.getTime()+" "+msg.getTopic()+" "+msg.getText());
    }

    public void sendRadarPulseMsg(String platformID, radarPulseMsg msg,String recivier){
        publisher.publishMessage(platformID+" "+"3"+" "+recivier,"5",msg.getType()+" "+msg.getEnv()+" "+msg.getLon()+" "+msg.getLat()+" "+msg.getH()+" "+msg.getFreq()+" "+msg.getPRI());
        List<Message> list = outmessageList.get(platformID)==null ? new ArrayList<>() : outmessageList.get(platformID);
        LocalDateTime now = LocalDateTime.now();

        // 定义格式（例如：yyyy-MM-dd HH:mm:ss）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化时间
        String formattedDateTime = now.format(formatter);
        list.add(new Message(formattedDateTime,platformID,"雷达脉冲",msg.getType()+" "+msg.getEnv()+" "+msg.getLon()+" "+msg.getLat()+" "+msg.getH()+" "+msg.getFreq()+" "+msg.getPRI(),"1"));
        outmessageList.put(platformID,list);
    }

    public void sendDisturbMsg(String platformID, disturbMsg msg,String recivier){
        publisher.publishMessage(platformID+" "+"3"+" "+recivier,"6",msg.getJaming()+" "+msg.getEnv()+" "+msg.getArea()+" "+msg.getJamingPolicy()+" "+msg.getTarget()+" "+msg.getIsCoop()+" "+msg.getPRI());
        List<Message> list = outmessageList.get(platformID)==null ? new ArrayList<>() : outmessageList.get(platformID);
        LocalDateTime now = LocalDateTime.now();

        // 定义格式（例如：yyyy-MM-dd HH:mm:ss）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化时间
        String formattedDateTime = now.format(formatter);
        list.add(new Message(formattedDateTime,platformID,"电子干扰",msg.getJaming()+" "+msg.getEnv()+" "+msg.getArea()+" "+msg.getJamingPolicy()+" "+msg.getTarget()+" "+msg.getIsCoop()+" "+msg.getPRI(),"1"));
        outmessageList.put(platformID,list);
    }

    public void sendCompMsg(String platformID, compMsg msg,String recivier){
        publisher.publishMessage(platformID+" "+"3"+" "+recivier,"7",msg.getTopic()+" "+msg.getPriority()+" "+msg.getIsBroadcast()+" "+msg.getText());

        List<Message> list = outmessageList.get(platformID)==null ? new ArrayList<>() : outmessageList.get(platformID);
        LocalDateTime now = LocalDateTime.now();

        // 定义格式（例如：yyyy-MM-dd HH:mm:ss）
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 格式化时间
        String formattedDateTime = now.format(formatter);
        list.add(new Message(formattedDateTime,platformID,"综合情报",msg.getTopic()+" "+msg.getPriority()+" "+msg.getIsBroadcast()+" "+msg.getText(),"1"));
        outmessageList.put(platformID,list);
    }

    //电子攻击相关方法\
    public ecmStatus getECMStatusByID(String platformID){
        return ecmStatusList.get(platformID);
    }

    public List<ecmParams> getECMParamsByID(String platformID){
        return ecmParamsList.get(platformID);
    }

    public void setEcmParam(String platformID,ecmParams params){
       List<ecmParams> list = ecmParamsList.get(platformID);
       list.add(params);
       ecmParamsList.put(platformID,list);
    }

    public sdrStatus getSdrStatusByID(String platformID){
        return subscriber.listener.sdrStatueMap.get(platformID);
    }

    //编队成员方法
    public List<String> getTeamMemberByID(String platformID) {
        for(List<String> list : subscriber.listener.coopTeamMap.values()){
            if(list.contains(platformID)){
                return list;
            }
        }
        List<String> list = new ArrayList<>();
        return list;
    }

    // 初始化默认目标数据
    private List<RadarTarget> initDefaultTargets() {
        List<RadarTarget> defaultTargets = new ArrayList<>();
        defaultTargets.add(new RadarTarget("14:37.15", 1, "我方", "后端数据测试", "高", 10, -50, 859, 5.4));
        defaultTargets.add(new RadarTarget("14:33.40", 2, "未知", "后端数据测试", "低", 40, -70, 458, 10.1));
        defaultTargets.add(new RadarTarget("14:38.55", 3, "可疑目标", "后端数据测试", "中", 120, -54, 269, 15.3));
        defaultTargets.add(new RadarTarget("14:39.30", 4, "可疑目标", "后端数据测试", "中", 210, -60, 234, 22.5));
        return defaultTargets;
    }



    private List<Message> initDefaultMessage(String platformID) {
        List<Message> defaultMessage = new ArrayList<>();
        defaultMessage.add(new Message("2025-4-1 12:00","100","综合情报","这是测试消息内容","0"));
        defaultMessage.add(new Message("2025-4-1 12:00","100","综合情报","这是测试消息内容","1"));
        defaultMessage.add(new Message("2025-4-1 12:00","100","综合情报","这是测试消息内容","0"));
        return defaultMessage;
    }


    public String msgToNumber(String s){
        if(s.equals("雷达脉冲")){
            return "5";
        }
        else if(s.equals("电子干扰")){
            return "6";
        }
        else return "7";
    }
    //检查范围
    //原版
//    private void checkTargets(){
//        platformTargetsMap.clear();
//        for(String missile : subscriber.listener.positionMap.keySet()){
//            Queue<RadarTarget> queue = new ConcurrentLinkedQueue<>();
//            for(String radar : subscriber.listener.radarPositionMap.keySet()){
//                Position thisMissile = subscriber.listener.positionMap.get(missile);
//                Position thisRadar = subscriber.listener.radarPositionMap.get(radar);
//                if(Math.sqrt((thisMissile.x-thisRadar.x)*(thisMissile.x-thisRadar.x)+(thisMissile.y-thisRadar.y)*(thisMissile.y-thisRadar.y)+(thisMissile.z-thisRadar.z)*(thisMissile.z-thisRadar.z))<=1000000){
//                    //进入侦察范围
//                    RadarTarget target = new RadarTarget();
//                    double dx = thisMissile.x-thisRadar.x;
//                    double dy = thisMissile.y-thisRadar.y;
//                    double dz = thisMissile.z-thisRadar.z;
//                    double azi,elv;
//                    azi = dx==0&&dy==0 ? 0.0 : Math.toDegrees(Math.atan2(dx,dy));
//                    azi = azi<0 ? azi+360 : azi;
//                    elv = Math.toDegrees(Math.atan2(dz,Math.sqrt(dx*dx+dy*dy)));
//                    target.setTargetId(Integer.valueOf(radar));
//                    target.setEnemyPro("未知");
//                    target.setFlightState("未知");
//                    target.setLightQuality("未知");
//                    target.setSimTime("未知");
//                    target.setTargetDistance(Math.sqrt((thisMissile.x-thisRadar.x)*(thisMissile.x-thisRadar.x)+(thisMissile.y-thisRadar.y)*(thisMissile.y-thisRadar.y)+(thisMissile.z-thisRadar.z)*(thisMissile.z-thisRadar.z)));
//                    target.setTargetAzi(azi);
//                    target.setTargetEle(elv);
//                    target.setTargetRSpeed(0);
//                    queue.add(target);
//                }
//            }
//            platformTargetsMap.put(missile,queue);
//        }
//    }
    private void checkTargets(){
        platformTargetsMap.clear();
        //雷达循环
        for(String radar : subscriber.listener.radarPositionMap.keySet()){
            Queue<RadarTarget> queue = new ConcurrentLinkedQueue<>();
            //侦察循环
            for(String missile : subscriber.listener.positionMap.keySet()){
                //侦察
                Position thisMissile = subscriber.listener.positionMap.get(missile);
                //雷达
                Position thisRadar = subscriber.listener.radarPositionMap.get(radar);
                if(Math.sqrt((thisMissile.x-thisRadar.x)*(thisMissile.x-thisRadar.x)+(thisMissile.y-thisRadar.y)*(thisMissile.y-thisRadar.y)+(thisMissile.z-thisRadar.z)*(thisMissile.z-thisRadar.z))<=1000000){
                    //进入侦察范围
                    RadarTarget target = new RadarTarget();
                    double dx = thisMissile.x-thisRadar.x;
                    double dy = thisMissile.y-thisRadar.y;
                    double dz = thisMissile.z-thisRadar.z;
                    double azi,elv;
                    azi = dx==0&&dy==0 ? 0.0 : Math.toDegrees(Math.atan2(dx,dy));
                    azi = azi<0 ? azi+360 : azi;
                    elv = Math.toDegrees(Math.atan2(dz,Math.sqrt(dx*dx+dy*dy)));
                    target.setTargetId(Integer.valueOf(radar));
                    target.setEnemyPro("未知");
                    target.setFlightState("未知");
                    target.setLightQuality("未知");
                    target.setSimTime("未知");
                    target.setTargetDistance(Math.sqrt((thisMissile.x-thisRadar.x)*(thisMissile.x-thisRadar.x)+(thisMissile.y-thisRadar.y)*(thisMissile.y-thisRadar.y)+(thisMissile.z-thisRadar.z)*(thisMissile.z-thisRadar.z)));
                    target.setTargetAzi(azi);
                    target.setTargetEle(elv);
                    target.setTargetRSpeed(0);
                    queue.add(target);
                }
            }
            platformTargetsMap.put(radar,queue);
        }
    }
}