package com.ruoyi.alarm.global.service.impl;

import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.alarm.access.domain.ArdAlarmAccess;
import com.ruoyi.alarm.access.mapper.ArdAlarmAccessMapper;
import com.ruoyi.alarm.apponekey.domain.ArdAlarmApponekey;
import com.ruoyi.alarm.apponekey.mapper.ArdAlarmApponekeyMapper;
import com.ruoyi.alarm.camera.domain.ArdAlarmCamera;
import com.ruoyi.alarm.camera.mapper.ArdAlarmCameraMapper;
import com.ruoyi.alarm.external.domain.ArdAlarmExternal;
import com.ruoyi.alarm.external.mapper.ArdAlarmExternalMapper;
import com.ruoyi.alarm.global.domain.GlobalAlarmCondition;
import com.ruoyi.alarm.global.domain.GlobalAlarmData;
import com.ruoyi.alarm.global.domain.GuidePriorityQueue;
import com.ruoyi.alarm.global.domain.GuideTask;
import com.ruoyi.alarm.global.service.IGlobalAlarmService;
import com.ruoyi.alarm.radar.domain.*;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarFireMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarMoveMapper;
import com.ruoyi.alarm.radar.mapper.ArdAlarmRadarPumpMapper;
import com.ruoyi.alarm.steal.domain.ArdAlarmStealelec;
import com.ruoyi.alarm.steal.mapper.ArdAlarmStealelecMapper;
import com.ruoyi.alarm.tube.domain.ArdAlarmTube;
import com.ruoyi.alarm.tube.mapper.ArdAlarmTubeMapper;
import com.ruoyi.alarm.wall.domain.ArdAlarmWall;
import com.ruoyi.alarm.wall.mapper.ArdAlarmWallMapper;
import com.ruoyi.alarmpoints.tube.domain.ArdTubes;
import com.ruoyi.alarmpoints.tube.domain.ArdTubesDetails;
import com.ruoyi.alarmpoints.tube.mapper.ArdTubesDetailsMapper;
import com.ruoyi.alarmpoints.tube.mapper.ArdTubesMapper;
import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
import com.ruoyi.alarmpoints.well.mapper.ArdAlarmpointsWellMapper;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.DictUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.device.external.domain.ArdEquipExternal;
import com.ruoyi.device.external.mapper.ArdEquipExternalMapper;
import com.ruoyi.device.radar.mapper.ArdEquipRadarMapper;
import com.ruoyi.utils.gis.GisUtil;
import com.ruoyi.utils.tools.ArdTool;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
import com.ruoyi.system.service.ISysConfigService;
import com.ruoyi.utils.tube.GeoPoint;
import com.ruoyi.utils.tube.TubeTools;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;


/**
 * @Description: 全局报警业务
 * @ClassName: globalAlarmServiceImpl
 * @Author: Administrator
 * @Date: 2023年03月10日 11:03
 * @Version: 1.0
 **/
@Service
@Slf4j(topic = "mqtt")
public class GlobalAlarmServiceImpl implements IGlobalAlarmService {
    //region 依赖注入
    @Resource
    private ArdAlarmWallMapper ardAlarmWallMapper;
    @Resource
    private ArdAlarmApponekeyMapper ardAlarmApponekeyMapper;
    @Resource
    private ArdEquipExternalMapper ardEquipExternalMapper;
    @Resource
    private ArdAlarmAccessMapper ardAlarmAccessMapper;
    @Resource
    private ArdAlarmExternalMapper ardAlarmExternalMapper;
    //@Resource
    //private ArdAlarmRadarMapper ardAlarmRadarMapper;
    @Resource
    private ArdAlarmRadarMoveMapper ardAlarmRadarMoveMapper;
    @Resource
    private ArdAlarmRadarFireMapper ardAlarmRadarFireMapper;
    @Resource
    private ArdAlarmRadarPumpMapper ardAlarmRadarPumpMapper;
    @Resource
    private ArdAlarmStealelecMapper ardAlarmStealelecMapper;
    @Resource
    private ArdAlarmTubeMapper ardAlarmTubeMapper;
    @Resource
    private ArdAlarmCameraMapper ardAlarmCameraMapper;
    @Resource
    private ArdTubesMapper ardTubesMapper;
    @Resource
    private ArdAlarmpointsWellMapper ardAlarmpointsWellMapper;
    @Resource
    private ArdTubesDetailsMapper ardTubesDetailsMapper;
    @Resource
    private ISysConfigService configService;
    @Resource
    private ArdCamerasMapper ardCamerasMapper;
    @Resource
    private RedisCache redisCache;
    @Resource
    private QueueManager queueManager;
    @Resource
    private ArdEquipRadarMapper ardEquipRadarMapper;
    //endregion
    //每个点位未引导次数
    private Map<String, Integer> unGuideCountMapMove = new HashMap<>();
    private Map<String, Integer> unGuideCountMapFire = new HashMap<>();
    private Map<String, Integer> unGuideCountMapPump = new HashMap<>();
    /**
     * @描述 查询所有报警的当前数量
     * @参数 []
     * @返回值 java.util.Map<java.lang.String, java.lang.Integer>
     * @创建人 刘苏义
     * @创建时间 2023/6/13 16:30
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> selectAlarmLogsCount() {
        Map<String, Object> map = new HashMap<>();
        Map<String, Integer> countMap = new HashMap<>();
        String refreshTime = configService.selectConfigByKey("refreshTime");
        int count1001 = ardAlarmStealelecMapper.selectCountByStartTime(refreshTime);
        countMap.put("1001", count1001);
        int count1002 = ardAlarmCameraMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1002", count1002);
        int count1003 = ardAlarmRadarMoveMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1003", count1003);
        int count1004 = ardAlarmRadarFireMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1004", count1004);
        int count1007 = ardAlarmRadarPumpMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1007", count1007);
        int count1005 = ardAlarmExternalMapper.selectCountByAlarmTime(refreshTime, "防区报警");
        countMap.put("1005", count1005);
        int count1006 = ardAlarmAccessMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1006", count1006);
        int count1009 = ardAlarmApponekeyMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1009", count1009);
        int count1010 = ardAlarmWallMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1010", count1010);
        int count1014 = ardAlarmTubeMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1014", count1014);
        map.put("20000", countMap);
        return map;
    }

    /**
     * @描述 按条件查询报警
     * @参数 [condition]
     * @返回值 java.util.List<com.ruoyi.alarm.globalAlarm.domain.GlobalAlarmData>
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:48
     * @修改人和其它信息
     */
    @Override
    public List<GlobalAlarmData> selectAlarmLogs(GlobalAlarmCondition condition) {
        String refreshTime = configService.selectConfigByKey("refreshTime");
        switch (condition.getCommand()) {
            case 1001:
                List<ArdAlarmStealelec> ardAlarmStealelecs = ardAlarmStealelecMapper.selectListAllByCommand(refreshTime);
                return ardAlarmStealelecs.stream()
                        .map(ardAlarmStealelec -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmStealelec.getId())
                                    .setName(ardAlarmStealelec.getDescribe())
                                    .setAlarmTime(ardAlarmStealelec.getStartTime())
                                    .setLongitude(ardAlarmStealelec.getLongitude())
                                    .setLatitude(ardAlarmStealelec.getLatitude())
                                    .setAltitude(ardAlarmStealelec.getAltitude())
                                    .setCount(ardAlarmStealelec.getCount())
                                    .setTotal(ardAlarmStealelec.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1002:
                List<ArdAlarmCamera> ardAlarmCameras = ardAlarmCameraMapper.selectListAllByCommand(refreshTime);
                return ardAlarmCameras.stream()
                        .map(ardAlarmCamera -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmCamera.getId())
                                    .setName(ardAlarmCamera.getCameraName())
                                    .setAlarmTime(ardAlarmCamera.getAlarmTime())
                                    .setLongitude(ardAlarmCamera.getLongitude())
                                    .setLatitude(ardAlarmCamera.getLatitude())
                                    .setCount(ardAlarmCamera.getCount())
                                    .setTotal(ardAlarmCamera.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1003:
                List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
                return ardAlarmRadarMoves.stream()
                        .map(ardAlarmRadarMove -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmRadarMove.getId())
                                    .setName(ardAlarmRadarMove.getName())
                                    .setAlarmTime(ardAlarmRadarMove.getAlarmTime())
                                    .setLongitude(ardAlarmRadarMove.getLongitude())
                                    .setLatitude(ardAlarmRadarMove.getLatitude())
                                    .setCount(ardAlarmRadarMove.getCount())
                                    .setTotal(ardAlarmRadarMove.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1004:
                List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
                return ardAlarmRadarFires.stream()
                        .map(ardAlarmRadarFire -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmRadarFire.getId())
                                    .setName(ardAlarmRadarFire.getName())
                                    .setAlarmTime(ardAlarmRadarFire.getAlarmTime())
                                    .setLongitude(ardAlarmRadarFire.getLongitude())
                                    .setLatitude(ardAlarmRadarFire.getLatitude())
                                    .setCount(ardAlarmRadarFire.getCount())
                                    .setTotal(ardAlarmRadarFire.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1005:
                List<ArdAlarmExternal> ardAlarmExternals = ardAlarmExternalMapper.selectListAllByCommand(refreshTime, "防区报警");
                return ardAlarmExternals.stream()
                        .map(ardAlarmExternal -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmExternal.getId())
                                    .setName(ardAlarmExternal.getAlarmName())
                                    .setAlarmTime(ardAlarmExternal.getAlarmTime())
                                    .setLongitude(ardAlarmExternal.getLongitude())
                                    .setLatitude(ardAlarmExternal.getLatitude())
                                    .setCount(ardAlarmExternal.getCount())
                                    .setTotal(ardAlarmExternal.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1006:
                List<ArdAlarmAccess> ardAlarmAccesses = ardAlarmAccessMapper.selectListAllByCommand(refreshTime);
                return ardAlarmAccesses.stream()
                        .map(ardAlarmAccess -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmAccess.getId())
                                    .setName(ardAlarmAccess.getAcsName())
                                    .setAlarmTime(ardAlarmAccess.getAlarmTime())
                                    .setLongitude(ardAlarmAccess.getLongitude())
                                    .setLatitude(ardAlarmAccess.getLatitude())
                                    .setCount(ardAlarmAccess.getCount())
                                    .setTotal(ardAlarmAccess.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1007:
                List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
                return ardAlarmRadarPumps.stream()
                        .map(ardAlarmRadarPump -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmRadarPump.getId())
                                    .setName(ardAlarmRadarPump.getName())
                                    .setAlarmTime(ardAlarmRadarPump.getAlarmTime())
                                    .setLongitude(ardAlarmRadarPump.getLongitude())
                                    .setLatitude(ardAlarmRadarPump.getLatitude())
                                    .setCount(ardAlarmRadarPump.getCount())
                                    .setTotal(ardAlarmRadarPump.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1009:
                List<ArdAlarmApponekey> ardAlarmApponekeys = ardAlarmApponekeyMapper.selectListAllByCommand(refreshTime);
                return ardAlarmApponekeys.stream()
                        .map(ardAlarmApponekey -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmApponekey.getId())
                                    .setName(ardAlarmApponekey.getName())
                                    .setAlarmTime(ardAlarmApponekey.getCreateTime())
                                    .setLongitude(ardAlarmApponekey.getLongitude())
                                    .setLatitude(ardAlarmApponekey.getLatitude())
                                    .setCount(ardAlarmApponekey.getCount())
                                    .setTotal(ardAlarmApponekey.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1010:
                List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
                return ardAlarmWalls.stream()
                        .map(ardAlarmWall -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmWall.getId())
                                    .setName(ardAlarmWall.getWallName())
                                    .setAlarmTime(ardAlarmWall.getAlarmTime())
                                    .setLongitude(ardAlarmWall.getLongitude())
                                    .setLatitude(ardAlarmWall.getLatitude())
                                    .setCount(ardAlarmWall.getCount())
                                    .setTotal(ardAlarmWall.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            case 1014:
                List<ArdAlarmTube> ardAlarmTubes = ardAlarmTubeMapper.selectListAllByCommand(refreshTime);
                return ardAlarmTubes.stream()
                        .map(ardAlarmTube -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                                    .setId(ardAlarmTube.getId())
                                    .setName(ardAlarmTube.getTubeName())
                                    .setAlarmTime(ardAlarmTube.getAlarmTime())
                                    .setLongitude(ardAlarmTube.getLongitude())
                                    .setLatitude(ardAlarmTube.getLatitude())
                                    .setAltitude(ardAlarmTube.getAltitude())
                                    .setCount(ardAlarmTube.getCount())
                                    .setTotal(ardAlarmTube.getTotal());
                            return globalAlarmData;
                        }).collect(Collectors.toList());
            default:
                return null;
        }
    }

    @Override
    public List<GlobalAlarmData> selectAlarmLogsAll() {
        List<GlobalAlarmData> GlobalAlarmDataList = new ArrayList<>();
        String refreshTime = configService.selectConfigByKey("refreshTime");
        List<ArdAlarmStealelec> ardAlarmStealelecs = ardAlarmStealelecMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1001 = ardAlarmStealelecs.stream()
                .map(ardAlarmStealelec -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmStealelec.getId())
                            .setName(ardAlarmStealelec.getDescribe())
                            .setAlarmTime(ardAlarmStealelec.getStartTime())
                            .setLongitude(ardAlarmStealelec.getLongitude())
                            .setLatitude(ardAlarmStealelec.getLatitude())
                            .setAltitude(ardAlarmStealelec.getAltitude())
                            .setCount(ardAlarmStealelec.getCount())
                            .setTotal(ardAlarmStealelec.getTotal())
                            .setAlarmType("1001");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1001.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1001);
        }

        List<ArdAlarmCamera> ardAlarmCameras = ardAlarmCameraMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1002= ardAlarmCameras.stream()
                .map(ardAlarmCamera -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmCamera.getId())
                            .setName(ardAlarmCamera.getCameraName())
                            .setAlarmTime(ardAlarmCamera.getAlarmTime())
                            .setLongitude(ardAlarmCamera.getLongitude())
                            .setLatitude(ardAlarmCamera.getLatitude())
                            .setCount(ardAlarmCamera.getCount())
                            .setTotal(ardAlarmCamera.getTotal())
                            .setAlarmType("1002");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1002.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1002);
        }

        List<ArdAlarmRadarMove> ardAlarmRadarMoves = ardAlarmRadarMoveMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1003= ardAlarmRadarMoves.stream()
                .map(ardAlarmRadarMove -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarMove.getId())
                            .setName(ardAlarmRadarMove.getName())
                            .setAlarmTime(ardAlarmRadarMove.getAlarmTime())
                            .setLongitude(ardAlarmRadarMove.getLongitude())
                            .setLatitude(ardAlarmRadarMove.getLatitude())
                            .setCount(ardAlarmRadarMove.getCount())
                            .setTotal(ardAlarmRadarMove.getTotal())
                            .setAlarmType("1003");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1003.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1003);
        }

        List<ArdAlarmRadarFire> ardAlarmRadarFires = ardAlarmRadarFireMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1004=  ardAlarmRadarFires.stream()
                .map(ardAlarmRadarFire -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarFire.getId())
                            .setName(ardAlarmRadarFire.getName())
                            .setAlarmTime(ardAlarmRadarFire.getAlarmTime())
                            .setLongitude(ardAlarmRadarFire.getLongitude())
                            .setLatitude(ardAlarmRadarFire.getLatitude())
                            .setCount(ardAlarmRadarFire.getCount())
                            .setTotal(ardAlarmRadarFire.getTotal())
                            .setAlarmType("1004");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1004.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1004);
        }

        List<ArdAlarmExternal> ardAlarmExternals = ardAlarmExternalMapper.selectListAllByCommand(refreshTime, "防区报警");
        List<GlobalAlarmData> alarmData1005=  ardAlarmExternals.stream()
                .map(ardAlarmExternal -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmExternal.getId())
                            .setName(ardAlarmExternal.getAlarmName())
                            .setAlarmTime(ardAlarmExternal.getAlarmTime())
                            .setLongitude(ardAlarmExternal.getLongitude())
                            .setLatitude(ardAlarmExternal.getLatitude())
                            .setCount(ardAlarmExternal.getCount())
                            .setTotal(ardAlarmExternal.getTotal())
                            .setAlarmType("1005");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1005.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1005);
        }

        List<ArdAlarmAccess> ardAlarmAccesses = ardAlarmAccessMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1006= ardAlarmAccesses.stream()
                .map(ardAlarmAccess -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmAccess.getId())
                            .setName(ardAlarmAccess.getAcsName())
                            .setAlarmTime(ardAlarmAccess.getAlarmTime())
                            .setLongitude(ardAlarmAccess.getLongitude())
                            .setLatitude(ardAlarmAccess.getLatitude())
                            .setCount(ardAlarmAccess.getCount())
                            .setTotal(ardAlarmAccess.getTotal())
                            .setAlarmType("1006");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1006.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1006);
        }

        List<ArdAlarmRadarPump> ardAlarmRadarPumps = ardAlarmRadarPumpMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1007= ardAlarmRadarPumps.stream()
                .map(ardAlarmRadarPump -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmRadarPump.getId())
                            .setName(ardAlarmRadarPump.getName())
                            .setAlarmTime(ardAlarmRadarPump.getAlarmTime())
                            .setLongitude(ardAlarmRadarPump.getLongitude())
                            .setLatitude(ardAlarmRadarPump.getLatitude())
                            .setCount(ardAlarmRadarPump.getCount())
                            .setTotal(ardAlarmRadarPump.getTotal())
                            .setAlarmType("1007");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1007.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1007);
        }

        List<ArdAlarmApponekey> ardAlarmApponekeys = ardAlarmApponekeyMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1009= ardAlarmApponekeys.stream()
                .map(ardAlarmApponekey -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmApponekey.getId())
                            .setName(ardAlarmApponekey.getName())
                            .setAlarmTime(ardAlarmApponekey.getCreateTime())
                            .setLongitude(ardAlarmApponekey.getLongitude())
                            .setLatitude(ardAlarmApponekey.getLatitude())
                            .setCount(ardAlarmApponekey.getCount())
                            .setTotal(ardAlarmApponekey.getTotal())
                            .setAlarmType("1009");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1009.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1009);
        }

        List<ArdAlarmWall> ardAlarmWalls = ardAlarmWallMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1010= ardAlarmWalls.stream()
                .map(ardAlarmWall -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmWall.getId())
                            .setName(ardAlarmWall.getWallName())
                            .setAlarmTime(ardAlarmWall.getCreateTime())
                            .setLongitude(ardAlarmWall.getLongitude())
                            .setLatitude(ardAlarmWall.getLatitude())
                            .setCount(ardAlarmWall.getCount())
                            .setTotal(ardAlarmWall.getTotal())
                            .setAlarmType("1010");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1010.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1010);
        }

        List<ArdAlarmTube> ardAlarmTubes = ardAlarmTubeMapper.selectListAllByCommand(refreshTime);
        List<GlobalAlarmData> alarmData1014= ardAlarmTubes.stream()
                .map(ardAlarmTube -> {
                    GlobalAlarmData globalAlarmData = new GlobalAlarmData()
                            .setId(ardAlarmTube.getId())
                            .setName(ardAlarmTube.getTubeName())
                            .setAlarmTime(ardAlarmTube.getAlarmTime())
                            .setLongitude(ardAlarmTube.getLongitude())
                            .setLatitude(ardAlarmTube.getLatitude())
                            .setAltitude(ardAlarmTube.getAltitude())
                            .setCount(ardAlarmTube.getCount())
                            .setTotal(ardAlarmTube.getTotal())
                            .setAlarmType("1014");
                    return globalAlarmData;
                }).collect(Collectors.toList());
        if(alarmData1014.size()>0) {
            GlobalAlarmDataList.addAll(alarmData1014);
        }
        return GlobalAlarmDataList;
}

    /**
     * @描述 历史报警查询
     * @参数 [command, beginTime, endTime, pageNum, pageSize]
     * @返回值 java.lang.Object
     * @创建人 刘苏义
     * @创建时间 2023/6/28 13:30
     * @修改人和其它信息
     */
    @Override
    public Object selectAlarmList(Integer command, String beginTime, String endTime, Integer pageNum, Integer pageSize) {
        Map<String, Object> params = new HashMap<>();
        params.put("beginTime", beginTime);
        params.put("endTime", endTime);
        switch (command) {
            case 1001:
                ArdAlarmStealelec aas = new ArdAlarmStealelec();
                aas.setParams(params);
                aas.setPageNum(pageNum);
                aas.setPageSize(pageSize);
                return ardAlarmStealelecMapper.selectArdAlarmStealelecList(aas);
            case 1002:
                ArdAlarmCamera aac = new ArdAlarmCamera();
                aac.setParams(params);
                aac.setPageNum(pageNum);
                aac.setPageSize(pageSize);
                return ardAlarmCameraMapper.selectArdAlarmCameraList(aac);
            case 1003:
                ArdAlarmRadarMove aarm = new ArdAlarmRadarMove();
                aarm.setParams(params);
                aarm.setPageNum(pageNum);
                aarm.setPageSize(pageSize);
                aarm.setAlarmType("运动目标检测");
                return ardAlarmRadarMoveMapper.selectArdAlarmRadarMoveList(aarm);
            case 1004:
                ArdAlarmRadarFire aarf = new ArdAlarmRadarFire();
                aarf.setParams(params);
                aarf.setPageNum(pageNum);
                aarf.setPageSize(pageSize);
                aarf.setAlarmType("热源检测");
                return ardAlarmRadarFireMapper.selectArdAlarmRadarFireList(aarf);
            case 1007:
                ArdAlarmRadarPump aarp = new ArdAlarmRadarPump();
                aarp.setParams(params);
                aarp.setPageNum(pageNum);
                aarp.setPageSize(pageSize);
                aarp.setAlarmType("雷达抽油机停机");
                return ardAlarmRadarPumpMapper.selectArdAlarmRadarPumpList(aarp);
            case 1005:
                ArdAlarmExternal aae = new ArdAlarmExternal();
                aae.setParams(params);
                aae.setPageNum(pageNum);
                aae.setPageSize(pageSize);
                aae.setAlarmType("防区报警");
                return ardAlarmExternalMapper.selectArdAlarmExternalList(aae);
            case 1006:
                ArdAlarmAccess aaa = new ArdAlarmAccess();
                aaa.setParams(params);
                aaa.setPageNum(pageNum);
                aaa.setPageSize(pageSize);
                aaa.setAlarmType("防区报警");
                return ardAlarmAccessMapper.selectArdAlarmAccessList(aaa);
            case 1009:
                ArdAlarmApponekey aaak = new ArdAlarmApponekey();
                aaak.setParams(params);
                aaak.setPageNum(pageNum);
                aaak.setPageSize(pageSize);
                return ardAlarmApponekeyMapper.selectArdAlarmApponekeyList(aaak);
            case 1010:
                ArdAlarmWall aaw = new ArdAlarmWall();
                aaw.setParams(params);
                aaw.setPageNum(pageNum);
                aaw.setPageSize(pageSize);
                return ardAlarmWallMapper.selectArdAlarmWallList(aaw);
            case 1014:
                ArdAlarmTube aat = new ArdAlarmTube();
                aat.setParams(params);
                aat.setPageNum(pageNum);
                aat.setPageSize(pageSize);
                return ardAlarmTubeMapper.selectArdAlarmTubeList(aat);
        }
        return null;
    }

    /**
     * @描述 按条件更新查看时间
     * @参数 [condition]
     * @返回值 java.lang.Object
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:48
     * @修改人和其它信息
     */
    @Override
    public Object updateAlarmViewTime(GlobalAlarmCondition condition) {
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat fmtms = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
        switch (condition.getCommand()) {
            case 1001:
                ArdAlarmStealelec ardAlarmStealelec = ardAlarmStealelecMapper.selectByPrimaryKey(condition.getId());
                if (StringUtils.isNotNull(ardAlarmStealelec)) {
                    String describe = ardAlarmStealelec.getDescribe();
                    String startTime = fmt.format(ardAlarmStealelec.getStartTime());
                    ardAlarmStealelecMapper.updateViewTimeByDescribe(describe, startTime, DateUtils.getTime());
                    return ardAlarmStealelec;
                }
            case 1002:
                ArdAlarmCamera ardAlarmCamera = ardAlarmCameraMapper.selectArdAlarmCameraById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmCamera)) {
                    String cameraName = ardAlarmCamera.getCameraName();
                    String alarmTime = fmt.format(ardAlarmCamera.getAlarmTime());
                    ardAlarmCameraMapper.updateViewTimeByCameraName(cameraName, alarmTime, DateUtils.getTime());
                    return ardAlarmCamera;
                }
            case 1003:
                ArdAlarmRadarMove ardAlarmRadarMove = ardAlarmRadarMoveMapper.selectArdAlarmRadarMoveById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmRadarMove)) {
                    String name = ardAlarmRadarMove.getName();
                    String alarmTime = fmt.format(ardAlarmRadarMove.getAlarmTime());
                    ardAlarmRadarMoveMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
                    return ardAlarmRadarMove;
                }
            case 1004:
                ArdAlarmRadarFire ardAlarmRadarFire = ardAlarmRadarFireMapper.selectArdAlarmRadarFireById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmRadarFire)) {
                    String name = ardAlarmRadarFire.getName();
                    String alarmTime = fmt.format(ardAlarmRadarFire.getAlarmTime());
                    ardAlarmRadarFireMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
                    return ardAlarmRadarFire;
                }
            case 1007:
                ArdAlarmRadarPump ardAlarmRadarPump = ardAlarmRadarPumpMapper.selectArdAlarmRadarPumpById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmRadarPump)) {
                    String name = ardAlarmRadarPump.getName();
                    String alarmTime = fmt.format(ardAlarmRadarPump.getAlarmTime());
                    ardAlarmRadarPumpMapper.updateViewTimeByCondition(name, alarmTime, DateUtils.getTime());
                    return ardAlarmRadarPump;
                }
            case 1005:
                ArdAlarmExternal ardAlarmExternal = ardAlarmExternalMapper.selectArdAlarmExternalById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmExternal)) {
                    String defenseName = ardAlarmExternal.getDefenseName();
                    String alarmType = ardAlarmExternal.getAlarmType();
                    String alarmTime = fmt.format(ardAlarmExternal.getAlarmTime());
                    ardAlarmExternalMapper.updateViewTimeByCondition(defenseName, alarmType, alarmTime, DateUtils.getTime());
                    return ardAlarmExternal;
                }
            case 1006:
                ArdAlarmAccess ardAlarmAccess = ardAlarmAccessMapper.selectArdAlarmAccessById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmAccess)) {
                    String acsId = ardAlarmAccess.getAcsId();
                    String alarmTime = fmt.format(ardAlarmAccess.getAlarmTime());
                    ardAlarmAccessMapper.updateViewTimeByAcsId(acsId, alarmTime, DateUtils.getTime());
                    return ardAlarmAccess;
                }
            case 1009:
                ArdAlarmApponekey ardAlarmApponekey = ardAlarmApponekeyMapper.selectArdAlarmApponekeyById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmApponekey)) {
                    String userId = ardAlarmApponekey.getUserId();
                    String alarmTime = fmt.format(ardAlarmApponekey.getCreateTime());
                    ardAlarmApponekeyMapper.updateViewTimeByUserId(userId, alarmTime, DateUtils.getTime());
                    return ardAlarmApponekey;
                }
            case 1010:
                ArdAlarmWall ardAlarmWall = ardAlarmWallMapper.selectArdAlarmWallById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmWall)) {
                    String userId = ardAlarmWall.getUserId();
                    String alarmTime = fmtms.format(ardAlarmWall.getAlarmTime());
                    ardAlarmWallMapper.updateViewTimeByUserId(userId, alarmTime, DateUtils.getTime());
                    return ardAlarmWall;
                }
            case 1014:
                ArdAlarmTube ardAlarmTube = ardAlarmTubeMapper.selectArdAlarmTubeById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmTube)) {
                    String tubeId = ardAlarmTube.getTubeId();
                    String alarmTime = fmt.format(ardAlarmTube.getAlarmTime());
                    ardAlarmTubeMapper.updateViewTimeByTubeId(tubeId, alarmTime, DateUtils.getTime());
                    return ardAlarmTube;
                }
            default:
                return null;
        }
    }

    /**
     * @描述 异步处理接收的报警
     * @参数 [topic, message]
     * @返回值 void
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:46
     * @修改人和其它信息
     */
    @Override
    @Async("alarmExecutor")
    public void receiveAlarm(String topic, String message) {
        try {
            switch (topic) {
                case "stealelec":
                    //region 处理盗电报警
                    ArdAlarmStealelec ardAlarmStealelec = JSONObject.parseObject(message, ArdAlarmStealelec.class);
                    ArdAlarmStealelec isExiste = ardAlarmStealelecMapper.selectByPrimaryKey(ardAlarmStealelec.getId());
                    if (StringUtils.isNull(isExiste)) {
                        int aas = ardAlarmStealelecMapper.insertArdAlarmStealelec(ardAlarmStealelec);
                        if (aas > 0) {
                            log.info("stealelec入库成功：" + ardAlarmStealelec);
                        }
                    }
                    //endregion
                    break;
                case "tube":
                    //region 处理管线泄露报警
                    ArdAlarmTube ardAlarmTube = JSONObject.parseObject(message, ArdAlarmTube.class);
                    ardAlarmTube.setId(IdUtils.simpleUUID());
                    ArdTubesDetails atd = new ArdTubesDetails();
                    atd.setReelNumber(ardAlarmTube.getTubeId());
                    List<ArdTubesDetails> ardTubesDetails = ardTubesDetailsMapper.selectArdTubesDetailsList(atd);
                    if (ardTubesDetails.size() > 0) {
                        String tubeId = ardTubesDetails.get(0).getTubeId();
                        ArdTubes ardTubes = ardTubesMapper.selectArdTubesById(tubeId);
                        ardAlarmTube.setTubeName(ardTubes.getName());
                        ardAlarmTube.setColor(ardTubes.getColor());
                        ardAlarmTube.setPipeDiameter(ardTubes.getPipeDiameter());
                        ardAlarmTube.setTubeType(ardTubes.getType());
                        ardAlarmTube.setCreateTime(new Date());
                        GeoPoint geoPoint = TubeTools.CalculateCoordinates(ardTubesDetails, ardAlarmTube.getPosition());
                        if (StringUtils.isNotNull(geoPoint)) {
                            ardAlarmTube.setLongitude(geoPoint.getLongitude());
                            ardAlarmTube.setLatitude(geoPoint.getLatitude());
                            ardAlarmTube.setAltitude(geoPoint.getAltitude());
                        }
                    }
                    int aat = ardAlarmTubeMapper.insertArdAlarmTube(ardAlarmTube);
                    if (aat > 0) {
                        log.debug("tube入库成功：" + ardAlarmTube);
                        //region 引导录像
                        Double longitude = ardAlarmTube.getLongitude();
                        Double latitude = ardAlarmTube.getLatitude();
                        if (StringUtils.isNull(longitude) || StringUtils.isNull(latitude)) {
                            return;
                        }
                        double[] coordinate = new double[]{longitude, latitude};
                        String nearbyCameraId = getNearbyCamera(new double[]{ardAlarmTube.getLongitude(), ardAlarmTube.getLatitude()});
                        if (StringUtils.isNotEmpty(nearbyCameraId)) {
                            messagesEnqueued(nearbyCameraId, ardAlarmTube.getId(), "sys_tube_leak", ardAlarmTube.getCreateTime(), 1, 1, coordinate);
                        }
                        //endregion
                    }
                    //endregion
                    break;
                case "camera":
                    //region 处理通用光电报警
                    ArdAlarmCamera ardAlarmCamera = JSONObject.parseObject(message, ArdAlarmCamera.class);
                    ardAlarmCamera.setId(IdUtils.simpleUUID());
                    ardAlarmCamera.setCreateTime(new Date());
                    int aac = ardAlarmCameraMapper.insertArdAlarmCamera(ardAlarmCamera);
                    if (aac > 0) {
                        log.debug("camera入库成功：" + ardAlarmCamera);
                    }
                    //endregion
                    break;
                case "radar":
                    //region 处理雷达报警
                    RadarAlarmData radarAlarmData = JSONObject.parseObject(message, RadarAlarmData.class);
                    List<ArdAlarmRadar> ardAlarmRadars = radarAlarmData.getArdAlarmRadars();
                    List<ArdAlarmRadarMove>ardAlarmRadarMoves=new ArrayList<>();
                    List<ArdAlarmRadarFire>ardAlarmRadarFires=new ArrayList<>();
                    List<ArdAlarmRadarPump>ardAlarmRadarPumps=new ArrayList<>();
                    for (ArdAlarmRadar ardAlarmRadar : ardAlarmRadars) {
                        String uuid = IdUtils.simpleUUID();
                        String alarmpointName = ardAlarmRadar.getName();//兴趣点名称
                        Double longitude = ardAlarmRadar.getLongitude();
                        Double latitude = ardAlarmRadar.getLatitude();
                        String targetId=ardAlarmRadar.getTargetId();
                        switch (ardAlarmRadar.getAlarmType()) {
                            case "运动目标检测":
                                ArdAlarmRadarMove ardAlarmRadarMove=new ArdAlarmRadarMove();
                                ardAlarmRadarMove.setId(uuid);
                                ardAlarmRadarMove.setTargetId(targetId);
                                ardAlarmRadarMove.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarMove.setCreateTime(new Date());
                                ardAlarmRadarMove.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarMove.setAlarmType("运动目标检测");
                                ardAlarmRadarMove.setLongitude(longitude);
                                ardAlarmRadarMove.setLatitude(latitude);
                                //入库
                                ardAlarmRadarMoveMapper.insertArdAlarmRadarMove(ardAlarmRadarMove);
                                ardAlarmRadarMoves.add(ardAlarmRadarMove);

                                break;
                            case "热源检测":
                                ArdAlarmRadarFire ardAlarmRadarFire=new ArdAlarmRadarFire();
                                ardAlarmRadarFire.setId(uuid);
                                ardAlarmRadarFire.setTargetId(targetId);
                                ardAlarmRadarFire.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarFire.setCreateTime(new Date());
                                ardAlarmRadarFire.setName(alarmpointName + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarFire.setAlarmType("热源检测");
                                ardAlarmRadarFire.setLongitude(longitude);
                                ardAlarmRadarFire.setLatitude(latitude);
                                //入库
                                ardAlarmRadarFireMapper.insertArdAlarmRadarFire(ardAlarmRadarFire);
                                ardAlarmRadarFires.add(ardAlarmRadarFire);

                                break;
                            case "雷达抽油机停机":
                                ArdAlarmRadarPump ardAlarmRadarPump=new ArdAlarmRadarPump();
                                ardAlarmRadarPump.setId(uuid);
                                ardAlarmRadarPump.setTargetId(targetId);
                                ardAlarmRadarPump.setAlarmTime(radarAlarmData.getAlarmTime());
                                ardAlarmRadarPump.setCreateTime(new Date());
                                ardAlarmRadarPump.setName(ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")");
                                ardAlarmRadarPump.setAlarmType("雷达抽油机停机");
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
                                if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                                    ardAlarmRadarPump.setLongitude(ardAlarmpointsWell.getLongitude());
                                    ardAlarmRadarPump.setLatitude(ardAlarmpointsWell.getLatitude());
                                }
                                //入库
                                ardAlarmRadarPumpMapper.insertArdAlarmRadarPump(ardAlarmRadarPump);
                                ardAlarmRadarPumps.add(ardAlarmRadarPump);

                                break;
                        }
                    }
                    radarMoveGuide(ardAlarmRadarMoves,radarAlarmData);
                    radarFireGuide(ardAlarmRadarFires,radarAlarmData);
                    radarPumpGuide(ardAlarmRadarPumps,radarAlarmData);
                    break;
                case "external":
                    //region 处理外联报警
                    ArdAlarmExternal ardAlarmExternal = JSONObject.parseObject(message, ArdAlarmExternal.class);
                    ardAlarmExternal.setId(IdUtils.simpleUUID());
                    ardAlarmExternal.setCreateTime(new Date());//接收时间
                    //外联防区名称就是兴趣点，查兴趣点坐标
                    String defenseName = ardAlarmExternal.getDefenseName();
                    ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(defenseName);
                    if (StringUtils.isNotNull(ardAlarmpointsWell)) {
                        ardAlarmExternal.setLongitude(ardAlarmpointsWell.getLongitude());
                        ardAlarmExternal.setLatitude(ardAlarmpointsWell.getLatitude());
                    }
                    int aae = ardAlarmExternalMapper.insertArdAlarmExternal(ardAlarmExternal);
                    if (aae > 0) {
                        log.debug("external入库成功：" + ardAlarmExternal);
                        //region 引导录像
                        if (StringUtils.isNull(ardAlarmExternal.getLongitude()) || StringUtils.isNull(ardAlarmExternal.getLatitude())) {
                            return;
                        }
                        double[] guideCoordinate = new double[]{ardAlarmExternal.getLongitude(), ardAlarmExternal.getLatitude()};//引导坐标
                        String nearbyCameraId = getNearbyCamera(guideCoordinate);//最近相机ID
                        if (StringUtils.isNotEmpty(nearbyCameraId)) {
                            messagesEnqueued(nearbyCameraId, ardAlarmExternal.getId(), "sys_external", ardAlarmExternal.getCreateTime(), 1, 1, guideCoordinate);
                        }
                        //endregion
                    }
                    //endregion
                    break;
                case "accessControl":
                    //region 处理门禁报警
                    ArdAlarmAccess ardAlarmAccess = JSONObject.parseObject(message, ArdAlarmAccess.class);
                    ardAlarmAccess.setId(IdUtils.simpleUUID());
                    ardAlarmAccess.setCreateTime(new Date());//接收时间
                    //查管理的门禁主机信息
                    String acsId = ardAlarmAccess.getAcsId();
                    ArdEquipExternal ardEquipExternal = ardEquipExternalMapper.selectArdEquipExternalById(acsId);
                    if (StringUtils.isNotNull(ardEquipExternal)) {
                        ardAlarmAccess.setLongitude(ardEquipExternal.getLongitude());
                        ardAlarmAccess.setLatitude(ardEquipExternal.getLatitude());
                        ardAlarmAccess.setAltitude(ardEquipExternal.getAltitude());
                        ardAlarmAccess.setAcsId(ardEquipExternal.getId());
                        ardAlarmAccess.setAcsName(ardEquipExternal.getName());
                    }
                    int aaa = ardAlarmAccessMapper.insertArdAlarmAccess(ardAlarmAccess);
                    if (aaa > 0) {
                        log.debug("external入库成功：" + ardAlarmAccess);
                        //region 引导录像
                        if (StringUtils.isNull(ardAlarmAccess.getLongitude()) || StringUtils.isNull(ardAlarmAccess.getLatitude())) {
                            return;
                        }
                        double[] guideCoordinate = new double[]{ardAlarmAccess.getLongitude(), ardAlarmAccess.getLatitude()};//引导坐标
                        String nearbyCameraId = getNearbyCamera(guideCoordinate);//最近相机ID
                        if (StringUtils.isNotEmpty(nearbyCameraId)) {
                            messagesEnqueued(nearbyCameraId, ardAlarmAccess.getId(), "sys_access_control", ardAlarmAccess.getCreateTime(), 1, 1, guideCoordinate);
                        }
                        //endregion
                    }
                    //endregion
                    break;
                case "apponekey":
                    //region app一键报警
                    ArdAlarmApponekey ardAlarmApponekey = JSONObject.parseObject(message, ArdAlarmApponekey.class);
                    int aaak = ardAlarmApponekeyMapper.insertArdAlarmApponekey(ardAlarmApponekey);
                    if (aaak > 0) {
                        log.debug("apponekey入库成功：" + ardAlarmApponekey);
                    }
                    //endregion
                    break;
            }
        } catch (Exception ex) {
            log.error("接收报警异常:" + ex.getMessage());
        }
    }

    /**
     * 消息入队
     * <p>
     * cameraId 相机ID
     * alarmId  报警ID
     * alarmType 报警类型
     * num  报警次数
     * recordSn 录像存储位置 1-recordUrl1 2-recordUrl2
     * targetPosition 报警点位置坐标
     */
    private void messagesEnqueued(String cameraId, String alarmId, String alarmType, Date receiveTime, Integer num, Integer recordSn, double[] targetPosition) {
        try {
            if (!IsEnableGuide(cameraId)) {
                log.info("相机:" + cameraId + "未开启报警引导功能");
                return;
            }
            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
            GuideTask guideTask = new GuideTask();
            //相机ID
            guideTask.setCameraId(cameraId);
            //报警类型
            String aType="";
            switch (alarmType)
            {
                case "运动目标检测": aType="sys_radar_move";break;
                case "热源检测": aType="sys_radar_fire";break;
                case "雷达抽油机停机": aType="sys_radar_pump";break;
                default: aType=alarmType;break;
            }
            guideTask.setAlarmType(aType);
            //通道(通过日夜时间研判)
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            Integer channel = ArdTool.getChannelBydayNightTime(dayNightTime);
            guideTask.setChanNum(channel);
            //报警ID
            guideTask.setAlarmId(alarmId);
            //接收时间
            guideTask.setReceiveTime(fmt.format(receiveTime));
            //报警优先级(通过优先级字典)
            String priority = DictUtils.getDictValue("cameras_priority", aType);
            if (StringUtils.isEmpty(priority)) {
                log.debug("未匹配到优先级,请检查优先级字典配置");
                return;
            }
            guideTask.setPriority(Integer.valueOf(priority));
            //报警次数
            guideTask.setNum(num);
            //录像存储位置
            guideTask.setRecordSn(recordSn);
            //目标经纬度
            guideTask.setTargetPosition(targetPosition);
            //消息入队
            queueManager.addTaskToQueue(cameraId, guideTask);
            //打印队列
            GuidePriorityQueue.printPriorityQueue();
        } catch (Exception ex) {
            log.error("报警入队异常:" + ex.getMessage());
        }
    }

    /**
     * 光电是否开启报警引导功能
     * 刘苏义
     * 2023/7/7 14:03
     */
    private Boolean IsEnableGuide(String cameraId) {
        boolean enabled = false;
        ArdCameras ardCameras = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
        if (ardCameras != null) {
            if (ardCameras.getCamAlarmGuideEnable().equals(1)) {
                enabled = true;
            }
        }
        return enabled;
    }

    /**
     * 获取附近开启报警引导功能光电
     */
    private String getNearbyCamera(double[] targetPosition) {
        String minDistanceCameraId = "";
        try {
            //获取所有大光电
            List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
            //统计所有大光电可视范围内与报警点的距离
            Map<String, Double> distanceMap = new HashMap<>();
            Map<String, Integer> guideMap = new HashMap<>();
            for (ArdCameras camera : ardCamerasList) {
                if (camera.getCamMaxVisibleDistance() == null) {
                    continue;
                }
                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double distance = GisUtil.getDistance(targetPosition, camPosition);
                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                    distanceMap.put(camera.getId(), distance);
                    if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
                        camera.setCamAlarmGuideEnable(0);
                    }
                    guideMap.put(camera.getId(), camera.getCamAlarmGuideEnable());
                }
            }
            if (distanceMap.size() > 0) {
                log.debug("尝试查找最近光电");
                //获取距离字典中最近的一个相机ID
                minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
                log.debug("查找到最近光电:" + minDistanceCameraId);
                if (guideMap.get(minDistanceCameraId).equals(0)) {
                    log.debug("该光电未开启报警引导");
                    return " ";
                }
            }
        } catch (Exception ex) {
            log.error("获取附近开启报警引导功能光电异常:" + ex.getMessage());
        }
        return minDistanceCameraId;
    }


    /**
     * 雷达引导入队
     */
    private void radarGuideToQueue(String alarmId,String radarId, String name, String alarmType, Date createTime, double[] coordinate) {
        int index = name.indexOf("(");
        String alarmpointName = name.substring(0, index);
        //获取雷达所在塔上的大光电
        String cameraIdWithTower = ardEquipRadarMapper.getCameraByRadar(radarId);
        if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
            log.debug("获取到雷达塔上的光电:" + cameraIdWithTower);
            //如果雷达塔上有光电
            messagesEnqueued(cameraIdWithTower, alarmId, alarmType, createTime, 1, 1, coordinate);
        }
        else
        {
            log.debug("未获取到雷达塔上的光电");
        }
        //获取报警点关联的大光电
        ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(alarmpointName);
        if (StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId())) {
            String cameraId = ardAlarmpointsWell.getCameraId();
            if (cameraId.equals(cameraIdWithTower)) {
                return;
            }
            log.info("获取到报警点关联的光电:" + cameraId);
            //如果报警点关联了光电
            messagesEnqueued(cameraId, alarmId, alarmType, createTime, 1, 2, coordinate);
        }
        else
        {
            log.debug("未获取到报警点关联的光电");
        }
    }


    private void radarMoveGuide(List<ArdAlarmRadarMove> ardAlarmRadarMoves,RadarAlarmData radarAlarmData)
    {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarMoves = ardAlarmRadarMoves.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarMove::getName))), ArrayList::new));
        if(ardAlarmRadarMoves.size()>0) {
            for (ArdAlarmRadarMove ardAlarmRadarMove : ardAlarmRadarMoves) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarMove.getLongitude()) || StringUtils.isNull(ardAlarmRadarMove.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarMove.getLongitude(), ardAlarmRadarMove.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarMove alarmRadarMove = redisCache.getCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarMove == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarMove.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);//更新

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapMove.get(ardAlarmRadarMove.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarMove.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_move_alarm:" + ardAlarmRadarMove.getName(), ardAlarmRadarMove, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队

                            radarGuideToQueue(ardAlarmRadarMove.getId(), radarAlarmData.getRadarId(), ardAlarmRadarMove.getName(), ardAlarmRadarMove.getAlarmType(), ardAlarmRadarMove.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarMove.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarMove.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapMove.put(ardAlarmRadarMove.getName(), count);
                }
                //更新
                ardAlarmRadarMoveMapper.updateArdAlarmRadarMove(ardAlarmRadarMove);
            }
        }
        //endregion
    }
    private void radarFireGuide(List<ArdAlarmRadarFire> ardAlarmRadarFires,RadarAlarmData radarAlarmData)
    {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarFires = ardAlarmRadarFires.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarFire::getName))), ArrayList::new));
        if(ardAlarmRadarFires.size()>0) {
            for (ArdAlarmRadarFire ardAlarmRadarFire : ardAlarmRadarFires) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarFire.getLongitude()) || StringUtils.isNull(ardAlarmRadarFire.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarFire.getLongitude(), ardAlarmRadarFire.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarFire alarmRadarFire = redisCache.getCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarFire == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarFire.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapFire.put(alarmRadarFire.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapFire.get(alarmRadarFire.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarFire.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_fire_alarm:" + ardAlarmRadarFire.getName(), ardAlarmRadarFire, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarFire.getId(), radarAlarmData.getRadarId(), ardAlarmRadarFire.getName(), ardAlarmRadarFire.getAlarmType(), ardAlarmRadarFire.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarFire.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarFire.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapFire.put(ardAlarmRadarFire.getName(), count);
                }
                //更新
                ardAlarmRadarFireMapper.updateArdAlarmRadarFire(ardAlarmRadarFire);
            }
        }
        //endregion
    }
    private void radarPumpGuide(List<ArdAlarmRadarPump> ardAlarmRadarPumps,RadarAlarmData radarAlarmData)
    {
        //按兴趣点去重,然后按引导逻辑进行引导入队
        ardAlarmRadarPumps = ardAlarmRadarPumps.stream()
                .collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new java.util.TreeSet<>(java.util.Comparator.comparing(ArdAlarmRadarPump::getName))), ArrayList::new));
        if(ardAlarmRadarPumps.size()>0) {
            for (ArdAlarmRadarPump ardAlarmRadarPump : ardAlarmRadarPumps) {
                //遍历报警数据进行引导
                if (StringUtils.isNull(ardAlarmRadarPump.getLongitude()) || StringUtils.isNull(ardAlarmRadarPump.getLatitude())) {
                    //坐标为空不引导
                    continue;
                }
                double[] coordinate = new double[]{ardAlarmRadarPump.getLongitude(), ardAlarmRadarPump.getLatitude()};//报警坐标
                //从redis中取出当前报警点的5分钟内是否有引导
                ArdAlarmRadarPump alarmRadarPump = redisCache.getCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName());//从redis中取出最新引导的报警数据
                if (alarmRadarPump == null) {
                    //5分钟内redis中没有数据，说明5分钟内没有引导数据
                    ardAlarmRadarPump.setGuideFlag(1);
                    //将引导数据写入redis 设置5分钟过期
                    redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);//引导数据写入redis
                    unGuideCountMapPump.put(alarmRadarPump.getName(), 0);
                    //引导入队
                    radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);

                } else {
                    //5分钟内redis中有数据，说明5分钟内有引导数据,获取当前报警点的未引导次数
                    Integer count = unGuideCountMapPump.get(ardAlarmRadarPump.getName());
                    if (count != null) {
                        if (count > 2) {
                            //未引导次数3次后进行引导
                            ardAlarmRadarPump.setGuideFlag(1);
                            //将引导数据写入redis 设置5分钟过期
                            redisCache.setCacheObject("global_pump_alarm:" + ardAlarmRadarPump.getName(), ardAlarmRadarPump, 5, TimeUnit.MINUTES);
                            count = 0;
                            //引导入队
                            radarGuideToQueue(ardAlarmRadarPump.getId(), radarAlarmData.getRadarId(), ardAlarmRadarPump.getName(), ardAlarmRadarPump.getAlarmType(), ardAlarmRadarPump.getCreateTime(), coordinate);
                        } else {
                            ardAlarmRadarPump.setGuideFlag(0);
                            count++;
                        }
                    } else {
                        ardAlarmRadarPump.setGuideFlag(0);
                        count = 0;
                    }
                    unGuideCountMapPump.put(ardAlarmRadarPump.getName(), count);
                }
                //更新
                ardAlarmRadarPumpMapper.updateArdAlarmRadarPump(ardAlarmRadarPump);
            }
        }
        //endregion
    }
}