package com.objecteye.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.objecteye.entity.*;
import com.objecteye.mapper.SyAreaEquipmentMapper;
import com.objecteye.mapper.SyDeployEquipmentMapper;
import com.objecteye.mapper.SyDeployMapper;
import com.objecteye.pojo.RabbitMQInfo;
import com.objecteye.pojo.RabbitMQVehicle;
import com.objecteye.pojo.ResponseParamPerson;
import com.objecteye.service.AreaEquipmentService;
import com.objecteye.service.DeployEquipmentService;
import com.objecteye.service.DeployService;
import com.objecteye.service.PersonnelService;
import com.objecteye.utils.CompareDistance;
import com.objecteye.utils.GlobalUtil;
import com.objecteye.utils.VehicleDetailsUtils;
import com.objecteye.utils.VehicleEngine;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 服务实现层
 *
 * @author Administrator
 */
@Service
public class DeployServiceImpl implements DeployService {

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

    @Autowired
    private SyDeployMapper deployMapper;
    @Autowired
    private SyDeployEquipmentMapper syDeployEquipmentMapper;
    @Autowired
    private SyDeployMapper syDeployMapper;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private DeployEquipmentService deployEquipmentService;
    @Autowired
    private AreaEquipmentService areaEquipmentService;
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private PersonnelService personnelService;
    @Autowired
    private CompareDistance compareDistance;
    @Autowired
    private VehicleEngine vehicleEngine;
    @Autowired
    private SyAreaEquipmentMapper syAreaEquipmentMapper;

    /**
     * 查询全部
     */
    @Override
    public List<SyDeploy> findAll() {
        SyDeployExample example = new SyDeployExample();
        SyDeployExample.Criteria criteria = example.createCriteria();
        criteria.andIsDeleteEqualTo(0);

        return deployMapper.selectByExample(example);
    }

    @Override
    public Integer cancelOrReNewDeployTask(int deployId) {
        SyDeploy syDeploy = deployMapper.selectByPrimaryKey(deployId);
        Integer status = syDeploy.getStatus();
        if (status == 0) {
            syDeploy.setStatus(1);
            deployMapper.updateByPrimaryKeySelective(syDeploy);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, syDeploy.getId());
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYIDANDENDTIME, syDeploy.getId());
            removeDeploysByDeploy(deployId);
            changeAllTaskDetailStatus(syDeploy, 1);
        } else if (status == 1) {
            String endTime = syDeploy.getEndTime();
            DateTime parse = DateUtil.parse(endTime);
            long time = parse.getTime();
            long nowTime = System.currentTimeMillis();
            if (nowTime > time) {
                throw new RuntimeException("布控结束时间过期");
            }
            syDeploy.setStatus(0);
            deployMapper.updateByPrimaryKeySelective(syDeploy);
            addDeploysByDeploy(syDeploy.getId());
            changeAllTaskDetailStatus(syDeploy, 0);
            redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, syDeploy.getId(), syDeploy.getEndTime());
            redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, syDeploy.getId(), syDeploy.getStartTime());
        }
        return syDeploy.getStatus();
    }

    /**
     * 修改任务下所有布控项明细的状态值
     *
     * @param syDeploy 布控任务
     * @param status   修改之后的状态
     */
    private void changeAllTaskDetailStatus(SyDeploy syDeploy, int status) {
        String deployId = String.valueOf(syDeploy.getId());
        for (String deployLid : syDeploy.getDeployLib().split(",")) {
            String hashKey;
            if (syDeploy.getDeployType() == 0) {
                hashKey = deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM;
            } else {
                hashKey = deployId + "|" + deployLid;
            }
            if (syDeploy.getDeployType() == 2) {
                Set<Integer> detailIntIds = redisTemplate.opsForHash().keys(hashKey);
                for (Integer detailId : detailIntIds) {
                    redisTemplate.opsForHash().put(hashKey, detailId, status);
                }
            } else {
                Set<String> detailIds = redisTemplate.opsForHash().keys(hashKey);
                for (String detailId : detailIds) {
                    redisTemplate.opsForHash().put(hashKey, detailId, status);
                }
            }

        }
    }

    @Override
    public Integer cancelOrReNewTaskByPersonId(int deployId, int featureId, int personId) {
        String key = deployId + "|" + featureId;
        Object o = redisTemplate.opsForHash().get(key, personId);
        if (o != null) {
            String s = o.toString();
            int status = Integer.parseInt(s);
            if (status == 1) {
                redisTemplate.opsForHash().put(key, personId, 0);
            } else {
                redisTemplate.opsForHash().put(key, personId, 1);
            }
        } else {
            redisTemplate.opsForHash().put(key, personId, 1);
        }
        return (Integer) redisTemplate.opsForHash().get(key, personId);
    }

    @Override
    public Integer cancelOrReNewTaskByVehicleId(int deployId, int featureId, String id) {
        String key = deployId + "|" + featureId;
        Object o = redisTemplate.opsForHash().get(key, id);
        if (o != null) {
            String s = o.toString();
            int status = Integer.parseInt(s);
            if (status == 1) {
                redisTemplate.opsForHash().put(key, id, 0);
            } else {
                redisTemplate.opsForHash().put(key, id, 1);
            }
        } else {
            redisTemplate.opsForHash().put(key, id, 1);
        }
        return (Integer) redisTemplate.opsForHash().get(key, id);
    }

    @Override
    public Integer cancelOrReNewTaskByPlate(int deployId, String plate) {
        String key = deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM;
        Object o = redisTemplate.opsForHash().get(key, plate);
        if (o != null) {
            String s = o.toString();
            int status = Integer.parseInt(s);
            if (status == 1) {
                redisTemplate.opsForHash().put(key, plate, 0);
            } else {
                redisTemplate.opsForHash().put(key, plate, 1);
            }
        } else {
            redisTemplate.opsForHash().put(key, plate, 1);
        }

        return (Integer) redisTemplate.opsForHash().get(key, plate);
    }

    /**
     * 按分页查询
     */
    @Override
    public PageResult findPage(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        SyDeployExample example = new SyDeployExample();
        SyDeployExample.Criteria criteria = example.createCriteria();
        criteria.andIsDeleteEqualTo(0);

        Page<SyDeploy> page = (Page<SyDeploy>) deployMapper.selectByExample(example);
        List<SyDeploy> result = page.getResult();
        List<DeployResultMsg> deployResultMsgs = new ArrayList<>();
        if (result != null && result.size() > 0) {
            for (SyDeploy deploy : result) {
                DeployResultMsg deployResultMsg = new DeployResultMsg();
                deployResultMsg.setDeployName(deploy.getName());
                deployResultMsg.setDeployId(deploy.getId());
                deployResultMsg.setStatus(deploy.getStatus());
                deployResultMsgs.add(deployResultMsg);
            }
        }
        return new PageResult<>(page.getPages(), deployResultMsgs);
    }

    /**
     * 增加
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public void add(SyDeploy deploy) {
        // 处理前端传递的时间戳
        makeTimeLongToTimeStr(deploy);
        String now = DateUtil.now();
        if (DateUtil.parse(deploy.getStartTime()).getTime() <= System.currentTimeMillis()) {
            deploy.setStartTime(now);
            deploy.setStatus(0);
        } else {
            deploy.setStatus(1);
        }
        String endTimeStr = deploy.getEndTime();
        deploy.setIsDelete(0);
        deploy.setCreateDate(now);
        deploy.setSinglemonitor(0);
        int deployType = deploy.getDeployType();

        deploy.setDeployType(deployType);
        String featureIds = deploy.getDeployLib();
        String[] split = featureIds.split(",");

        deploy.setDeployLib(featureIds);
        Set<Integer> equipmens = getEquipmens(deploy);

        String equipIds = equipmens.stream().map(String::valueOf).collect(Collectors.joining(","));
        deploy.setSingleId(deploy.getDeployEquip());
        deploy.setDeployEquip(equipIds);
        deployMapper.insert(deploy);
        Integer deployId = deploy.getId();
        // 布控库中每一条数据都放到redis中
        makeLibRedisDetail(split, deployId, deployType);

        for (Integer alleqid : equipmens) {
            insertDeployEquip(deploy.getId(), alleqid);
            findDeploysByEquipmentId(alleqid);
        }

        redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, deployId, deploy.getStartTime());
        if (deploy.getThresld() != null) {
            redisTemplate.opsForHash().put(GlobalUtil.DEPLOYTHRESLD, deployId, deploy.getThresld());
        }
        redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_LIB, deployId, featureIds);
        redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_TYPE, deployId, deployType);
        redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, deployId, endTimeStr);
    }

    /**
     * 重置时间参数
     *
     * @param syDeploy 原始数据
     */
    private void makeTimeLongToTimeStr(SyDeploy syDeploy) {
        syDeploy.setStartTime(DateUtil.format(new Date(Long.parseLong(syDeploy.getStartTime())), "yyyy-MM-dd HH:mm:ss"));
        syDeploy.setEndTime(DateUtil.format(new Date(Long.parseLong(syDeploy.getEndTime())), "yyyy-MM-dd HH:mm:ss"));
    }

    /**
     * 布控库中每一条数据都放到redis中
     *
     * @param split      所有的布控库id
     * @param deployId   布控任务id
     * @param deployType 布控任务类型
     */
    private void makeLibRedisDetail(String[] split, int deployId, int deployType) {
        for (String s : split) {
            s = s.trim();
            if (deployType == 0) {
                redisTemplate.opsForHash().put(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, s, 0);
            } else if (deployType == 1) {
                Integer integer = Integer.valueOf(s);
                List<UploadVehicleDbResult> vehicleId = mongoTemplate.find(Query.query(new Criteria("vehicleId").is(integer)), UploadVehicleDbResult.class);
                String key = deployId + "|" + integer;
                for (UploadVehicleDbResult uploadVehicleDbResult : vehicleId) {
                    String id = uploadVehicleDbResult.getId();
                    redisTemplate.opsForHash().put(key, id, 0);
                }
            } else if (deployType == 2) {
                int integer = Integer.parseInt(s);
                List<SyPersonnel> personIdByFid = personnelService.findPersonIdByFid(integer);
                String key = deployId + "|" + integer;
                for (SyPersonnel syPersonnel : personIdByFid) {
                    Integer id = syPersonnel.getId();
                    redisTemplate.opsForHash().put(key, id, 0);
                }
            }
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void update(SyDeploy deploy) {
        // 处理前端传递的时间戳
        makeTimeLongToTimeStr(deploy);
        long l = System.currentTimeMillis();
        String endTime = deploy.getEndTime();
        long time = DateUtil.parse(endTime).getTime();
        Integer deployId = deploy.getId();
        if (l > time) {
            deploy.setStatus(1);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, deployId);
        } else if (l < DateUtil.parse(deploy.getStartTime()).getTime()) {
            deploy.setStatus(1);
            redisTemplate.opsForHash().put(GlobalUtil.DEPLOYID_STATRTIME, deployId, deploy.getStartTime());
        }
        String deployLib = deploy.getDeployLib();
        Integer deployType = deploy.getDeployType();
        Set<Integer> equipments = getEquipmens(deploy);

        String equipIds = equipments.stream().map(String::valueOf).collect(Collectors.joining(","));
        deploy.setDeployEquip(equipIds);

        // 删除历史
        deleteRedisWhenUpdateDeploy(deployId);
        // 布控库中每一条数据都放到redis中
        if (deployLib != null && !"".equals(deployLib)) {
            makeLibRedisDetail(deployLib.split(","), deployId, deployType);
        }

        deployEquipmentService.deleteByDeployId(deployId);
        for (Integer alleqid : equipments) {
            insertDeployEquip(deploy.getId(), alleqid);
            findDeploysByEquipmentId(alleqid);
        }

        redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_LIB, deployId, deployLib);
        redisTemplate.opsForHash().put(GlobalUtil.DEPLOY_TYPE, deployId, deployType);
        redisTemplate.opsForHash().put(GlobalUtil.DEPLOYIDANDENDTIME, deployId, endTime);

        deployMapper.updateByPrimaryKeySelective(deploy);
    }

    /**
     * 删除历史的所有对应布控任务布控库redis数据
     *
     * @param deployId 布控任务id
     */
    private void deleteRedisWhenUpdateDeploy(int deployId) {
        SyDeploy oldSyDeploy = deployMapper.selectByPrimaryKey(deployId);
        if (oldSyDeploy.getDeployType() == 0) {
            redisTemplate.delete(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM);
        } else {
            String oldDeployLib = oldSyDeploy.getDeployLib();
            // 删除历史
            List<String> deleteIds = new ArrayList<>();
            for (String libId : oldDeployLib.split(",")) {
                deleteIds.add(deployId + "|" + libId);
            }
            redisTemplate.delete(deleteIds);
        }
    }

    /**
     * 根据ID获取实体
     *
     * @param id
     * @return
     */
    @Override
    public SyDeploy findOne(int id) {
        SyDeploy syDeploy = deployMapper.selectByPrimaryKey(id);
        if (syDeploy != null) {
            syDeploy.setStartTime(String.valueOf(DateUtil.parse(syDeploy.getStartTime()).getTime()));
            syDeploy.setEndTime(String.valueOf(DateUtil.parse(syDeploy.getEndTime()).getTime()));
            syDeploy.setDeployEquip(syDeploy.getSingleId());
            String areaIds = syDeploy.getSingleId();
            if (areaIds != null && !"".equals(areaIds)) {
                List<Integer> areaIdList = Arrays.stream(areaIds.split(",")).map(Integer::parseInt).collect(Collectors.toList());
                SyAreaEquipmentExample syAreaEquipmentExample = new SyAreaEquipmentExample();
                SyAreaEquipmentExample.Criteria criteria = syAreaEquipmentExample.createCriteria();
                criteria.andIdIn(areaIdList);
                List<SyAreaEquipment> syAreaEquipments = syAreaEquipmentMapper.selectByExample(syAreaEquipmentExample);
                String areaNames = syAreaEquipments.stream().map(SyAreaEquipment::getName).collect(Collectors.joining(","));
                syDeploy.setAreaName(areaNames);
            }
        }
        return syDeploy;
    }


    /**
     * 批量删除
     */
    @Override
    public void delete(int[] ids) {
        for (int id : ids) {
            SyDeploy syDeploy = deployMapper.selectByPrimaryKey(id);
            syDeploy.setIsDelete(1);
            deleteRedisWhenUpdateDeploy(id);
            deployMapper.updateByPrimaryKeySelective(syDeploy);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOY_LIB, id);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOY_TYPE, id);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYIDANDENDTIME, id);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, id);
            redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYTHRESLD, id);

            SyDeployEquipmentExample syDeployEquipmentExample = new SyDeployEquipmentExample();
            SyDeployEquipmentExample.Criteria criteria = syDeployEquipmentExample.createCriteria();
            criteria.andDidEqualTo(id);

            List<SyDeployEquipment> syDeployEquipments = syDeployEquipmentMapper.selectByExample(syDeployEquipmentExample);
            for (SyDeployEquipment syDeployEquipment : syDeployEquipments) {
                Integer id1 = syDeployEquipment.getId();
                syDeployEquipmentMapper.deleteByPrimaryKey(id1);

                findDeploysByEquipmentId(id);
            }
        }
    }


    /**
     * 布控任务查询列表- 分页
     *
     * @param pageNum  当前页 码
     * @param pageSize 每页记录数
     * @param deploy   布控任务类型
     * @return 结果集
     */
    @Override
    public PageResult findPage(SyDeploy deploy, int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);

        SyDeployExample example = new SyDeployExample();
        SyDeployExample.Criteria criteria = example.createCriteria();
        Integer deployType = deploy.getDeployType();
        criteria.andDeployTypeEqualTo(deployType);
        criteria.andIsDeleteEqualTo(0);
        Page<SyDeploy> page = (Page<SyDeploy>) deployMapper.selectByExample(example);
        List<SyDeploy> tempDeployList = page.getResult();
        List<MonitorTaskResultInfo> resultInfos = new ArrayList<>();

        // 查询出指定任务类型的所有任务报警次数
        Map<Integer, Long> deployIdWarningNumberMap = getDeployIdWarningNumberMap(deployType);
        for (SyDeploy syDeploy : tempDeployList) {
            long warningNumber = deployIdWarningNumberMap.getOrDefault(syDeploy.getId(), 0L);
            MonitorTaskResultInfo monitorTaskResultInfo = new MonitorTaskResultInfo();
            monitorTaskResultInfo.setId(syDeploy.getId());
            monitorTaskResultInfo.setStatus(syDeploy.getStatus());
            monitorTaskResultInfo.setName(syDeploy.getName());
            monitorTaskResultInfo.setCreateDate(syDeploy.getCreateDate());
            monitorTaskResultInfo.setWarningNumber(warningNumber);
            resultInfos.add(monitorTaskResultInfo);
        }

        return new PageResult<>(page.getPages(), resultInfos);
    }

    /**
     * 获取指定任务类型id报警数量
     *
     * @param deployType 报警类型
     * @return 结果集
     */
    private Map<Integer, Long> getDeployIdWarningNumberMap(Integer deployType) {
        Aggregation aggregation = Aggregation.newAggregation(
                Aggregation.match(Criteria.where("alarmType").is(deployType)),
                Aggregation.group("deployId").count().as("count"),
                Aggregation.project("deployId", "count")
        );
        AggregationResults<JSONObject> aggregationResults = mongoTemplate.aggregate(aggregation, "plateAlarmMsg", JSONObject.class);
        List<JSONObject> deviceIdsWarningNumberList = aggregationResults.getMappedResults();
        Map<Integer, Long> resultMap = new HashMap<>(16);
        for (JSONObject jsonObject : deviceIdsWarningNumberList) {
            if (jsonObject == null) {
                continue;
            }
            resultMap.put(jsonObject.getIntValue("_id"), jsonObject.getLongValue("count"));
        }

        return resultMap;
    }

    /**
     * 布控任务-任务内容 查询列表
     *
     * @param deployId    任务id
     * @param currentpage 页码
     * @param pagevolume  页码容量
     * @return 结果集
     */
    @Override
    public PageResult findMonitorTaskDetail(Integer deployId, int currentpage, int pagevolume) {
        SyDeploy syDeploy = syDeployMapper.selectByPrimaryKey(deployId);
        Integer deployType = syDeploy.getDeployType();
        List<MonitorTaskContentResultInfo> resultInfos = new ArrayList<>();
        if (null != deployType) {
            if (0 == deployType) {
                Set<String> plateNumberSet = redisTemplate.opsForHash().keys(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM);
                for (String plateNumber : plateNumberSet) {
                    MonitorTaskContentResultInfo monitorTaskContentResultInfo = new MonitorTaskContentResultInfo();
                    monitorTaskContentResultInfo.setPlateNumber(plateNumber);
                    monitorTaskContentResultInfo.setCreateDate(syDeploy.getCreateDate());
                    monitorTaskContentResultInfo.setDeployTime(syDeploy.getStartTime() + "-" + syDeploy.getEndTime());
                    monitorTaskContentResultInfo.setDeployId(String.valueOf(deployId));
                    Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, plateNumber);
                    monitorTaskContentResultInfo.setStatus(String.valueOf(status));
                    resultInfos.add(monitorTaskContentResultInfo);
                }
            } else {
                String[] deployLibArr = syDeploy.getDeployLib().split(",");

                for (String deployLib : deployLibArr) {
                    Map<String, Integer> oneLibPicUrlStatusMap = redisTemplate.opsForHash().entries(deployId + "|" + deployLib);
                    for (Map.Entry<String, Integer> entry : oneLibPicUrlStatusMap.entrySet()) {
                        MonitorTaskContentResultInfo monitorTaskContentResultInfo = new MonitorTaskContentResultInfo();
                        monitorTaskContentResultInfo.setDeployTime(syDeploy.getStartTime() + "-" + syDeploy.getEndTime());
                        monitorTaskContentResultInfo.setCreateDate(syDeploy.getCreateDate());
                        monitorTaskContentResultInfo.setId(String.valueOf(entry.getKey()));
                        monitorTaskContentResultInfo.setFeatureId(deployLib);
                        monitorTaskContentResultInfo.setDeployId(String.valueOf(deployId));
                        String urlKey = "";
                        if (1 == deployType) {
                            urlKey = "vehicleUrl";
                        } else if (2 == deployType) {
                            urlKey = "personUrl";
                        }
                        monitorTaskContentResultInfo.setUrl((String) redisTemplate.opsForHash().get(urlKey, entry.getKey()));
                        Integer status = entry.getValue();
                        monitorTaskContentResultInfo.setStatus(String.valueOf(status));
                        resultInfos.add(monitorTaskContentResultInfo);
                    }
                }
            }
        }
        return makePageResultByBaseList(resultInfos, currentpage, pagevolume);
    }


    /**
     * 统一手动分页
     *
     * @param baseList    原始数据集合
     * @param currentpage 页码
     * @param pagevolume  页面容量
     * @return 结果集
     */
    private PageResult makePageResultByBaseList(List baseList, Integer currentpage, Integer pagevolume) {
        // 总页数
        int pageTotal = (baseList.size() / pagevolume) + ((baseList.size() % pagevolume > 0) ? 1 : 0);

        int fromIndex = (currentpage - 1) * pagevolume;
        int toIndex;
        if (currentpage == pageTotal) {
            toIndex = baseList.size();
        } else if (pageTotal == 0) {
            return new PageResult<>(pageTotal, new ArrayList<>());
        } else {
            toIndex = currentpage * pagevolume;
            if (toIndex > baseList.size()) {
                toIndex = baseList.size();
            }
            if (fromIndex >= toIndex) {
                return new PageResult<>(pageTotal, new ArrayList<>());
            }
        }

        return new PageResult<>(pageTotal, baseList.subList(fromIndex, toIndex));
    }

    /**
     * 每隔一分钟秒执行一次
     */
    @Scheduled(fixedRate = 60 * 1000)
    public void monitorDeployState() {
        Map<Integer, String> map = redisTemplate.opsForHash().entries(GlobalUtil.DEPLOYID_STATRTIME);
        Set<Integer> integers = map.keySet();
        for (Integer integer : integers) {
            String endTime = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOYIDANDENDTIME, integer);
            long currentTimeStamp = System.currentTimeMillis();
            long deployEndTimeStamp = Objects.requireNonNull(DateUtil.parse(endTime)).getTime();
            long deployStartTimeStamp = DateUtil.parse(map.get(integer)).getTime();
            // 没有到开始时间的不做处理
            if (currentTimeStamp >= deployStartTimeStamp && currentTimeStamp <= deployEndTimeStamp) {
                SyDeploy syDeploy = deployMapper.selectByPrimaryKey(integer);
                if (syDeploy == null) {
                    return;
                }
                if (1 == syDeploy.getStatus()) {
                    syDeploy.setStatus(0);
                    deployMapper.updateByPrimaryKeySelective(syDeploy);
                }
                String[] split = syDeploy.getDeployEquip().split(",");
                deployEquipmentService.deleteByDeployId(integer);
                for (String equipmentId : split) {
                    insertDeployEquip(integer, Integer.parseInt(equipmentId));
                    findDeploysByEquipmentId(Integer.parseInt(equipmentId));
                }
            } else if (currentTimeStamp > deployEndTimeStamp) {
                SyDeploy syDeploy = deployMapper.selectByPrimaryKey(integer);
                if (syDeploy == null) {
                    return;
                }
                syDeploy.setStatus(1);
                deployMapper.updateByPrimaryKeySelective(syDeploy);
                String[] split = syDeploy.getDeployEquip().split(",");

                deployEquipmentService.deleteByDeployId(integer);
                for (String equipmentId : split) {
                    findDeploysByEquipmentId(Integer.parseInt(equipmentId));
                }
                redisTemplate.opsForHash().delete(GlobalUtil.DEPLOYID_STATRTIME, integer);
            }
        }
    }

    /**
     * 修改布控任务id和设备id 的是否关闭的状态
     *
     * @param deployId    任务id
     * @param equipmentId 设备id
     * @return 操作结果
     */
    private Integer insertDeployEquip(int deployId, int equipmentId) {

        SyDeployEquipment syDeployEquipment = new SyDeployEquipment();
        syDeployEquipment.setEid(equipmentId);
        syDeployEquipment.setDid(deployId);
        syDeployEquipment.setIsDelete(0);
        return syDeployEquipmentMapper.insert(syDeployEquipment);
    }

    /**
     * 根据设备id把所有的状态是未删除的所有任务id放到redis中
     *
     * @param equipmentId 设备id
     */
    private void findDeploysByEquipmentId(int equipmentId) {
        SyDeployEquipmentExample example = new SyDeployEquipmentExample();
        SyDeployEquipmentExample.Criteria criteria = example.createCriteria();
        criteria.andEidEqualTo(equipmentId);
        criteria.andIsDeleteEqualTo(0);
        List<SyDeployEquipment> syDeployEquipments = syDeployEquipmentMapper.selectByExample(example);
        if (syDeployEquipments != null && syDeployEquipments.size() > 0) {
            List<Integer> list = new ArrayList<>();
            for (SyDeployEquipment syDeployEquipment : syDeployEquipments) {
                list.add(syDeployEquipment.getDid());
            }
            redisTemplate.opsForHash().put(GlobalUtil.IPWITHDEPLOYLIST, equipmentId, list);
        } else {
            redisTemplate.opsForHash().delete(GlobalUtil.IPWITHDEPLOYLIST, equipmentId);
        }
    }

    /**
     * 通过区域id获取所有的设备id
     *
     * @param deploy 布控任务
     * @return 设备id集合
     */
    private Set<Integer> getEquipmens(SyDeploy deploy) {
        String areaIds = deploy.getDeployEquip();
        String[] equipmentIds = StringUtils.split(areaIds, ",");

        Set<Integer> alleqids = new HashSet<>();
        for (int i = 0; i < equipmentIds.length; i++) {
            Integer integer = Integer.valueOf(equipmentIds[i]);
            List<Integer> epids = areaEquipmentService.findCaptureById(integer);
            alleqids.addAll(epids);
        }
        return alleqids;
    }

    /**
     * 删除布控任务和布控设备之间的关系
     *
     * @param deployId 布控任务id
     */
    private void removeDeploysByDeploy(int deployId) {
        SyDeployEquipmentExample syDeployEquipmentExample = new SyDeployEquipmentExample();
        SyDeployEquipmentExample.Criteria criteria = syDeployEquipmentExample.createCriteria();
        criteria.andIsDeleteEqualTo(0);
        criteria.andDidEqualTo(deployId);
        List<SyDeployEquipment> syDeployEquipments = syDeployEquipmentMapper.selectByExample(syDeployEquipmentExample);
        for (SyDeployEquipment syDeployEquipment : syDeployEquipments) {
            syDeployEquipment.setIsDelete(1);
            syDeployEquipmentMapper.updateByPrimaryKeySelective(syDeployEquipment);
            findDeploysByEquipmentId(deployId);
        }
    }

    /**
     * 添加布控任务和布控设备之间的关系
     *
     * @param deployId 布控任务id
     */
    private void addDeploysByDeploy(int deployId) {
        SyDeployEquipmentExample syDeployEquipmentExample = new SyDeployEquipmentExample();
        SyDeployEquipmentExample.Criteria criteria = syDeployEquipmentExample.createCriteria();
        criteria.andDidEqualTo(deployId);
        List<SyDeployEquipment> syDeployEquipments = syDeployEquipmentMapper.selectByExample(syDeployEquipmentExample);
        for (SyDeployEquipment syDeployEquipment : syDeployEquipments) {
            syDeployEquipment.setIsDelete(0);
            syDeployEquipmentMapper.updateByPrimaryKeySelective(syDeployEquipment);
            List<Integer> lists = (List<Integer>) redisTemplate.opsForHash().get(GlobalUtil.IPWITHDEPLOYLIST, syDeployEquipment.getEid());
            lists.add(deployId);
            redisTemplate.opsForHash().put(GlobalUtil.IPWITHDEPLOYLIST, syDeployEquipment.getEid(), lists);
        }
    }

    /**
     * 布控任务- 主列表查询
     *
     * @param monitorMainTableQueryInfo 请求参数
     * @return 分页结果集
     */
    @Override
    public PageResult monitorMainTableByPage(MonitorMainTableQueryInfo monitorMainTableQueryInfo) {
        Integer currentpage = monitorMainTableQueryInfo.getCurrentpage();
        Integer pagevolume = monitorMainTableQueryInfo.getPagevolume();
        Integer deployType = monitorMainTableQueryInfo.getDeployType();

        Long startTime = monitorMainTableQueryInfo.getStartTime();
        Long endTime = monitorMainTableQueryInfo.getEndTime();
        Criteria criteria = new Criteria();
        if (null != startTime && null != endTime) {
            criteria.and("picTime").gte(startTime).lte(endTime);
        } else if (null != startTime) {
            criteria.and("picTime").gte(startTime);
        } else if (null != endTime) {
            criteria.and("picTime").lte(endTime);
        }
        if (monitorMainTableQueryInfo.getCustomsPass() != null) {
            List<Integer> deviceIds = areaEquipmentService.findCaptureById(monitorMainTableQueryInfo.getCustomsPass());
            criteria.and("deviceId").in(deviceIds);
        }
        if (monitorMainTableQueryInfo.getPlateNumber() != null) {
            String plateNumber = monitorMainTableQueryInfo.getPlateNumber().replaceAll("\\?", "\\\\S").replaceAll("\\*", ".*");
            Pattern pattern = Pattern.compile(plateNumber, Pattern.CASE_INSENSITIVE);
            criteria.and("plateNum").regex(pattern);
        }
        criteria.and("alarmType").is(deployType);
        Query query = Query.query(criteria);
        query.fields().include("baseId");
        query.fields().include("alarmTime");
        query.fields().include("plateNum");
        query.fields().include("snapshotUrl");
        query.fields().include("equipmentName");
        if (0 != deployType) {
            query.fields().include("similarity");
            query.fields().include("libUrl");
            query.fields().include("libId");
        }

        List<PlateAlarmMsg> plateAlarmMsgs = mongoTemplate.find(query.skip((currentpage - 1) * pagevolume).limit(pagevolume)
                .with(Sort.by(Sort.Order.desc("picTime"))), PlateAlarmMsg.class);
        long total = mongoTemplate.count(query, PlateAlarmMsg.class);

        List<MonitorMainTableResultInfo> resultInfos = new ArrayList<>();

        Map<String, String> personIdRabbitMqVehicleIdMap = new HashMap<>();
        if (2 == deployType) {
            List<String> personIdList = plateAlarmMsgs.stream().map(PlateAlarmMsg::getBaseId).collect(Collectors.toList());
            Query findIdByPersonIdsQuery = new Query(Criteria.where("personid").in(personIdList));
            findIdByPersonIdsQuery.fields().include("id");
            findIdByPersonIdsQuery.fields().include("personid");
            List<RabbitMQVehicle> rabbitMqVehicles = mongoTemplate.find(findIdByPersonIdsQuery, RabbitMQVehicle.class);
            personIdRabbitMqVehicleIdMap = rabbitMqVehicles.stream().collect(Collectors.toMap(RabbitMQVehicle::getPersonid, RabbitMQVehicle::getId));
        }
        for (PlateAlarmMsg plateAlarmMsg : plateAlarmMsgs) {
            MonitorMainTableResultInfo monitorMainTableResultInfo = new MonitorMainTableResultInfo();
            if (null != plateAlarmMsg) {
                monitorMainTableResultInfo.setAddress(plateAlarmMsg.getEquipmentName());
                monitorMainTableResultInfo.setPlateNumber(plateAlarmMsg.getPlateNum());
                monitorMainTableResultInfo.setSnapshotUrl(plateAlarmMsg.getSnapshotUrl());
                monitorMainTableResultInfo.setPicTime(plateAlarmMsg.getAlarmTime());
                String id;
                if (2 == deployType) {
                    id = personIdRabbitMqVehicleIdMap.get(plateAlarmMsg.getBaseId());
                } else {
                    id = plateAlarmMsg.getBaseId();
                }
                monitorMainTableResultInfo.setId(id);
                if (0 != deployType) {
                    monitorMainTableResultInfo.setLibId(plateAlarmMsg.getLibId());
                    monitorMainTableResultInfo.setLibUrl(plateAlarmMsg.getLibUrl());
                    monitorMainTableResultInfo.setThreshold(plateAlarmMsg.getSimilarity());
                }
            }
            resultInfos.add(monitorMainTableResultInfo);
        }

        // 总页数
        long pageTotal = (total / pagevolume) + ((total % pagevolume > 0) ? 1 : 0);

        return new PageResult<>(pageTotal, resultInfos);
    }

    /**
     * 布控监听器
     *
     * @param rabbitMqVehicle 消息体
     */
    @Override
    public void rabbitMqMsgListener(RabbitMQVehicle rabbitMqVehicle) {
        int deviceId = rabbitMqVehicle.getDeviceid();
        // 设备id - 布控任务
        List<Integer> integers = (List<Integer>) redisTemplate.opsForHash().get(GlobalUtil.IPWITHDEPLOYLIST, deviceId);
        if (null != integers) {
            for (Integer deployId : integers) {
                // 获取布控类型
                Integer deployType = (Integer) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_TYPE, deployId);
                if (null != deployType) {
                    // 车牌布控
                    if (deployType == 0) {
                        rabbitMqMsgPlateNumberHandler(rabbitMqVehicle, deployId);
                    } else if (deployType == 1) {
                        // 车辆布控
                        rabbitMqMsgVehicleHandler(rabbitMqVehicle, deployId);
                    }
                }
            }
        }
    }

    @Override
    public void rabbitMqMsgListener(PersonMsg personMsg) {
        int deviceId = personMsg.getDeviceId();

        // 设备id - 布控任务
        List<Integer> integers = (List<Integer>) redisTemplate.opsForHash().get(GlobalUtil.IPWITHDEPLOYLIST, deviceId);
        if (null != integers) {
            for (Integer deployId : integers) {
                // 获取布控类型
                Integer deployType = (Integer) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_TYPE, deployId);
                if (null != deployType) {
                    if (deployType == 2) {
                        // 人像布控
                        rabbitMqPersonHandler(personMsg, deployId);
                    }
                }
            }
        }
    }

    /**
     * 根据布控库和布控类型查找所有布控id
     *
     * @param libId      布控库id
     * @param deployType 布控类型
     * @return 对应布控id
     */
    @Override
    public List<Integer> getDeployListByLibAndDeployType(int libId, int deployType) {
        SyDeployExample example = new SyDeployExample();
        SyDeployExample.Criteria criteria = example.createCriteria();
        criteria.andDeployTypeEqualTo(deployType);
        criteria.andIsDeleteEqualTo(0);
        List<SyDeploy> deployList = syDeployMapper.selectByExample(example);

        List<Integer> list = new ArrayList<>();
        if (deployList != null) {
            list = deployList.stream().filter(syDeploy -> Arrays.asList(syDeploy.getDeployLib().split(",")).contains(String.valueOf(libId)))
                    .map(SyDeploy::getId).collect(Collectors.toList());
        }
        return list;
    }

    /**
     * 车牌布控处理
     *
     * @param rabbitMqVehicle 消息体
     * @param deployId        布控任务id
     */
    private void rabbitMqMsgPlateNumberHandler(RabbitMQVehicle rabbitMqVehicle, Integer deployId) {
        int deviceId = rabbitMqVehicle.getDeviceid();
        String equipmentName = rabbitMqVehicle.getEquipmentName();
        String latitude = rabbitMqVehicle.getLatitude();
        String longitude = rabbitMqVehicle.getLongitude();
        String snapshotUrl = rabbitMqVehicle.getSnapshoturl();
        Long pictime = rabbitMqVehicle.getPictime();
        String vehiclePlateHphm = rabbitMqVehicle.getVehicle_plate_hphm();

        PlateAlarmMsg plateAlarmMsg = null;
        String deployLib = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_LIB, deployId);
        if (null != vehiclePlateHphm) {
            if (null != deployLib) {
                if (deployLib.contains(vehiclePlateHphm)) {
                    Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + GlobalUtil.DEPLOY_PLATE_NUM, vehiclePlateHphm);
                    if (status != null && 0 == status) {
                        plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)
                                .deviceId(deviceId).equipmentName(equipmentName).longitude(longitude).latitude(latitude)
                                .picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                                .plateNum(vehiclePlateHphm).alarmType(0).build();
                    }
                }
            }
        }
        plateAlarmMsgProducer(plateAlarmMsg);
    }

    /**
     * PlateAlarmMsg 消息发生器
     *
     * @param plateAlarmMsg 消息体
     */
    private void plateAlarmMsgProducer(PlateAlarmMsg plateAlarmMsg) {
        if (plateAlarmMsg != null) {
            PlateAlarmMsg save = mongoTemplate.save(plateAlarmMsg);
            String s = JSON.toJSONString(save);
            redisTemplate.opsForList().leftPush("ALARM", s);
        }
    }

    /**
     * 车辆布控处理
     *
     * @param rabbitMqVehicle 消息体
     * @param deployId        布控任务id
     */
    private void rabbitMqMsgVehicleHandler(RabbitMQVehicle rabbitMqVehicle, Integer deployId) {
        int deviceId = rabbitMqVehicle.getDeviceid();
        String equipmentName = rabbitMqVehicle.getEquipmentName();
        String latitude = rabbitMqVehicle.getLatitude();
        String longitude = rabbitMqVehicle.getLongitude();
        String snapshotUrl = rabbitMqVehicle.getSnapshoturl();
        Long pictime = rabbitMqVehicle.getPictime();
        double[] vehicleFeaFeature = rabbitMqVehicle.getVehicle_fea_feature();
        double distance1 = compareDistance.getDistance(vehicleFeaFeature);
        String vehiclePlateHphm = rabbitMqVehicle.getVehicle_plate_hphm();

        String deployLib = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_LIB, deployId);
        PlateAlarmMsg plateAlarmMsg = null;
        if (null != vehiclePlateHphm) {
            String vehicleIdStr = (String) redisTemplate.opsForHash().get("vehiclePlate", vehiclePlateHphm);
            if (vehicleIdStr != null) {
                Integer status = (Integer) redisTemplate.opsForHash().get(deployId + "|" + deployLib, vehicleIdStr);
                if (status == null || 0 == status) {
                    float[] vehicleIds = (float[]) redisTemplate.opsForHash().get("vehicleId", vehicleIdStr);
                    if (vehicleIds != null) {
                        double[] features = floatArrToDoubleArr(vehicleIds);
                        double distance = compareDistance.getDistance(features);
                        double v = compareDistance.simDistance(vehicleFeaFeature, distance1, features, distance);
                        v = v > 1 ? 1.00 : v;
                        String vehicleUrl = (String) redisTemplate.opsForHash().get("vehicleUrl", vehicleIdStr);
                        //将数据储存到mongo中
                        plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)
                                .deviceId(deviceId).equipmentName(equipmentName).longitude(longitude).latitude(latitude)
                                .libUrl(vehicleUrl).picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                                .plateNum(vehiclePlateHphm).alarmType(1).similarity(v).libId(vehicleIdStr).build();
                    }

                }
            }
        }
        if (plateAlarmMsg == null) {
            double max = 0;
            String key = "";
            // 获取工作中的所有车辆信息
            Set<String> openVehicleIds = new HashSet<>();
            if (deployLib != null) {
                for (String detailDeployLib : deployLib.split(",")) {
                    Map<String, Integer> vehicleIdStatusMap = redisTemplate.opsForHash().entries(deployId + "|" + detailDeployLib);
                    openVehicleIds.addAll(vehicleIdStatusMap.entrySet().stream().filter(entry -> 0 == entry.getValue())
                            .map(Map.Entry::getKey).collect(Collectors.toList()));
                }
            }
            // 判断是否需要报警
            for (String openVehicleId : openVehicleIds) {
                float[] floats = (float[]) redisTemplate.opsForHash().get("vehicleId", openVehicleId);
                if (floats == null) {
                    continue;
                }
                double[] featureArr = floatArrToDoubleArr(floats);
                double distance = compareDistance.getDistance(featureArr);
                double similar = compareDistance.simDistance(vehicleFeaFeature, distance1, featureArr, distance);
                if (max < similar) {
                    max = similar;
                    key = openVehicleId;
                    if (max >= 1) {
                        max = 1.00;
                        break;
                    }
                }
            }
            if (max >= (float) redisTemplate.opsForHash().get(GlobalUtil.DEPLOYTHRESLD, deployId)) {
                String vehicleUrl = (String) redisTemplate.opsForHash().get("vehicleUrl", key);
                plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(rabbitMqVehicle.getId()).deployId(deployId)
                        .deviceId(deviceId).equipmentName(equipmentName).longitude(longitude).latitude(latitude)
                        .libUrl(vehicleUrl).picTime(pictime).alarmTime(DateUtil.now()).snapshotUrl(snapshotUrl)
                        .alarmType(1).similarity(max).build();
            }
        }
        plateAlarmMsgProducer(plateAlarmMsg);
    }

    /**
     * float数组转 double数组
     *
     * @param floats float数组
     * @return double数组
     */
    private double[] floatArrToDoubleArr(float[] floats) {
        double[] result = new double[floats.length];
        for (int i = 0; i < floats.length; i++) {
            result[i] = floats[i];
        }
        return result;
    }

    /**
     * 人像布控处理
     *
     * @param personMsg 消息体
     * @param deployId  任务id
     */
    public void rabbitMqPersonHandler(PersonMsg personMsg, Integer deployId) {
        float[] fea = personMsg.getFea();
        int deviceId = personMsg.getDeviceId();
        String equipmentName = personMsg.getEquipmentName();
        String longitude = personMsg.getLongitude();
        String latitude = personMsg.getLatitude();
        String url = personMsg.getUrl();
        long captureTime = personMsg.getCaptureTime();
        String snapshotUrl = personMsg.getImageUrl();

        HashMap<String, Object> map = new HashMap<>(16);
        map.put("topN", 3);
        map.put("threshold", 0);
        map.put("threadNum", 2);
        map.put("feature", fea);
        String s = vehicleEngine.searchDataFromDeployDb(map);
        logger.info("searchDataFromDeployDb: " + s);
        ResponseParamPerson responseParamPerson = JSON.parseObject(s, ResponseParamPerson.class);
        String code = responseParamPerson.getCode();
        if ("0".equals(code)) {
            List<PersonIdAndScore> result = responseParamPerson.getResult();

            if (result != null && result.size() > 0) {
                int size = result.size();
                for (int i = 0; i < size; i++) {
                    String retrieveKey = result.get(i).getRetrieveKey();
                    logger.info("retrieveKey: " + retrieveKey);
                    String[] split = retrieveKey.split("&");
                    String key = deployId + "|" + split[1];
                    String deployLib = (String) redisTemplate.opsForHash().get(GlobalUtil.DEPLOY_LIB, deployId);
                    if (deployLib.contains(split[1])) {
                        Object staus = redisTemplate.opsForHash().get(key, Integer.parseInt(split[0]));
                        if (staus != null && Integer.parseInt(staus.toString()) == 0) {
                            float score = Float.parseFloat(result.get(i).getScore());
                            PlateAlarmMsg plateAlarmMsg = PlateAlarmMsg.builder().id(null).baseId(personMsg.getPersonId())
                                    .deployId(deployId)
                                    .deviceId(deviceId).equipmentName(equipmentName).longitude(longitude).latitude(latitude).libId(split[0])
                                    .libUrl(split[2]).picTime(captureTime).alarmTime(DateUtil.now()).snapshotUrl(url)
                                    .plateNum(null).alarmType(2).similarity(score).build();
                            logger.info("plateAlarmMsg: " + plateAlarmMsg.toString());
                            plateAlarmMsgProducer(plateAlarmMsg);
                            break;
                        } else if (staus != null && Integer.parseInt(staus.toString()) == 1) {
                            continue;
                        }
                    }
                }
            }
        }
    }

    /**
     * 获取底库的相关信息
     *
     * @param id 底库数据id
     * @return 底库数据
     */
    @Override
    public JSONObject getLibMsgById(String id) {
        JSONObject jsonObject = new JSONObject();
        try {

            List<UploadVehicleDbResult> uploadVehicleDbResults = mongoTemplate.find(Query.query(Criteria.where("id").is(id)), UploadVehicleDbResult.class);
            RabbitMQInfo rabbitMQInfo = null;
            if (uploadVehicleDbResults.size() > 0) {
                UploadVehicleDbResult uploadVehicleDbResult = uploadVehicleDbResults.get(0);
                rabbitMQInfo = uploadVehicleDbResultToRabbitInfo(uploadVehicleDbResult);
            }

            if (rabbitMQInfo != null) {
                jsonObject.put("code", 200);
                jsonObject.put("message", "success");
                jsonObject.put("data", rabbitMQInfo);
            } else {
                jsonObject.put("code", 201);
                jsonObject.put("message", "没有符合要求的数据");
                jsonObject.put("data", rabbitMQInfo);
            }
        } catch (Exception e) {
            jsonObject.put("code", 202);
            jsonObject.put("message", "请检查数据准确性");
            jsonObject.put("data", "");
            e.printStackTrace();
        }
        return jsonObject;
    }

    private RabbitMQInfo uploadVehicleDbResultToRabbitInfo(UploadVehicleDbResult uploadVehicleDbResult) {
        final String nullStatus = " ";
        RabbitMQInfo rabbitMQInfo = new RabbitMQInfo();
        VehicleInfoParam vehicleInfoParam = uploadVehicleDbResult.getVehicleInfoParam();

        //封装数据信息
        //增加车头的检测坐标值
        SyRectParam syRectParam = vehicleInfoParam.getVehicle_detect_res().getSyRectParam();
        if (syRectParam != null && null != uploadVehicleDbResult.getImageUrl()) {
            //获取抓拍图
            String snapshotBase64 = VehicleDetailsUtils.picToSnapshot(uploadVehicleDbResult.getImageUrl(),
                    syRectParam.getLeft(), syRectParam.getTop(), syRectParam.getWidth(), syRectParam.getHeight());
            rabbitMQInfo.setSnapshot(snapshotBase64);
        }

        // id; //车辆id
        rabbitMQInfo.setId(uploadVehicleDbResult.getId());
        // picurl;  //图片的路径
        rabbitMQInfo.setPicurl(uploadVehicleDbResult.getImageUrl());

        // vehicleplatetype;  //车牌类型
        int vehicleplatetype = vehicleInfoParam.getVehicle_plate_det_recg_res().getType();
        String vehiclePlateTypeName = RelationMappingUtil.getVehiclePlateType(vehicleplatetype);
        rabbitMQInfo.setVehicleplatetype(vehiclePlateTypeName);

        // vehicle_plate_numScore;  //号牌可信度
        double vehicle_plate_numScore = vehicleInfoParam.getVehicle_plate_det_recg_res().getNumScore();
        BigDecimal bg = new BigDecimal(vehicle_plate_numScore).setScale(2, RoundingMode.UP);
        float vehiclePlateNumScore = (float) bg.doubleValue();
        rabbitMQInfo.setVehicle_plate_numScore(vehiclePlateNumScore);

        // vehicle_color_index;  //车辆颜色;
        int vehicle_color_index = vehicleInfoParam.getVehicle_color_res().getIndex();
        String vehicleColor = RelationMappingUtil.getVehicleColor(vehicle_color_index);
        rabbitMQInfo.setVehicle_color_index(vehicleColor);
        // vehicle_special_type;   //特殊品类车类型
        int vehicle_special_type = vehicleInfoParam.getVehicle_special_res().getType();
        String vehicleSpecialType = RelationMappingUtil.getVehicleSpecialType(vehicle_special_type);
        rabbitMQInfo.setVehicle_special_type(vehicleSpecialType);


        // vehicleIllegalDriverPersonStatus;
        int vehicleIllegalDriverPersonStatus = vehicleInfoParam.getVehicle_illegal_det_res().getDriver().getPerson().getStatus();
        String vehicleIllegalStatus3;
        if (vehicleIllegalDriverPersonStatus == 1003) {
            vehicleIllegalStatus3 = "无人";
        } else if (vehicleIllegalDriverPersonStatus == 1004) {
            vehicleIllegalStatus3 = "有人";
        } else {
            vehicleIllegalStatus3 = "不确定有无人";
        }
        rabbitMQInfo.setVehicle_illegal_driver_person_status(vehicleIllegalStatus3);

        if ("有人".equals(vehicleIllegalStatus3)) {
            // vehicle_illegal_driver_smoke_status;
            int vehicle_illegal_driver_smoke_status = vehicleInfoParam.getVehicle_illegal_det_res().getDriver().getSmoke().getStatus();
            String vehicleIllegalStatus;
            if (vehicle_illegal_driver_smoke_status == 1000) {
                vehicleIllegalStatus = "吸烟";
            } else if (vehicle_illegal_driver_smoke_status == 1001) {
                vehicleIllegalStatus = "未吸烟";
            } else {
                vehicleIllegalStatus = "不确定吸烟";
            }
            rabbitMQInfo.setVehicle_illegal_driver_smoke_status(vehicleIllegalStatus);

            // vehicle_illegal_driver_belt_status;
            int vehicle_illegal_driver_belt_status = vehicleInfoParam.getVehicle_illegal_det_res().getDriver().getBelt().getStatus();
            String vehicleIllegalStatus1;
            if (vehicle_illegal_driver_belt_status == 1000) {
                vehicleIllegalStatus1 = "未系安全带";
            } else if (vehicle_illegal_driver_belt_status == 1001) {
                vehicleIllegalStatus1 = "系安全带";
            } else {
                vehicleIllegalStatus1 = "不确定系安全带";
            }
            rabbitMQInfo.setVehicle_illegal_driver_belt_status(vehicleIllegalStatus1);

            // vehicle_illegal_driver_phone_status;
            int vehicle_illegal_driver_phone_status = vehicleInfoParam.getVehicle_illegal_det_res().getDriver().getPhone().getStatus();
            String vehicleIllegalStatus2;
            if (vehicle_illegal_driver_phone_status == 1000) {
                vehicleIllegalStatus2 = "打电话";
            } else if (vehicle_illegal_driver_phone_status == 1001) {
                vehicleIllegalStatus2 = "未打电话";
            } else {
                vehicleIllegalStatus2 = "不确定打电话";
            }
            rabbitMQInfo.setVehicle_illegal_driver_phone_status(vehicleIllegalStatus2);
        } else {
            rabbitMQInfo.setVehicle_illegal_driver_smoke_status(nullStatus);
            rabbitMQInfo.setVehicle_illegal_driver_belt_status(nullStatus);
            rabbitMQInfo.setVehicle_illegal_driver_phone_status(nullStatus);
        }


        // vehicle_illegal_copilot_person_status;
        int vehicle_illegal_copilot_person_status = vehicleInfoParam.getVehicle_illegal_det_res().getCopilot().getPerson().getStatus();
        String vehicleIllegalStatus7;
        if (vehicle_illegal_copilot_person_status == 1003) {
            vehicleIllegalStatus7 = "无人";
        } else if (vehicle_illegal_copilot_person_status == 1004) {
            vehicleIllegalStatus7 = "有人";
        } else {
            vehicleIllegalStatus7 = "不确定有无人";
        }
        rabbitMQInfo.setVehicle_illegal_copilot_person_status(vehicleIllegalStatus7);

        if ("有人".equals(vehicleIllegalStatus7)) {

            // vehicle_illegal_copilot_smoke_status;
            int vehicle_illegal_copilot_smoke_status = vehicleInfoParam.getVehicle_illegal_det_res().getCopilot().getSmoke().getStatus();
            String vehicleIllegalStatus4;
            if (vehicle_illegal_copilot_smoke_status == 1000) {
                vehicleIllegalStatus4 = "吸烟";
            } else if (vehicle_illegal_copilot_smoke_status == 1001) {
                vehicleIllegalStatus4 = "未吸烟";
            } else {
                vehicleIllegalStatus4 = "不确定吸烟";
            }
            rabbitMQInfo.setVehicle_illegal_copilot_smoke_status(vehicleIllegalStatus4);

            // vehicle_illegal_copilot_belt_status;
            int vehicle_illegal_copilot_belt_status = vehicleInfoParam.getVehicle_illegal_det_res().getCopilot().getBelt().getStatus();
            String vehicleIllegalStatus5;
            if (vehicle_illegal_copilot_belt_status == 1000) {
                vehicleIllegalStatus5 = "未系安全带";
            } else if (vehicle_illegal_copilot_belt_status == 1001) {
                vehicleIllegalStatus5 = "系安全带";
            } else {
                vehicleIllegalStatus5 = "不确定系安全带";
            }
            rabbitMQInfo.setVehicle_illegal_copilot_belt_status(vehicleIllegalStatus5);

            // vehicle_illegal_copilot_phone_status;
            int vehicle_illegal_copilot_phone_status = vehicleInfoParam.getVehicle_illegal_det_res().getCopilot().getPhone().getStatus();
            String vehicleIllegalStatus6;
            if (vehicle_illegal_copilot_phone_status == 1000) {
                vehicleIllegalStatus6 = "打电话";
            } else if (vehicle_illegal_copilot_phone_status == 1001) {
                vehicleIllegalStatus6 = "未打电话";
            } else {
                vehicleIllegalStatus6 = "不确定打电话";
            }
            rabbitMQInfo.setVehicle_illegal_copilot_phone_status(vehicleIllegalStatus6);
        } else {
            rabbitMQInfo.setVehicle_illegal_copilot_smoke_status(nullStatus);
            rabbitMQInfo.setVehicle_illegal_copilot_belt_status(nullStatus);
            rabbitMQInfo.setVehicle_illegal_copilot_phone_status(nullStatus);
        }


        // vehicle_recg_type;  //车辆类型
        rabbitMQInfo.setVehicle_recg_type(vehicleInfoParam.getVehicle_recg_res().getVehicle_type());

        // vehicle_recg_freight_ton;  //吨数
        rabbitMQInfo.setVehicle_recg_freight_ton(vehicleInfoParam.getVehicle_recg_res().getFreight_ton());

        // vehicle_recg_name_score;   //品牌可信度
        double vehicle_recg_name_score = vehicleInfoParam.getVehicle_recg_res().getName_score();
        BigDecimal bigDecimal = new BigDecimal(vehicle_recg_name_score).setScale(2, RoundingMode.UP);
        float vehicleRecgNameScore = (float) bigDecimal.doubleValue();
        rabbitMQInfo.setVehicle_recg_name_score(vehicleRecgNameScore);

        // vehicle_plate_hphm;  //车辆号牌
        rabbitMQInfo.setVehicle_plate_hphm(uploadVehicleDbResult.getPlateNum());

        // vehicle_plate_status;
        double vehicle_plate_numScore1 = vehicleInfoParam.getVehicle_plate_det_recg_res().getNumScore();
        String vehiclePlateStatus;
        if (vehicle_plate_numScore1 == 0) {
            //无号牌
            vehiclePlateStatus = "无号牌";
        } else {
            VehiclePlateNumParam[] vehicle_plate_plateNumParams = vehicleInfoParam.getVehicle_plate_det_recg_res().getPlateNumParams();
            String chara = null;
            for (int i = 0; i < 7; i++) {
                VehiclePlateNumParam ppnp = vehicle_plate_plateNumParams[i];
                double maxprob = ppnp.getMaxprob();
                if (maxprob == 0) {
                    chara = "污损号牌";
                }
            }
            if (chara == null) {
                //有号牌
                vehiclePlateStatus = "完整号牌";
            } else {
                //污损号牌
                vehiclePlateStatus = "污损号牌";
            }
        }
        rabbitMQInfo.setVehicle_plate_status(vehiclePlateStatus);

        // clxh;
        StringBuffer sb = new StringBuffer();
        String vehicle_recg_brand = vehicleInfoParam.getVehicle_recg_res().getVehicle_brand();
        sb.append(vehicle_recg_brand);
        String vehicle_recg_subbrand = vehicleInfoParam.getVehicle_recg_res().getVehicle_subbrand();
        if (vehicle_recg_subbrand != null) {
            sb.append("-").append(vehicle_recg_subbrand);
        }
        String vehicle_recg_issue_year = vehicleInfoParam.getVehicle_recg_res().getVehicle_issue_year();
        if (vehicle_recg_issue_year != null) {
            sb.append("-").append(vehicle_recg_issue_year);
        }
        rabbitMQInfo.setClxh(sb.toString());

        return rabbitMQInfo;

    }
}