package com.zhgd.xmgl.call;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.xuyanwu.spring.file.storage.FileStorageService;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.zhgd.jeecg.common.api.vo.Result;
import com.zhgd.jeecg.common.execption.OpenPromptException;
import com.zhgd.redis.lock.RedisRepository;
import com.zhgd.xmgl.async.AsyncAiAnalyse;
import com.zhgd.xmgl.async.AsyncHikvision;
import com.zhgd.xmgl.base.*;
import com.zhgd.xmgl.call.entity.ChargeDeletionParam;
import com.zhgd.xmgl.constant.Cts;
import com.zhgd.xmgl.modules.basicdata.service.UploadFileService;
import com.zhgd.xmgl.modules.basicdata.service.impl.NoticeServiceImpl;
import com.zhgd.xmgl.modules.car.entity.CarCamera;
import com.zhgd.xmgl.modules.car.entity.CarInfo;
import com.zhgd.xmgl.modules.car.entity.CarPassRecord;
import com.zhgd.xmgl.modules.car.mapper.CarCameraMapper;
import com.zhgd.xmgl.modules.car.mapper.CarInfoMapper;
import com.zhgd.xmgl.modules.car.mapper.CarPassRecordMapper;
import com.zhgd.xmgl.modules.car.mapper.CarTypeMapper;
import com.zhgd.xmgl.modules.car.service.impl.CarInfoServiceImpl;
import com.zhgd.xmgl.modules.car.service.impl.CarPassRecordServiceImpl;
import com.zhgd.xmgl.modules.frontierprotectionnonet.entity.FrontierProtectionNoNetData;
import com.zhgd.xmgl.modules.frontierprotectionnonet.entity.FrontierProtectionNoNetDev;
import com.zhgd.xmgl.modules.frontierprotectionnonet.mapper.FrontierProtectionNoNetDevMapper;
import com.zhgd.xmgl.modules.frontierprotectionnonet.service.IFrontierProtectionNoNetDevService;
import com.zhgd.xmgl.modules.frontierprotectionnonet.service.impl.FrontierProtectionNoNetDataServiceImpl;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.vo.ProjectInfoExtVo;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.impl.ProjectServiceImpl;
import com.zhgd.xmgl.modules.video.entity.AiAnalyseHardWareAlarmRecord;
import com.zhgd.xmgl.modules.video.entity.AiAnalyseHardWareRecord;
import com.zhgd.xmgl.modules.video.mapper.AiAnalyseHardWareAlarmRecordMapper;
import com.zhgd.xmgl.modules.video.mapper.AiAnalyseHardWareRecordMapper;
import com.zhgd.xmgl.modules.video.service.IAiAnalyseHardWareAlarmRecordService;
import com.zhgd.xmgl.modules.video.service.IAiAnalyseHardWareRecordService;
import com.zhgd.xmgl.modules.worker.entity.*;
import com.zhgd.xmgl.modules.worker.mapper.EnterpriseInfoMapper;
import com.zhgd.xmgl.modules.worker.mapper.UfaceDevMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerAttendanceMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerInfoMapper;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendancePresenceService;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendanceService;
import com.zhgd.xmgl.modules.worker.service.impl.WorkerAttendanceServiceImpl;
import com.zhgd.xmgl.modules.xz.entity.XzHikvisionSync;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionCompareDataMapper;
import com.zhgd.xmgl.modules.xz.mapper.XzHikvisionSyncMapper;
import com.zhgd.xmgl.modules.xz.service.IXzHikvisionCompareDataService;
import com.zhgd.xmgl.modules.xz.service.impl.XzHikvisionSyncServiceImpl;
import com.zhgd.xmgl.security.entity.UserInfo;
import com.zhgd.xmgl.util.*;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang3.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import java.util.*;

@Slf4j
@RestController
@RequestMapping("/xmgl/hikvision")
public class HikvisionCall {
    private static final String FIXED_CAR_GROUP_NAME = "业主车辆";
    static String pageNo = "pageNo";
    @Autowired
    XzHikvisionSyncServiceImpl xzHikvisionSyncService;
    @Lazy
    @Autowired
    UploadFileService uploadFileService;
    @Lazy
    @Autowired
    ProjectServiceImpl projectService;
    @Lazy
    @Autowired
    FileStorageService fileStorageService;
    @Lazy
    @Autowired
    CarPassRecordServiceImpl carPassRecordService;
    @Lazy
    @Autowired
    HikvisionCall hikvisionCall;
    @Lazy
    @Autowired
    CarInfoServiceImpl carInfoService;
    @Lazy
    @Autowired
    private XzHikvisionCompareDataMapper xzHikvisionCompareDataMapper;
    @Lazy
    @Autowired
    private AiAnalyseHardWareAlarmRecordMapper aiAnalyseHardWareAlarmRecordMapper;
    @Lazy
    @Autowired
    private AsyncAiAnalyse asyncAiAnalyse;
    @Value("${upload.image.url.prefix:}")
    private String imageUrlPrefix;
    @Value("${basePath:}")
    private String basePath;
    @Autowired
    @Lazy
    private ProjectMapper projectMapper;
    @Autowired
    @Lazy
    private RedisRepository redisRepository;
    @Autowired
    @Lazy
    private EnterpriseInfoMapper enterpriseInfoMapper;
    @Autowired
    @Lazy
    private NoticeServiceImpl noticeService;
    @Autowired
    @Lazy
    private IWorkerAttendanceService workerAttendanceService;
    @Autowired
    @Lazy
    private WorkerAttendanceMapper workerAttendanceMapper;
    @Autowired
    @Lazy
    private IWorkerAttendancePresenceService workerAttendancePresenceService;
    @Autowired
    @Lazy
    private WorkerInfoMapper workerInfoMapper;
    @Autowired
    @Lazy
    private CarCameraMapper carCameraMapper;
    @Autowired
    @Lazy
    private CarPassRecordMapper carPassRecordMapper;
    @Autowired
    @Lazy
    private CarTypeMapper carTypeMapper;
    @Autowired
    @Lazy
    private CarInfoMapper carInfoMapper;
    @Autowired
    @Lazy
    private WorkerAttendanceServiceImpl workerAttendanceServiceImpl;
    @Autowired
    private UfaceDevMapper ufaceDevMapper;
    @Autowired
    private XzHikvisionSyncMapper xzHikvisionSyncMapper;

    @Autowired
    private IAiAnalyseHardWareRecordService aiAnalyseHardWareRecordService;

    @Autowired
    private IFrontierProtectionNoNetDevService frontierProtectionNoNetDevService;

    @Lazy
    @Autowired
    private IAiAnalyseHardWareAlarmRecordService aiAnalyseHardWareAlarmRecordService;
    @Lazy
    @Autowired
    private AiAnalyseHardWareRecordMapper aiAnalyseHardWareRecordMapper;
    @Lazy
    @Autowired
    private FrontierProtectionNoNetDevMapper frontierProtectionNoNetDevMapper;
    @Lazy
    @Autowired
    private FrontierProtectionNoNetDataServiceImpl frontierProtectionNoNetDataService;

    @Lazy
    @Autowired
    private IXzHikvisionCompareDataService xzHikvisionCompareDataService;


    /**
     * 获取图片
     *
     * @param rq
     * @param artemisConfigHost
     * @param artemisConfigAppKey
     * @param artemisConfigAppSecret
     * @return
     */
    public static String getHikvisionEventsPicture(HikvisionEventsPictureRq rq, String artemisConfigHost, String
            artemisConfigAppKey, String artemisConfigAppSecret) throws Exception {
        if (StrUtil.isBlank(rq.getPicUri()) || StrUtil.isBlank(rq.getSvrIndexCode())) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/video/v1/events/picture";
        String host = "https://" + artemisConfigHost;
        String body = JSONObject.toJSONString(rq);
        String rs = HikvisionUtil.doPost(host, path, body, null, artemisConfigAppKey, artemisConfigAppSecret);
        JSONObject rsJo = JSONObject.parseObject(rs);
        String code = rsJo.getString("code");
        if (Objects.equals(code, "0")) {
            return rsJo.getJSONObject("data").getString("picUrl");
        }
        return null;
    }

    @ApiOperation(value = "海康事件回调", notes = "海康事件回调", httpMethod = "POST")
    @PostMapping(value = "/eventCallback")
    public Result eventCallback(@ApiIgnore @RequestBody JSONObject jsonObject) {
        log.info("海康事件回调:{}", JSON.toJSONString(jsonObject));
        String method = jsonObject.getString("method");
        if (Objects.equals(method, "OnEventNotify")) {
            JSONObject paramsJo = jsonObject.getJSONObject("params");
            String ability = paramsJo.getString("ability");
            if (Objects.equals(ability, "event_acs")) {
                log.info("人员通行记录事件");
                //人员通行记录
                JSONArray eventsJa = paramsJo.getJSONArray("events");
                if (eventsJa != null) {
                    for (int i = 0; i < eventsJa.size(); i++) {
                        JSONObject jo1 = eventsJa.getJSONObject(i);
                        JSONObject dataJo = jo1.getJSONObject("data");
                        String extEventPersonNo = dataJo.getString("ExtEventPersonNo");
                        WorkerInfo workerInfo = workerInfoMapper.selectById(extEventPersonNo);
                        if (workerInfo == null) {
                            log.info("未找到该人员信息,extEventPersonNo:{}", extEventPersonNo);
                            return Result.error("未找到该人员信息,extEventPersonNo:" + extEventPersonNo);
                        }
                        String happenTime = jo1.getString("happenTime");
                        String extEventCardNo = dataJo.getString("ExtEventCardNo");
                        String srcIndex = jo1.getString("srcIndex");
                        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
                        String idCard = workerInfo.getIdCard();
                        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
                            log.info("未配置，idCard:{},extEventCardNo:{}", idCard, extEventCardNo);
                            return Result.error("未配置，idCard:" + idCard + ",extEventCardNo:" + extEventCardNo);
                        }
                        QueryWrapper<UfaceDev> devQueryWrapper = new QueryWrapper<>();
                        devQueryWrapper.lambda().eq(UfaceDev::getDevSn, srcIndex).eq(UfaceDev::getProjectSn, workerInfo.getProjectSn());
                        UfaceDev ufaceDev = ufaceDevMapper.selectOne(devQueryWrapper);
                        if (ufaceDev == null) {
                            log.error("请先上传对应设备信息，idCard:{},devSN:{}", idCard, srcIndex);
                            return Result.error("请先上传对应设备信息，idCard:" + idCard + ",extEventCardNo:" + extEventCardNo);
                        }
                        String time = DateUtil.formatDateTime(DateUtil.parse(happenTime));
                        Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                .eq(WorkerAttendance::getCreateTime, time)
                        );
                        if (count != 0) {
                            continue;
                        }
                        int passType = workerAttendanceServiceImpl.getPassType(ufaceDev, time);
                        hikvisionCall.saveEventCallbackAttendanceAsync(dataJo, workerInfo, srcIndex, project, idCard, time, passType);
                    }
                }
            } else if (Objects.equals(ability, "event_pms")) {
                log.info("车辆出入场事件");
                //车辆入场压线（放行）、出场压线（放行）
                JSONArray eventsJa = paramsJo.getJSONArray("events");
                if (eventsJa != null) {
                    for (int i = 0; i < eventsJa.size(); i++) {
                        JSONObject jo1 = eventsJa.getJSONObject(i);
                        JSONObject dataJo = jo1.getJSONObject("data");
                        Integer status = jo1.getInteger("status");
                        String srcIndex = jo1.getString("srcIndex");
                        Long eventType = jo1.getLong("eventType");
                        String plateNo = dataJo.getString("plateNo");
                        if (!Objects.equals(status, 5)) {
                            log.info("status!=5没有图片的不记录,cameraId:{}，plateNo：{}", srcIndex, plateNo);
                            continue;
                        }
                        CarCamera carCamera = carCameraMapper.selectOne(new LambdaQueryWrapper<CarCamera>()
                                .eq(CarCamera::getCameraId, srcIndex));
                        if (carCamera == null) {
                            log.info("海康回调车辆相机设备不存在：CameraId:{}", srcIndex);
                            return Result.error("海康回调车辆相机设备不存在：CameraId:" + srcIndex);
                        }
                        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carCamera.getProjectSn()));
                        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
                            String cameraId = carCamera.getCameraId();
                            log.info("海康事件车辆入场压线的project不存在,cameraId:{}", cameraId);
                            return Result.error("海康事件车辆入场压线的project不存在,cameraId:" + cameraId);
                        }

                        String time = DateUtil.formatDateTime(DateUtil.parse(dataJo.getString("time")));
                        if (eventType == 771760134 || eventType == 771760131) {
                            //出入场放行，不通过这个判断车辆是否通行
                            //CarPassRecord carPassRecord = carPassRecordMapper.getNewestlineBreakingEvent(plateNo, time);
                            //if (carPassRecord == null) {
                            //    log.info("海康回调出入场放行的压线不存在：plateNo:{}", plateNo);
                            //    return Result.error("");
                            //}
                            //carPassRecord.setIsOpen(1);
                            //carPassRecordMapper.updateById(carPassRecord);
                        } else if (eventType == 771760130 || eventType == 771760133) {
                            //压线事件
                            hikvisionCall.saveEventCallbackCarPassRecordAsync(dataJo, srcIndex, plateNo, carCamera, project, time);
                        }
                    }
                }
            } else if (Objects.equals(ability, "event_ias")) {
                log.info("红外对射预警事件========" + paramsJo);
                JSONArray eventsJa = paramsJo.getJSONArray("events");
                JSONObject dataEvent = eventsJa.getJSONObject(0);
                hikvisionCall.saveEventCallbackIasAsync(dataEvent);

            } else if (Objects.equals(ability, "")) {
                log.info("告警=======" + paramsJo);
                JSONArray eventsArray = paramsJo.getJSONArray("events");
                if (eventsArray.size() > 0) {
                    JSONObject dataEvent = eventsArray.getJSONObject(0);
                    JSONArray eventDetails = dataEvent.getJSONArray("eventDetails");
                    JSONObject eventDetail = eventDetails.getJSONObject(0);
                    ability = eventDetail.getString("ability");
                    if (Objects.equals(ability, "event_vss")) {
                        log.info("AI识别告警=======" + paramsJo);
                        String srcName = eventDetail.getString("srcName");//摄像机名称
                        String eventType = eventDetail.getString("eventType");//422000003
                        JSONObject data = eventDetail.getJSONObject("data");
                        String imageUrl = data.getString("url"); //海康AI图片地址
                        String deviceID = data.getString("deviceID"); //海康AI图片地址
                        AiAnalyseHardWareRecord dev = aiAnalyseHardWareRecordMapper.selectOne(new LambdaQueryWrapper<AiAnalyseHardWareRecord>()
                                .eq(AiAnalyseHardWareRecord::getHardwareId, deviceID));
                        if (dev == null) {
                            log.info("未查到AI识别告警设备，设备id：{}", deviceID);
                            return null;
                        }
                        hikvisionCall.saveEventCallbackAiAsync(dataEvent, srcName, eventType, imageUrl, deviceID, dev);
                    } else if (Objects.equals(ability, "event_ias")) {
                        log.info("临边防护告警=======" + paramsJo);
                        String srcName = eventDetail.getString("srcName");//srcName
                        String srcParentIndex = dataEvent.getString("srcParentIndex");
                        String happenTime = dataEvent.getString("happenTime");
                        String ds = srcName + "报警";
                        FrontierProtectionNoNetData data1 = new FrontierProtectionNoNetData();
                        data1.setDevSn(srcParentIndex);
                        data1.setAlarmTime(DateUtil.parse(happenTime));
                        data1.setDeviceStatus(1);
                        data1.setDetailStatus(ds);
                        data1.setDescription(ds);
                        frontierProtectionNoNetDataService.add(data1);
                    }
                }
            }
        }
        return Result.ok();
    }

    @Async("saveEventCallbackAiAsync")
    public void saveEventCallbackIasAsync(JSONObject dataEvent) {
        String devCode = dataEvent.getString("srcIndex");
        String happenTime = dataEvent.getString("happenTime");
        Date createTime = DateUtil.parse(happenTime);
        Integer count = frontierProtectionNoNetDataService.count(new LambdaQueryWrapper<FrontierProtectionNoNetData>()
                .eq(FrontierProtectionNoNetData::getCreateTime, createTime)
                .eq(FrontierProtectionNoNetData::getDevSn, devCode));
        if (count > 0) {
            log.info("重复的红外对射预警数据不保存，deviceID：{},createTime:{}", devCode, createTime);
            return;
        }
        FrontierProtectionNoNetDev frontierProtectionNoNetDev = frontierProtectionNoNetDevService
                .getOne(Wrappers.<FrontierProtectionNoNetDev>lambdaQuery().eq(FrontierProtectionNoNetDev::getDevSn, devCode));
        FrontierProtectionNoNetData frontierProtectionNoNetData = new FrontierProtectionNoNetData();
        frontierProtectionNoNetData.setDevSn(frontierProtectionNoNetDev.getDevSn());
        frontierProtectionNoNetData.setAlarmTime(createTime);
        frontierProtectionNoNetData.setLocation(frontierProtectionNoNetDev.getLocation());
        frontierProtectionNoNetData.setCreateTime(new Date());
        frontierProtectionNoNetData.setDevName(frontierProtectionNoNetDev.getDevName());
        frontierProtectionNoNetData.setDeviceStatus(1);
        frontierProtectionNoNetData.setDescription(dataEvent.getString("srcName") + "-" + dataEvent.getString("data"));
        frontierProtectionNoNetDataService.save(frontierProtectionNoNetData);
    }

    @Async("saveEventCallbackAiAsync")
    public void saveEventCallbackAiAsync(JSONObject dataEvent, String srcName, String eventType, String imageUrl, String deviceID, AiAnalyseHardWareRecord dev) {
        String happenTime = dataEvent.getString("happenTime");
        String createTime = DateUtil.formatDateTime(DateUtil.parse(happenTime));
        Integer count = aiAnalyseHardWareAlarmRecordMapper.selectCount(new LambdaQueryWrapper<AiAnalyseHardWareAlarmRecord>()
                .eq(AiAnalyseHardWareAlarmRecord::getCreateTime, createTime)
                .eq(AiAnalyseHardWareAlarmRecord::getHardwareId, deviceID)
        );
        if (count > 0) {
            log.info("重复的ai预警数据不保存，deviceID：{},createTime:{}", deviceID, createTime);
            return;
        }
        ProjectInfoExtVo projectInfoBySn = projectService.getProjectInfoBySn(dev.getProjectSn());
        AiAnalyseHardWareAlarmRecord aiAnalyseHardWareAlarmRecord = new AiAnalyseHardWareAlarmRecord();
        aiAnalyseHardWareAlarmRecord.setCreateTime(createTime);
        aiAnalyseHardWareAlarmRecord.setAlarmType(Integer.valueOf(eventType));
        aiAnalyseHardWareAlarmRecord.setHardwareId(deviceID);
        aiAnalyseHardWareAlarmRecord.setHardwareName(dev.getHardwareName());
        aiAnalyseHardWareAlarmRecord.setLocation(srcName);
        aiAnalyseHardWareAlarmRecord.setProjectSn(dev.getProjectSn());
        aiAnalyseHardWareAlarmRecord.setStatus(1);
        String relativePath = projectInfoBySn.getProjectName() + "/" + DateUtil.today();
        aiAnalyseHardWareAlarmRecord.setImageUrl(uploadFileService.uploadUrlReturnFileName(imageUrl, relativePath));
        aiAnalyseHardWareAlarmRecordMapper.insert(aiAnalyseHardWareAlarmRecord);
        //将数据通过MQTT转发到前台
        asyncAiAnalyse.sendAiAnalyse(aiAnalyseHardWareAlarmRecord, Cts.PROJECT_LEVEL_AND_CHILDREN);
    }

    @Async("saveEventCallbackCarPassRecord")
    public void saveEventCallbackCarPassRecordAsync(JSONObject dataJo, String srcIndex, String plateNo, CarCamera carCamera, Project project, String time) {
        CarPassRecord carPassRecord = new CarPassRecord();
        carPassRecord.setCarNumber(plateNo);
        carPassRecord.setType(getPassType(carCamera.getPassType()));
        carPassRecord.setPassTime(time);
        LambdaQueryWrapper<CarPassRecord> queryWrapper = new LambdaQueryWrapper<CarPassRecord>()
                .eq(CarPassRecord::getCarNumber, plateNo)
                .eq(CarPassRecord::getPassTime, time);
        Integer count = carPassRecordMapper.selectCount(queryWrapper);
        if (count != 0) {
            log.info("重复的车辆通行的数据不保存，plateNo：{},time:{}", plateNo, time);
            return;
        }
        try {
            //车牌
            JSONObject picUrlJo = dataJo.getJSONObject("picUrl");
            String svrIndex = dataJo.getString("svrIndex");
            String vehiclePicUrl = picUrlJo.getString("vehiclePicUrl");
            String platePicUrl = picUrlJo.getString("platePicUrl");
            if (StringUtils.isNotBlank(platePicUrl)) {
                carPassRecord.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, platePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
            }
            if (StringUtils.isNotBlank(vehiclePicUrl)) {
                carPassRecord.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(svrIndex, vehiclePicUrl), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
            }
        } catch (Exception e) {
            log.error("error：", e);
        }

        carPassRecord.setCarColor(getCarColor(dataJo.getInteger("plateColor")));
        carPassRecord.setLocation(carCamera.getCameraName());
        carPassRecord.setProjectSn(carCamera.getProjectSn());
        carPassRecord.setColor(getColor(dataJo.getInteger("vehicleColor")));
        carPassRecord.setCameraId(srcIndex);
        List<CarInfo> carInfos = carInfoMapper.selectList(new LambdaQueryWrapper<CarInfo>()
                .eq(CarInfo::getProjectSn, carCamera.getProjectSn())
                .eq(CarInfo::getCarNumber, plateNo)
                .eq(CarInfo::getIsBlack, 0)
        );
        if (CollUtil.isNotEmpty(carInfos)) {
            carPassRecord.setIsOpen(1);
        } else {
            carPassRecord.setIsOpen(0);
        }
        carPassRecordMapper.insert(carPassRecord);
        //车进场后，意味着绑定的司机走过了人脸机，统计为在场人员。车辆出场后，在场人员随之减少
        if (carInfos.size() != 0 && carInfos.get(0) != null && StringUtils.isNotEmpty(carInfos.get(0).getDriverWorkerId())) {
            log.info("保存车辆绑定的司机的通行数据，车牌号：{}", carInfos.get(0).getCarNumber());
            carPassRecordService.saveDriverPassData(carPassRecord, carInfos.get(0));
        }
    }

    @Async("saveEventCallbackAttendance")
    public void saveEventCallbackAttendanceAsync(JSONObject dataJo, WorkerInfo workerInfo, String srcIndex, Project project, String idCard, String time, int passType) {
        HashMap<String, Object> map = new HashMap<>();
        map.put("passTime", time);
        map.put("idCard", idCard);
        map.put("attendanceNumber", workerInfo.getAttendanceNumber());
        map.put("direction", passType);
        map.put("passType", 2);
        map.put("projectCode", workerInfo.getProjectSn());
        map.put("devCode", srcIndex);
        Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                .eq(WorkerAttendance::getCreateTime, time)
                .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
        );
        if (count != 0) {
            log.info("重复的人员通行的数据不保存，idCard：{},time:{}", idCard, time);
            return;
        }
        try {
            String extEventPictureURL = dataJo.getString("ExtEventPictureURL");
            String svrIndexCode = dataJo.getString("svrIndexCode");
            HikvisionEventsPictureRq rq = new HikvisionEventsPictureRq();
            rq.setPicUri(extEventPictureURL);
            rq.setSvrIndexCode(svrIndexCode);
            map.put("faceUrl", saveToLocal(getHikvisionEventsPicture(rq, project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
        } catch (Exception e) {
            log.error("error：", e);
        }
        workerAttendanceService.saveExternalPassRecord(map);
    }

    @ApiOperation(value = "按事件类型订阅事件", notes = "按事件类型订阅事件", httpMethod = "POST")
    @PostMapping(value = "/subscribeEvent")
    public Result subscribeEvent(@ApiIgnore @RequestBody SubscribeEventQo qo) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/eventService/v1/eventSubscriptionByEventTypes";
        String host = "https://" + qo.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(qo), null, qo.getArtemisConfigAppKey(), qo.getArtemisConfigAppSecret());
        return Result.ok();
    }

    @ApiOperation(value = "服务挂了主动获取门禁点事件的人员通行记录", notes = "服务挂了主动获取门禁点事件的人员通行记录", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "projectSn", value = "项目sn", paramType = "body", required = false, dataType = "String"),
            @ApiImplicitParam(name = "startTime", value = "开始时间", paramType = "body", required = true, dataType = "String"),
            @ApiImplicitParam(name = "endTime", value = "结束时间", paramType = "body", required = true, dataType = "String"),
    })
    @PostMapping(value = "/getDoorEvents")
    public Result getDoorEvents(@ApiIgnore @RequestBody HashMap<String, Object> paramMap) {
        String startTime = MapUtils.getString(paramMap, "startTime");
        String endTime = MapUtils.getString(paramMap, "endTime");
        DateUtils.checkLegalDate19(startTime);
        DateUtils.checkLegalDate19(endTime);
        JSONObject param = new JSONObject();
        param.put("startTime", DateUtils.getISO8601Str(DateUtil.parse(startTime)));
        param.put("endTime", DateUtils.getISO8601Str(DateUtil.parse(endTime)));
        String projectSn = MapUtils.getString(paramMap, "projectSn");
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<Project>()
                .eq(Project::getSyncHikvision, 1);
        if (StringUtils.isNotBlank(projectSn)) {
            queryWrapper.eq(Project::getProjectSn, projectSn);
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        getDoorEventsAsync(startTime, endTime, param, projectSn, projects);
        return Result.ok("已在后台同步人员数据，请耐心等待！");
    }

    @Async("getDoorEvents")
    public void getDoorEventsAsync(String startTime, String endTime, JSONObject param, String projectSn, List<Project> projects) {
        for (Project project : projects) {
            List<UfaceDev> ufaceDevs = ufaceDevMapper.selectList(new LambdaQueryWrapper<UfaceDev>()
                    .eq(UfaceDev::getProjectSn, project.getProjectSn()));
            for (UfaceDev ufaceDev : ufaceDevs) {
                param.put("doorIndexCodes", Collections.singletonList(ufaceDev.getDevSn()));
                param.put(pageNo, 0);
                param.put("pageSize", 1000);
                Integer total = 0;
                JSONArray listJa = new JSONArray();
                do {
                    String rs = null;
                    param.put("pageNo", param.getIntValue("pageNo") + 1);
                    try {
                        rs = getDoorEventsForHttp(project, param);
                    } catch (Exception e) {
                        log.error("err:", e);
                        return;
                    }
                    JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
                    if (joData != null) {
                        total = joData.getInteger("total");
                        if (!Objects.equals(total, 0)) {
                            listJa = joData.getJSONArray("list");
                            for (int i = 0; i < listJa.size(); i++) {
                                JSONObject listJo = listJa.getJSONObject(i);
                                String eventTime = listJo.getString("eventTime");
                                String personId = listJo.getString("personId");
                                String personName = listJo.getString("personName");
                                String doorIndexCode = listJo.getString("doorIndexCode");
                                String picUri = listJo.getString("picUri");
                                String svrIndexCode = listJo.getString("svrIndexCode");
                                WorkerInfo workerInfo = workerInfoMapper.selectById(personId);
                                if (workerInfo == null) {
                                    log.error("未找到该人员信息,personName:{}", personName);
                                    continue;
                                }
                                HashMap<String, Object> map = new HashMap<>();
                                String time = DateUtil.formatDateTime(DateUtil.parse(eventTime));
                                map.put("passTime", time);
                                map.put("idCard", workerInfo.getIdCard());
                                map.put("attendanceNumber", workerInfo.getAttendanceNumber());
                                int passType = workerAttendanceServiceImpl.getPassType(ufaceDev, time);
                                map.put("direction", passType);
                                map.put("passType", 2);
                                map.put("projectCode", workerInfo.getProjectSn());
                                map.put("devCode", doorIndexCode);
                                Integer count = workerAttendanceMapper.selectCount(new LambdaQueryWrapper<WorkerAttendance>()
                                        .eq(WorkerAttendance::getCreateTime, time)
                                        .eq(WorkerAttendance::getPersonSn, workerInfo.getPersonSn())
                                );
                                if (count != 0) {
                                    log.info("重复的人员通行的数据不保存，idCard：{},time:{}", workerInfo.getIdCard(), time);
                                    return;
                                }
                                try {
                                    HikvisionEventsPictureRq rq = new HikvisionEventsPictureRq();
                                    rq.setPicUri(picUri);
                                    rq.setSvrIndexCode(svrIndexCode);
                                    map.put("faceUrl", saveToLocal(getHikvisionEventsPicture(rq, project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                } catch (Exception e) {
                                    log.error("主动获取人脸图片失败>", e);
                                }
                                workerAttendanceService.saveExternalPassRecord(map);
                            }
                        }
                    }
                } while (total > param.getInteger(pageNo) * 1000);
            }
            try {
                workerAttendancePresenceService.addNowAllWorkerAttendancePresence(projectSn);
            } catch (Exception e) {
                log.error("主动更新在场人员失败,projectSn:{},>", projectSn, e);
            }
        }
        log.info("服务挂了主动获取门禁点事件的人员通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
    }

    @ApiOperation(value = "服务挂了主动获取查询过车记录", notes = "服务挂了主动获取查询过车记录", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "projectSn", value = "项目sn", paramType = "body", required = false, dataType = "String"),
            @ApiImplicitParam(name = "startTime", value = "开始时间", paramType = "body", required = true, dataType = "String"),
            @ApiImplicitParam(name = "endTime", value = "结束时间", paramType = "body", required = true, dataType = "String"),
    })
    @PostMapping(value = "/getCrossRecords")
    public Result getCrossRecords(@ApiIgnore @RequestBody HashMap<String, Object> paramMap) {
        String startTime = MapUtils.getString(paramMap, "startTime");
        String endTime = MapUtils.getString(paramMap, "endTime");
        DateUtils.checkLegalDate19(startTime);
        DateUtils.checkLegalDate19(endTime);
        JSONObject param = new JSONObject();
        param.put("startTime", DateUtils.getISO8601Str(DateUtil.parse(startTime)));
        param.put("endTime", DateUtils.getISO8601Str(DateUtil.parse(endTime)));
        String projectSn = MapUtils.getString(paramMap, "projectSn");
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<Project>()
                .eq(Project::getSyncHikvision, 1);
        if (StringUtils.isNotBlank(projectSn)) {
            queryWrapper.eq(Project::getProjectSn, projectSn);
        }
        List<Project> projects = projectMapper.selectList(queryWrapper);
        if (CollUtil.isEmpty(projects)) {
            return Result.error("项目未配置海康同步功能");
        }
        hikvisionCall.getCrossRecordsAsync(startTime, endTime, param, projects);
        return Result.ok("已在后台同步车辆通行数据，请耐心等待！");
    }

    @Async("getCrossRecords")
    public void getCrossRecordsAsync(String startTime, String endTime, JSONObject param, List<Project> projects) {
        for (Project project : projects) {
            String projectParkCode = null;
            try {
                projectParkCode = HikvisionUtil.getProjectParkCode(project);
            } catch (Exception e) {
                log.error("err:", e);
                return;
            }
            if (StringUtils.isBlank(projectParkCode)) {
                continue;
            }
            param.put("parkSyscode", projectParkCode);
            Integer total = 0;
            JSONArray listJa = new JSONArray();
            param.put(pageNo, 0);
            do {
                String rs = null;
                param.put(pageNo, param.getIntValue(pageNo) + 1);
                try {
                    rs = getCrossRecordsForHttp(project, param);
                } catch (Exception e) {
                    log.error("err:", e);
                    return;
                }
                JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
                if (joData != null) {
                    total = joData.getInteger("total");
                    if (!Objects.equals(total, 0)) {
                        listJa = joData.getJSONArray("list");
                        for (int i = 0; i < listJa.size(); i++) {
                            JSONObject listJo = listJa.getJSONObject(i);
                            String plateNo = listJo.getString("plateNo");
                            String roadwaySyscode = listJo.getString("roadwaySyscode");
                            String aswSyscode = listJo.getString("aswSyscode");
                            String crossTime = listJo.getString("crossTime");
                            String time = DateUtil.formatDateTime(DateUtil.parse(crossTime));
                            String plateNoPicUri = listJo.getString("plateNoPicUri");
                            String vehiclePicUri = listJo.getString("vehiclePicUri");
                            CarCamera carCamera = carCameraMapper.selectOne(new LambdaQueryWrapper<CarCamera>()
                                    .eq(CarCamera::getCameraId, roadwaySyscode));
                            if (carCamera == null) {
                                log.info("海康车辆相机设备不存在：CameraId:{}", roadwaySyscode);
                                continue;
                            }
                            CarPassRecord entity = new CarPassRecord();
                            entity.setCarNumber(plateNo);
                            entity.setType(getPassType(carCamera.getPassType()));
                            entity.setPassTime(time);
                            LambdaQueryWrapper<CarPassRecord> queryWrapper = new LambdaQueryWrapper<CarPassRecord>()
                                    .eq(CarPassRecord::getCarNumber, plateNo)
                                    .eq(CarPassRecord::getPassTime, time);
                            Integer count = carPassRecordMapper.selectCount(queryWrapper);
                            if (count != 0) {
                                log.info("重复的车辆通行的数据不保存，plateNo：{},time:{}", plateNo, time);
                                return;
                            }
                            try {
                                //车牌
                                entity.setImageUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, plateNoPicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                                entity.setPanoramaUrl(saveToLocal(getHikvisionEventsPicture(new HikvisionEventsPictureRq(aswSyscode, vehiclePicUri), project.getArtemisConfigHost(), project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret())));
                            } catch (Exception e) {
                                log.error("error：", e);
                            }

                            entity.setCarColor(getCarColor(listJo.getInteger("plateColor")));
                            entity.setLocation(carCamera.getCameraName());
                            entity.setProjectSn(carCamera.getProjectSn());
                            entity.setColor(getColor(listJo.getInteger("vehicleColor")));
                            entity.setCameraId(roadwaySyscode);
                            List<CarInfo> carInfos = carInfoMapper.selectList(new LambdaQueryWrapper<CarInfo>()
                                    .eq(CarInfo::getProjectSn, carCamera.getProjectSn())
                                    .eq(CarInfo::getCarNumber, plateNo)
                                    .eq(CarInfo::getIsBlack, 0)
                            );
                            if (CollUtil.isNotEmpty(carInfos)) {
                                entity.setIsOpen(1);
                            } else {
                                entity.setIsOpen(0);
                            }
                            carPassRecordMapper.insert(entity);
                        }
                    }
                }
            } while (total > param.getInteger(pageNo) * 1000);
        }
        log.info("服务挂了主动获取车辆事件的车辆通行记录执行完成，startTime：{}，endTime：{}", startTime, endTime);
    }

    /**
     * 定时一分钟获取海康数据
     */
    @SchedulerLock(name = "getRecordForHikvision", lockAtMostFor = 1000 * 30, lockAtLeastFor = 1000 * 30)
    @Scheduled(cron = "0 */1 * * * ?")
    @RequestMapping("getRecordForHikvision")
    public void getRecordForHikvision() {
        String startTime = DateUtil.formatDateTime(DateUtil.offsetMinute(new Date(), -2));
        String endTime = DateUtil.formatDateTime(new Date());
        List<Project> projects = projectMapper.selectList(new LambdaQueryWrapper<Project>()
                .eq(Project::getSyncHikvision, 1));
        for (Project project : projects) {
            log.info("定时获取海康记录,{}", project.getProjectName());
            HashMap<String, Object> map = new HashMap<>();
            map.put("projectSn", project.getProjectSn());
            map.put("startTime", startTime);
            map.put("endTime", endTime);
            hikvisionCall.getDoorEventsAsync(map);
            hikvisionCall.getCrossRecordsAsync(map);
        }
    }

    @Async("getRecordForHikvisionTask")
    public void getDoorEventsAsync(HashMap<String, Object> paramMap) {
        getDoorEvents(paramMap);
    }

    @Async("getRecordForHikvisionTask")
    public void getCrossRecordsAsync(HashMap<String, Object> paramMap) {
        getCrossRecords(paramMap);
    }


    /**
     * 定时重试失败的记录
     */
    @SchedulerLock(name = "retrySyncHikvision", lockAtMostFor = 1000 * 30, lockAtLeastFor = 1000 * 30)
    @Scheduled(cron = "0 */10 * * * ?")
    @RequestMapping("retrySyncHikvision")
    public void retrySyncHikvision() throws Exception {
        HashMap<String, Object> newListMap = new HashMap<>();
        newListMap.put("isSuccess", 0);
        newListMap.put("createDateBegin", DateUtil.formatDateTime(DateUtil.offsetHour(new Date(), -1)));
        List<XzHikvisionSync> newestList = xzHikvisionSyncService.getNewestList(newListMap);
        for (XzHikvisionSync xzHikvisionSync : newestList) {
            log.info("海康同步的定时重试失败的记录，id:{}", xzHikvisionSync.getId());
            HashMap<String, Object> retryMap = new HashMap<>();
            retryMap.put("id", xzHikvisionSync.getId());
            try {
                xzHikvisionSyncService.retry(retryMap);
            } catch (Exception e) {
                log.error("海康同步的定时重试失败的记录:error:", e);
            }
        }
    }

    /**
     * 获取车辆颜色
     *
     * @param plateColor
     * @return
     */
    private String getColor(Integer plateColor) {
        if (plateColor == null) {
            return null;
        }
        switch (plateColor) {
            case 0:
                return "其他颜色";
            case 1:
                return "白色";
            case 2:
                return "银色";
            case 3:
                return "灰色";
            case 4:
                return "黑色";
            case 5:
                return "红色";
            case 6:
                return "深蓝色";
            case 7:
                return "蓝色";
            case 8:
                return "黄色";
            case 9:
                return "绿色";
            case 10:
                return "棕色";
            case 11:
                return "粉色";
            case 12:
                return "紫色";
            case 13:
                return "深灰";
            case 14:
                return "杏色";
            case 255:
                return "未识别的车辆颜色";
        }
        return null;
    }

    /**
     * 车牌颜色
     *
     * @param plateColor
     * @return
     */
    private String getCarColor(Integer plateColor) {
        if (plateColor == null) {
            return null;
        }
        switch (plateColor) {
            case 0:
                return "蓝色";
            case 1:
                return "黄色";
            case 2:
                return "白色";
            case 3:
                return "黑色";
            case 4:
                return "绿色";
            case 5:
                return "民航黑色";
            case 255:
                return "其他颜色";
        }
        return null;
    }

    private Integer getPassType(Integer passType) {
        if (passType == null) {
            return null;
        }
        //1进，2出
        switch (passType) {
            case 1:
                return 0;
            case 2:
                return 1;
        }
        return null;
    }

    /**
     * 添加人员
     *
     * @param workerInfo
     */
    public void addWorkerForHikvision(WorkerInfo workerInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        addWorkerFromHttp(workerInfo, project);
        addWorkerFace(workerInfo, project);
    }

    public void addWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
//        JSONObject wiJo = getWorkerInfoByCertificateNo(workerInfo, project);
//        if (wiJo != null) {
//            WorkerInfo deleteWorker = BeanUtil.toBean(workerInfo, WorkerInfo.class);
//            deleteWorker.setId(wiJo.getLong("personId"));
//            deleteWorkerFromHttp(deleteWorker, project);
//        }
        String rs = doAddWorkerFromHttp(workerInfo, project);
        sendNoticeAndSetStatusForWorker("添加人员到海康isc", rs, workerInfo, 1, 1);
    }

    public String doAddWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/person/single/add";
        String host = "https://" + project.getArtemisConfigHost();
        String body = getWorkerJson(workerInfo);
        String rs = HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        return rs;
    }

    private String getWorkerJson(WorkerInfo workerInfo) {
        JSONObject jsonBody = new JSONObject();
        jsonBody.put("personId", workerInfo.getId());
        jsonBody.put("personName", workerInfo.getWorkerName());
        jsonBody.put("gender", workerInfo.getSex());
        jsonBody.put("orgIndexCode", getOrgIndexCode(workerInfo));
        jsonBody.put("birthday", workerInfo.getBirthday());
        jsonBody.put("phoneNo", workerInfo.getPhoneNumber());
        jsonBody.put("email", workerInfo.getPersonMail());
        jsonBody.put("certificateType", "111");
        jsonBody.put("certificateNo", workerInfo.getIdCard());
        jsonBody.put("jobNo", workerInfo.getPersonSn());
        return jsonBody.toJSONString();
    }

    private String getOrgIndexCode(WorkerInfo workerInfo) {
        if (workerInfo == null) {
            return null;
        }
        if (Objects.equals(workerInfo.getPersonType(), 1)) {
            return String.valueOf(workerInfo.getTeamId());
        } else if (Objects.equals(workerInfo.getPersonType(), 2)) {
            return String.valueOf(workerInfo.getDepartmentId());
        } else if (Objects.equals(workerInfo.getPersonType(), 3)) {
            return String.valueOf(workerInfo.getProjectSn());
        }
        return null;
    }

    /**
     * 编辑人员
     *
     * @param workerInfo
     */
    public void editWorkerForHikvision(WorkerInfo workerInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        JSONObject wiJo = getWorkerInfoByPersonId(String.valueOf(workerInfo.getId()), project);
        if (wiJo != null) {
            editWorkerFromHttp(workerInfo, project);

            editWorkerFace(workerInfo, project);
        } else {
            addWorkerForHikvision(workerInfo);
        }
    }

    public void editWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
        String rs = doEditWorkerFromHttp(workerInfo, project);
        sendNoticeAndSetStatusForWorker("更新人员到海康isc", rs, workerInfo, 1, 2);
    }

    public String doEditWorkerFromHttp(WorkerInfo workerInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        String body = getWorkerJson(workerInfo);
        return HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 添加人脸
     *
     * @param workerInfo
     * @param project
     */
    public void addWorkerFace(WorkerInfo workerInfo, Project project) throws Exception {
        String fieldAcquisitionUrl = workerInfo.getFieldAcquisitionUrl();
        if (StringUtils.isNotBlank(fieldAcquisitionUrl)) {
            String rs = doAddWorkerFace(workerInfo, project);
            sendNoticeAndSetStatusForWorker("添加人员照片到海康isc", rs, workerInfo, 2, 1);
        }
    }

    public String doAddWorkerFace(WorkerInfo workerInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/face/single/add";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("personId", String.valueOf(workerInfo.getId()));
        jo.put("faceData", Base64Util.convertFileToBase64(PathUtil.reviseSlash(basePath + "/" + workerInfo.getFieldAcquisitionUrl())));
        return HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    public void sendNoticeAndSetStatusForCarInfo(String title, String rs, CarInfo carInfo, Integer type, Integer operate, Boolean setSuc, boolean isNotice) {
        String msg;
        if (setSuc == null) {
            setSuc = false;
            boolean callSuc = HikvisionUtil.isSuccess(rs);
            JSONObject jo = JSONObject.parseObject(rs);
            String code = jo.getString("code");
            if (callSuc) {
                Object data = jo.get("data");
                if (data instanceof JSONObject) {
                    JSONObject dataJo = jo.getJSONObject("data");
                    Optional<JSONArray> fOp = Optional.ofNullable(dataJo).map(o -> o.getJSONArray("failures"));
                    if (fOp.isPresent() && fOp.get().size() != 0) {
                        if ("0x00052102".equals(fOp.get().getJSONObject(0).getString("code"))) {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆绑定的人员在isc不存在";
                            title += "失败";
                        } else {
                            msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                            title += "失败";
                        }
                    } else {
                        msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                        title += "成功";
                        setSuc = true;
                    }
                } else {
                    msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                    title += "成功";
                    setSuc = true;
                }
            } else {
                if (Objects.equals(code, "0x00072202")) {
                    msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                    title += "成功";
                    setSuc = true;
                    isNotice = false;
                } else if (Objects.equals(code, "0x02e33900")) {
                    String msg1 = jo.getString("msg");
                    if (Objects.equals(msg1, "reservation record not existed or overdued!")) {
                        msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                        title += "成功";
                        setSuc = true;
                        isNotice = false;
                    } else if (Objects.equals(msg1, "Car reservation failed! The plateNo has reserved in the parking!")) {
                        msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆预约记录已存在";
                        title += "失败";
                    } else {
                        msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                        title += "失败";
                    }
                } else if (Objects.equals(code, "0x02e33400")) {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车辆属于黑名单内不能下发预约车";
                    title += "失败";
                } else if (Objects.equals(code, "0x00072003")) {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：车牌格式不正确！";
                    title += "失败";
                } else {
                    msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                    title += "失败";
                }
            }
        } else {
            if (setSuc) {
                msg = "同步成功，车牌号码：" + carInfo.getCarNumber();
                title += "成功";
            } else {
                msg = "同步失败，车牌号码：" + carInfo.getCarNumber() + "。失败原因：下发异常";
                title += "失败";
            }
        }

        if (setSuc) {
            updateSuccessStatusByNow(carInfo.getProjectSn(), carInfo.getId(), type, operate, AsyncHikvision.getSyncTime(), null);
        } else {
            updateFailStatusByNow(carInfo.getProjectSn(), carInfo.getId(), type, operate, AsyncHikvision.getSyncTime(), null);
        }
        if (isNotice) {
            if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
                noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, "24");
            } else if (carInfo.getUserIds() != null && carInfo.getUserIds().size() > 0) {
                for (String userId : carInfo.getUserIds()) {
                    noticeService.addUserNotice(Long.valueOf(userId), msg, title, "24");
                }
            } else if (carInfo.getCreateBy() != null) {
                noticeService.addUserNotice(carInfo.getCreateBy(), msg, title, "24");
            }
        }
    }

    private void sendNoticeForOrg(String title, String rs, String orgName) {
        if (StringUtils.isBlank(rs)) {
            return;
        }
        boolean success = HikvisionUtil.isSuccess(rs);
        String msg = "";
        String type = "25";
        if (success) {
            JSONObject jo = JSONObject.parseObject(rs);
            JSONObject dataJo = jo.getJSONObject("data");
            Optional<JSONArray> fOp = Optional.ofNullable(dataJo).map(o -> o.getJSONArray("failures"));
            if (fOp.isPresent() && fOp.get().size() != 0) {
                if ("0x00052102".equals(fOp.get().getJSONObject(0).getString("code"))) {
                    msg = "同步失败，组织名称：" + orgName + "。失败原因：上级组织不存在";
                    title += "失败";
                    success = false;
                } else {
                    msg = "同步失败，组织名称：" + orgName + "。失败原因：下发异常";
                    title += "失败";
                    success = false;
                }
            } else {
                msg = "同步成功，组织名称：" + orgName;
                title += "成功";
            }
        } else {
            msg = "同步失败，组织名称：" + orgName + "。失败原因：" + rs;
            title += "失败";
            success = false;
        }
        if (success) {
            xzHikvisionCompareDataService.compareRetrySuccess();
        } else {
            xzHikvisionCompareDataService.compareRetryFail();
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, type);
        }
    }

    private void sendNoticeAndSetStatusForWorker(String title, String rs, WorkerInfo workerInfo, int type, int operate) {
        boolean callSuc = HikvisionUtil.isSuccess(rs);
        String msg = "";
        String noticeType = "23";
        boolean success = false;
        if (callSuc) {
            success = true;
            msg = "同步成功，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard();
            title += "成功";
        } else {
            JSONObject jo = JSONObject.parseObject(rs);
            String code = jo.getString("code");
            if (Objects.equals(code, "0x00072002")) {
                String msg1 = jo.getString("msg");
                if (Objects.equals(msg1, "Please Change Picture,Picture Max Size Is Limit 200KB")) {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：人脸图片不能大于200KB";
                    title += "失败";
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += "失败";
                }
            } else if (Objects.equals(code, "0x00052301")) {
                String msg1 = jo.getString("msg");
                if (Objects.equals(msg1, "OrgIndexCode Not Exists")) {
                    String pN = "";
                    if (Objects.equals(workerInfo.getPersonType(), 1)) {
                        pN = "班组";
                    } else if (Objects.equals(workerInfo.getPersonType(), 2)) {
                        pN = "部门";
                    }
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：" + pN + "未同步成功";
                    title += "失败";
                } else if (Objects.equals(msg1, "PersonId Already In Db")) {
                    //成功
                    success = true;
                    msg = "同步成功，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard();
                    title += "成功";
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += "失败";
                }
            } else if (Objects.equals(code, "0x00072003")) {
                String msg1 = jo.getString("msg");
                if (Objects.equals(msg1, "The format of parameter phoneNo is not correct.")) {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：手机号码格式不正确";
                    title += "失败";
                } else {
                    msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                    title += "失败";
                }
            } else {
                msg = "同步失败，人员名称：" + workerInfo.getWorkerName() + "，身份证号：" + workerInfo.getIdCard() + "。失败原因：下发异常";
                title += "失败";
            }
        }
        if (success) {
            updateSuccessStatusByNow(workerInfo.getProjectSn(), workerInfo.getId(), type, operate, AsyncHikvision.getSyncTime(), null);
            xzHikvisionCompareDataService.compareRetrySuccess();
        } else {
            updateFailStatusByNow(workerInfo.getProjectSn(), workerInfo.getId(), type, operate, AsyncHikvision.getSyncTime(), null);
            xzHikvisionCompareDataService.compareRetryFail();
        }
        if (ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class) != null) {
            noticeService.addUserNotice(ThreadLocalUtil.getByKey(Cts.TL_AUTH_USER, UserInfo.class).getUserId(), msg, title, noticeType);
        }
    }

    public void updateAllFailStatusIfNullByNowForAuth(String projectSn, Long whoId, Integer bigType, Integer operate, Date now) {
        xzHikvisionSyncMapper.update(null, new LambdaUpdateWrapper<XzHikvisionSync>()
                .set(XzHikvisionSync::getIsSuccess, 0)
                .isNull(XzHikvisionSync::getIsSuccess)
                .eq(XzHikvisionSync::getType, 3)
                .eq(XzHikvisionSync::getOperate, operate)
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getCreateDate, now)
        );
        updateTotalStatus(projectSn, whoId, bigType, now);
    }

    public void updateAllFailStatusIfNullByNow(String projectSn, Long whoId, Integer bigType, Date now) {
        xzHikvisionSyncMapper.update(null, new LambdaUpdateWrapper<XzHikvisionSync>()
                .set(XzHikvisionSync::getIsSuccess, 0)
                .isNull(XzHikvisionSync::getIsSuccess)
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getCreateDate, now)
        );
        updateTotalStatus(projectSn, whoId, bigType, now);
    }

    public void updateFailStatusByNow(String projectSn, Long whoId, Integer type, Date now, String deviceSn) {
        updateFailStatusByNow(projectSn, whoId, type, null, now, deviceSn);
    }

    public void updateFailStatusByNow(String projectSn, Long whoId, Integer type, Integer operate, Date now, String deviceSn) {
        updateStatusByNow(projectSn, whoId, type, operate, now, deviceSn, false);
    }

    public void updateSuccessStatusByNow(String projectSn, Long whoId, Integer type, Date now, String deviceSn) {
        updateSuccessStatusByNow(projectSn, whoId, type, null, now, deviceSn);
    }

    public void updateSuccessStatusByNow(String projectSn, Long whoId, Integer type, Integer operate, Date now, String deviceSn) {
        updateStatusByNow(projectSn, whoId, type, operate, now, deviceSn, true);
    }

    private void updateStatusByNow(String projectSn, Long whoId, Integer type, Integer operate, Date now, String deviceSn, Boolean isSuccess) {
        LambdaQueryWrapper<XzHikvisionSync> queryWrapper = new LambdaQueryWrapper<XzHikvisionSync>()
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getType, type)
                .eq(XzHikvisionSync::getCreateDate, now)
                .eq(StringUtils.isNotBlank(deviceSn), XzHikvisionSync::getDeviceSn, deviceSn);
        if (operate != null) {
            if (operate == 3) {
                queryWrapper.eq(XzHikvisionSync::getOperate, operate);
            } else {
                queryWrapper.ne(XzHikvisionSync::getOperate, 3);
            }
        }
        XzHikvisionSync xzHikvisionSync = xzHikvisionSyncMapper.selectOne(queryWrapper);
        if (xzHikvisionSync == null) {
            return;
        }
        xzHikvisionSync.setIsSuccess(isSuccess ? 1 : 0);
        xzHikvisionSyncMapper.updateById(xzHikvisionSync);

        updateTotalStatus(projectSn, whoId, type, now);
    }

    public void updateTotalStatus(String projectSn, Long whoId, Integer bigType, Date now) {
        List<XzHikvisionSync> xzHikvisionSyncs = xzHikvisionSyncMapper.selectList(new LambdaQueryWrapper<XzHikvisionSync>()
                .eq(XzHikvisionSync::getProjectSn, projectSn)
                .eq(XzHikvisionSync::getWhoId, whoId)
                .eq(XzHikvisionSync::getCreateDate, now)
        );
        Integer sendSuccessStatus = null;
        if (CollUtil.isEmpty(xzHikvisionSyncs)) {
            sendSuccessStatus = null;
        } else if (xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> Objects.equals(xzHikvisionSync1.getIsSuccess(), 1))) {
            sendSuccessStatus = 1;
        } else if (xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> xzHikvisionSync1.getIsSuccess() == null)) {
            sendSuccessStatus = null;
        } else if (xzHikvisionSyncs.stream().allMatch(xzHikvisionSync1 -> xzHikvisionSync1.getIsSuccess() == null || Objects.equals(xzHikvisionSync1.getIsSuccess(), 0))) {
            sendSuccessStatus = 2;
        } else {
            sendSuccessStatus = 3;
        }
        if (bigType >= 4) {
            carInfoMapper.update(null, new LambdaUpdateWrapper<CarInfo>()
                    .eq(CarInfo::getId, whoId)
                    .set(CarInfo::getSendSuccessStatus, sendSuccessStatus)
            );
        } else {
            workerInfoMapper.update(null, new LambdaUpdateWrapper<WorkerInfo>()
                    .eq(WorkerInfo::getId, whoId)
                    .set(WorkerInfo::getSendSuccessStatus, sendSuccessStatus)
            );
        }
    }

    /**
     * 编辑人脸
     *
     * @param workerInfo
     * @param project
     */
    public void editWorkerFace(WorkerInfo workerInfo, Project project) throws Exception {
        ArrayList<String> workerFaceIds = getWorkerFaceIds(String.valueOf(workerInfo.getId()), project);
        if (CollUtil.isNotEmpty(workerFaceIds)) {
            String workerFaceId = workerFaceIds.get(0);
            final String ARTEMIS_PATH = "/artemis";
            final String path = ARTEMIS_PATH + "/api/resource/v1/face/single/update";
            String host = "https://" + project.getArtemisConfigHost();
            JSONObject jo = new JSONObject();
            jo.put("faceId", workerFaceId);
            jo.put("faceData", Base64Util.convertFileToBase64(PathUtil.reviseSlash(basePath + "/" + workerInfo.getFieldAcquisitionUrl())));
            String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
            sendNoticeAndSetStatusForWorker("更新人员照片到海康isc", rs, workerInfo, 2, 2);
        } else {
            addWorkerFace(workerInfo, project);
        }
    }

    /**
     * 删除人员
     *
     * @param uniqueId
     * @param workerInfo
     */
    public void deleteWorkerForHikvision(String uniqueId, WorkerInfo workerInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteWorkerFace(uniqueId, workerInfo, project);

        deleteWorkerFromHttp(uniqueId, workerInfo, project);
    }

    public void deleteWorkerFromHttp(String uniqueId, WorkerInfo workerInfo, Project project) throws Exception {
        String rs = HikvisionUtil.deleteWorkerById(uniqueId, project).toJSONString();
        sendNoticeAndSetStatusForWorker("删除人员到海康isc", rs, workerInfo, 1, 3);
    }

    public void deleteWorkerFace(String uniqueId, WorkerInfo workerInfo, Project project) throws Exception {
        ArrayList<String> workerFaceIds = getWorkerFaceIds(uniqueId, project);
        if (CollUtil.isNotEmpty(workerFaceIds)) {
            for (String workerFaceId : workerFaceIds) {
                JSONObject rsJo = HikvisionUtil.deleteWorkerFace(project, workerFaceId);
                sendNoticeAndSetStatusForWorker("删除人员图片到海康isc", rsJo.toJSONString(), workerInfo, 2, 3);
            }
        }
    }

    /**
     * 获取人员人脸id列表
     *
     * @param uniqueId
     * @param project
     * @return
     */
    private ArrayList<String> getWorkerFaceIds(String uniqueId, Project project) throws Exception {
        JSONObject joData = getWorkerInfoByPersonId(uniqueId, project);
        ArrayList<String> ids = new ArrayList<>();
        if (joData != null) {
            JSONArray ppJa = joData.getJSONArray("personPhoto");
            if (ppJa != null) {
                for (int j = 0; j < ppJa.size(); j++) {
                    JSONObject jo1 = ppJa.getJSONObject(j);
                    ids.add(jo1.getString("personPhotoIndexCode"));
                }
            }
        }
        return ids;
    }

    /**
     * 获取单个劳务人员信息，根据人员id
     *
     * @param uniqueId
     * @param project
     * @return
     */
    private JSONObject getWorkerInfoByPersonId(String uniqueId, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/condition/personInfo";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("paramName", "personId");
        jo.put("paramValue", Arrays.asList(uniqueId));
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
        Integer total = joData.getInteger("total");
        if (Objects.equals(total, 1)) {
            JSONArray jsonArray = joData.getJSONArray("list");
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                return jsonObject;
            }
        }
        return null;
    }

    /**
     * 获取单个劳务人员信息，根据人员身份证
     *
     * @param workerInfo
     * @param project
     * @return
     */
    private JSONObject getWorkerInfoByCertificateNo(WorkerInfo workerInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/person/condition/personInfo";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("paramName", "certificateNo");
        jo.put("paramValue", Arrays.asList(String.valueOf(workerInfo.getIdCard())));
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        JSONObject joData = HikvisionUtil.getJSONObjectData(rs);
        Integer total = joData.getInteger("total");
        if (Objects.equals(total, 1)) {
            JSONArray jsonArray = joData.getJSONArray("list");
            for (int i = 0; i < jsonArray.size(); i++) {
                JSONObject jsonObject = jsonArray.getJSONObject(i);
                return jsonObject;
            }
        }
        return null;
    }

    /**
     * 保存车辆
     *
     * @param carInfo
     */
    public void saveCarInfoFromHikvision(CarInfo carInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        if (carInfo.getIsBlack() == 0) {
            handleAlarmCar(project, carInfo);
        }
        cancelCharge(project, carInfo);
        if (Objects.equals(carInfo.getCarModuleType(), 1)) {
            //删除预约车辆
            deleteReservationCarFromHttp(carInfo, project, true);
            saveFixedCar(carInfo, project);
            saveBindCategory(carInfo, project);
        } else if (Objects.equals(carInfo.getCarModuleType(), 2) || Objects.equals(carInfo.getCarModuleType(), 3)) {
            unbindCar(project, carInfo);
            deleteFixedCarForHikvision(carInfo, project);
            saveReservationCar(project, carInfo);
        }
    }

    /**
     * 车辆取消布防/布防
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    public void handleAlarmCar(Project project, CarInfo carInfo) {
        try {
            JSONObject jo = new JSONObject();
            jo.put("searchKey", carInfo.getCarNumber());
            jo.put("pageNo", 1);
            jo.put("pageSize", 1);
            JSONObject joRs = queryAlarmCarPage(project, jo);
            if (HikvisionUtil.isSuccess(joRs)) {
                JSONObject dataJo = HikvisionUtil.getJSONObjectData(joRs);
                JSONArray listJa = dataJo.getJSONArray("list");
                if (CollUtil.isEmpty(listJa)) {
                    if (carInfo.getIsBlack() == 1) {
                        JSONObject addJo = new JSONObject();
                        CarInfo c = carInfoService.queryById(String.valueOf(carInfo.getId()));
                        addJo.put("driver", c.getDriverWorkerName());
                        addJo.put("driverPhone", c.getDriverTelephone());
                        addJo.put("plateNo", carInfo.getCarNumber());
                        JSONObject rs = addAlarmCarForHttp(project, addJo);
                        sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", rs.toJSONString(), carInfo, 7, null, null, true);
                    } else {
                        sendNoticeAndSetStatusForCarInfo("车辆取消布防（取消黑名单）到海康isc", null, carInfo, 7, null, true, false);
                    }
                } else {
                    if (carInfo.getIsBlack() == 1) {
                        sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", null, carInfo, 7, null, true, true);
                    } else {
                        JSONObject joOne = listJa.getJSONObject(0);
                        String alarmSyscode = joOne.getString("alarmSyscode");
                        JSONObject deleteJo = new JSONObject();
                        deleteJo.put("alarmSyscodes", alarmSyscode);
                        JSONObject rs = this.deletionAlarmCarForHttp(project, deleteJo);
                        sendNoticeAndSetStatusForCarInfo("车辆取消布防（取消黑名单）到海康isc", rs.toJSONString(), carInfo, 7, null, null, true);
                    }
                }
            } else {
                failAlarmNotice(carInfo);
            }
        } catch (Exception e) {
            failAlarmNotice(carInfo);
        }
    }

    private void failAlarmNotice(CarInfo carInfo) {
        if (carInfo.getIsBlack() == 1) {
            sendNoticeAndSetStatusForCarInfo("车辆添加黑名单到海康isc", new JSONObject().toJSONString(), carInfo, 7, null, false, true);
        } else {
            sendNoticeAndSetStatusForCarInfo("车辆取消黑名单到海康isc", new JSONObject().toJSONString(), carInfo, 7, null, false, true);
        }
    }

    /**
     * 车辆布防
     *
     * @param project
     * @return
     */
    public JSONObject addAlarmCarForHttp(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/alarmCar/addition";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 取消车辆布防
     *
     * @param project
     * @return
     */
    public JSONObject deletionAlarmCarForHttp(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/alarmCar/deletion";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 查询布防车辆
     *
     * @param project
     * @return
     */
    public JSONObject queryAlarmCarPage(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/alarmCar/page";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 保存固定车
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void saveFixedCar(CarInfo carInfo, Project project) throws Exception {
        //根据车牌号删除车辆
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carInfo.getCarNumber(), project);
        if (oldCarInfo != null) {
            log.info("查询到海康车辆，车牌号：{}", carInfo.getCarNumber());
            carInfo.setHikvisionVehicleId(oldCarInfo.getString("vehicleId"));
            editCarInfoFromHttp(carInfo, project);
        } else {
            log.info("未查询到海康车辆，车牌号：{}", carInfo.getCarNumber());
            //固定车
            addCarInfoFromHttp(carInfo, project);
        }
    }

    private String getRemoteCarIdByCarNumber(String carNumber, Project project) throws Exception {
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carNumber, project);
        return oldCarInfo == null ? null : oldCarInfo.getString("vehicleId");
    }


    /**
     * 保存绑定群组关系
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void saveBindCategory(CarInfo carInfo, Project project) throws Exception {
        bindCar(project, carInfo);
    }

    @NotNull
    private String getCategoryCode(Project project) throws Exception {
        //绑定固定的群组
        JSONArray ja = HikvisionUtil.getCategoryList(project);
        return getFixedCarGroupName(ja);
    }

    public void addCarInfoFromHttp(CarInfo carInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/vehicle/batch/add";
        String host = "https://" + project.getArtemisConfigHost();
        HikvisionCarInfo hikvisionCarInfo = getHikvisionCarInfo(carInfo);
        ArrayList<HikvisionCarInfo> list = new ArrayList<>();
        list.add(hikvisionCarInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(list), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("添加车辆白名单到海康isc", rs, carInfo, 4, 1, null, true);
    }

    private HikvisionCarInfo getHikvisionCarInfo(CarInfo carInfo) {
        HikvisionCarInfo hikvisionCarInfo = new HikvisionCarInfo();
        hikvisionCarInfo.setVehicleId(carInfo.getHikvisionVehicleId());
        hikvisionCarInfo.setPlateNo(carInfo.getCarNumber());
        String[] driverList = StringUtils.split(carInfo.getDriverWorkerId(), ",");
        if (driverList != null && driverList.length > 0) {
            hikvisionCarInfo.setPersonId(driverList[0]);
        }
        hikvisionCarInfo.setPlateType(null);
        hikvisionCarInfo.setPlateColor(getPlateColor(carInfo));
        hikvisionCarInfo.setVehicleType(getVehicleType(carInfo));
        hikvisionCarInfo.setVehicleColor(getVehicleColor(carInfo.getCarColor()));
        hikvisionCarInfo.setDescription(null);
        return hikvisionCarInfo;
    }

    private String getPlateColor(CarInfo carInfo) {
        String carColor = carInfo.getCarColor();
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "蓝色":
                return "0";
            case "黄色":
                return "1";
            case "白色":
                return "2";
            case "黑色":
                return "3";
            case "绿色":
                return "4";
            case "民航黑色":
                return "5";
            case "其他颜色":
                return "255";
        }
        return null;
    }

    private String getVehicleType(CarInfo carInfo) {
        String carTypeName = carInfoMapper.getCarTypeName(carInfo);
        switch (carTypeName) {
            case "其他车":
                return "0";
            case "小型车":
                return "1";
            case "大型车":
                return "2";
            case "摩托车":
                return "3";
        }
        return null;
    }

    private String getVehicleColor(String carColor) {
        if (StringUtils.isBlank(carColor)) {
            return null;
        }
        switch (carColor) {
            case "其他颜色":
                return "0";
            case "白色":
                return "1";
            case "银色":
                return "2";
            case "灰色":
                return "3";
            case "黑色":
                return "4";
            case "红色":
                return "5";
            case "深蓝色":
                return "6";
            case "蓝色":
                return "7";
            case "黄色":
                return "8";
            case "绿色":
                return "9";
            case "棕色":
                return "10";
            case "粉色":
                return "11";
            case "紫色":
                return "12";
            case "深灰":
                return "13";
            case "杏色":
                return "14";
            case "未识别的车辆颜色":
                return "255";
            default:
                return null;
        }
    }

    /**
     * 编辑车辆
     *
     * @param carInfo
     * @param old
     */
    public void editCarInfoForHikvision(CarInfo carInfo, CarInfo old) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        if (!Objects.equals(carInfo.getCarNumber(), old.getCarNumber())) {
            //删除旧的车辆数据
            deleteCarInfoForHikvision(old, false);
        }
        saveCarInfoFromHikvision(carInfo);
    }

    /**
     * 修改车辆
     *
     * @param carInfo
     * @param project
     * @throws Exception
     */
    private void editCarInfoFromHttp(CarInfo carInfo, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/vehicle/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        HikvisionCarInfo hikvisionCarInfo = getHikvisionCarInfo(carInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(hikvisionCarInfo), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("更新车辆白名单到海康isc", rs, carInfo, 4, 2, null, true);
    }

    /**
     * 解绑车辆群组
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void unbindCar(Project project, CarInfo carInfo) throws Exception {
        String categoryCode = getCategoryCode(project);
        bindOrNotCarCategory(project, 2, categoryCode, carInfo);
    }

    /**
     * 解绑车辆群组
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void bindCar(Project project, CarInfo carInfo) throws Exception {
        String categoryCode = getCategoryCode(project);
        bindOrNotCarCategory(project, 1, categoryCode, carInfo);
    }

    /**
     * 获取固定车的categoryCode
     *
     * @param ja
     */
    private String getFixedCarGroupName(JSONArray ja) {
        if (ja != null) {
            for (int i = 0; i < ja.size(); i++) {
                JSONObject jo = ja.getJSONObject(i);
                String categoryName = jo.getString("categoryName");
                if (Objects.equals(categoryName, FIXED_CAR_GROUP_NAME)) {
                    return jo.getString("categoryCode");
                }
            }
        }
        log.error("获取固定车的群组失败");
        throw new OpenPromptException("获取固定车的群组失败");
    }

    /**
     * 删除车辆
     *
     * @param carInfo
     * @param isSetBlack
     */
    public void deleteCarInfoForHikvision(CarInfo carInfo, boolean isSetBlack) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, carInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        cancelCharge(project, carInfo);
        unbindCar(project, carInfo);
        deleteFixedCarForHikvision(carInfo, project);
        deleteReservationCarFromHttp(carInfo, project, true);
        CarInfo c = new CarInfo();
        BeanUtil.copyProperties(carInfo, c);
        c.setIsBlack(isSetBlack ? 1 : 0);
        handleAlarmCar(project, c);
    }

    private void deleteFixedCarForHikvision(CarInfo carInfo, Project project) throws Exception {
        //根据车牌号删除车辆
        JSONObject oldCarInfo = searchCarInfoByCarNumberFromHttp(carInfo.getCarNumber(), project);
        if (oldCarInfo != null) {
            log.info("海康存在车辆，车牌号：{}", oldCarInfo.getString("plateNo"));
            String rs = deleteCarInfoByIdFromHttp(oldCarInfo.getString("vehicleId"), project);
            sendNoticeAndSetStatusForCarInfo("删除车辆白名单到海康isc", rs, carInfo, 4, 3, null, true);
        } else {
            sendNoticeAndSetStatusForCarInfo("删除车辆白名单到海康isc", null, carInfo, 4, 3, true, false);
        }
    }

    private JSONObject searchCarInfoByCarNumberFromHttp(String carNumber, Project project) throws Exception {
        long total = 0;
        JSONObject o1 = null;
        int pageNo = 0;
        do {
            JSONObject jo = HikvisionUtil.getFixCarListByCarNumber(carNumber, project, ++pageNo);
            if (HikvisionUtil.isSuccess(jo)) {
                JSONObject dataJo = HikvisionUtil.getJSONObjectData(jo);
                total = dataJo.getInteger("total");
                JSONArray listJa = dataJo.getJSONArray("list");
                Optional<Object> plateNoOpt = listJa.stream().filter(o -> {
                    JSONObject j = (JSONObject) o;
                    return carNumber.equals(j.getString("plateNo"));
                }).findFirst();
                if (plateNoOpt.isPresent()) {
                    o1 = (JSONObject) plateNoOpt.get();
                }
            } else {
                return null;
            }
        } while (o1 == null && total > pageNo * 1000L);
        return o1;
    }

    private String deleteCarInfoByIdFromHttp(String carId, Project project) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/vehicle/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        ArrayList<String> list = new ArrayList<>();
        list.add(carId);
        jo.put("vehicleIds", list);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        return rs;
    }

    /**
     * 取消车位预约
     *
     * @param carInfo
     * @param project
     * @param isNotice
     */
    private void deleteReservationCarFromHttp(CarInfo carInfo, Project project, boolean isNotice) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/parkingSpace/reservations/deletion";
        String host = "https://" + project.getArtemisConfigHost();
        JSONArray reservationCarInfoList = HikvisionUtil.getReservationCarInfoDataList(carInfo.getCarNumber(), project);
        if (CollUtil.isNotEmpty(reservationCarInfoList)) {
            for (int i = 0; i < reservationCarInfoList.size(); i++) {
                JSONObject jsonObject = reservationCarInfoList.getJSONObject(i);
                String reserveOrderNo = jsonObject.getString("reserveOrderNo");
                JSONObject jsonObject1 = new JSONObject();
                jsonObject1.put("reserveOrderNo", reserveOrderNo);
                String rs = HikvisionUtil.doPost(host, path, jsonObject1.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
                sendNoticeAndSetStatusForCarInfo("取消车位预约到海康isc", rs, carInfo, 6, 3, null, isNotice);
            }
        } else {
            sendNoticeAndSetStatusForCarInfo("取消车位预约到海康isc", null, carInfo, 6, 3, true, false);
        }
    }

    /**
     * 添加组织
     *
     * @param enterpriseInfo
     */
    public void addEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, enterpriseInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(enterpriseInfo);
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    private HikvisionOrganization getHikvisionOrganization(EnterpriseInfo enterpriseInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(enterpriseInfo.getId()));
        hikvisionOrganization.setOrgName(enterpriseInfo.getEnterpriseName());
        hikvisionOrganization.setParentIndexCode(enterpriseInfo.getProjectSn());
        return hikvisionOrganization;
    }

    /**
     * 更新组织
     *
     * @param enterpriseInfo
     */
    public void editEnterpriseInfoForHikvision(EnterpriseInfo enterpriseInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, enterpriseInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(enterpriseInfo);
        if (existOrg(project, String.valueOf(enterpriseInfo.getId()))) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }
    }

    /**
     * 删除组织
     *
     * @param enterpriseId
     * @param projectSn
     * @param enterpriseName
     */
    public void deleteEnterpriseInfoForHikvision(String enterpriseId, String projectSn, String enterpriseName) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, projectSn));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("indexCodes", Arrays.asList(enterpriseId));
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("删除组织到海康isc", rs, enterpriseName);
    }

    /**
     * 添加组织
     *
     * @param teamInfo
     */
    public void addTeamInfoForHikvision(TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(teamInfo);
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    private HikvisionOrganization getHikvisionOrganization(TeamInfo teamInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(teamInfo.getId()));
        hikvisionOrganization.setOrgName(teamInfo.getTeamName());
        hikvisionOrganization.setParentIndexCode(String.valueOf(teamInfo.getEnterpriseId()));
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param teamInfo
     */
    public void editTeamInfoForHikvision(TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(teamInfo);
        if (existOrg(project, String.valueOf(teamInfo.getId()))) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }
    }

    private void editOrgFromHttp(Project project, HikvisionOrganization hikvisionOrganization) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/single/update";
        String host = "https://" + project.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, JSONArray.toJSONString(hikvisionOrganization), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("更新组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    private void deleteOrgFromHttp(Project project, List<String> idList, String orgName) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/delete";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("indexCodes", idList);
        String rs = HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeForOrg("删除组织到海康isc", rs, orgName);
    }

    private void addOrgNoticeFromHttp(Project project, HikvisionOrganization hikvisionOrganization) throws Exception {
        String rs = addOrgFromHttp(project, hikvisionOrganization);
        sendNoticeForOrg("添加组织到海康isc", rs, hikvisionOrganization.getOrgName());
    }

    private String addOrgFromHttp(Project project, HikvisionOrganization hikvisionOrganization) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/batch/add";
        String host = "https://" + project.getArtemisConfigHost();
        ArrayList<HikvisionOrganization> list = new ArrayList<>();
        list.add(hikvisionOrganization);
        return HikvisionUtil.doPost(host, path, JSON.toJSONString(list), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 删除组织
     *
     * @param id
     * @param teamInfo
     */
    public void deleteTeamInfoForHikvision(String id, TeamInfo teamInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, teamInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteOrgFromHttp(project, Arrays.asList(id), teamInfo.getTeamName());
    }

    /**
     * 添加组织
     *
     * @param departmentInfo
     */
    public void addDepartmentInfoForHikvision(DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(departmentInfo);
        addOrgNoticeFromHttp(project, hikvisionOrganization);
    }

    private HikvisionOrganization getHikvisionOrganization(DepartmentInfo departmentInfo) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(String.valueOf(departmentInfo.getId()));
        hikvisionOrganization.setOrgName(departmentInfo.getDepartmentName());
        hikvisionOrganization.setParentIndexCode(String.valueOf(departmentInfo.getEnterpriseId()));
        return hikvisionOrganization;
    }

    /**
     * 编辑组织
     *
     * @param departmentInfo
     */
    public void editDepartmentInfoForHikvision(DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(departmentInfo);
        if (existOrg(project, String.valueOf(departmentInfo.getId()))) {
            editOrgFromHttp(project, hikvisionOrganization);
        } else {
            addOrgNoticeFromHttp(project, hikvisionOrganization);
        }

    }

    /**
     * 删除组织
     *
     * @param uniqueId
     * @param departmentInfo
     */
    public void deleteDepartmentInfoForHikvision(String uniqueId, DepartmentInfo departmentInfo) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, departmentInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        deleteOrgFromHttp(project, Arrays.asList(uniqueId), departmentInfo.getDepartmentName());
    }

    /**
     * 添加组织
     *
     * @param project
     */
    public void editProjectForHikvision(Project project) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        HikvisionOrganization hikvisionOrganization = getHikvisionOrganization(project);
        addOrgFromHttp(project, hikvisionOrganization);
    }

    /**
     * 获取组织列表
     *
     * @param project
     */
    public void getOrg(Project project) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/orgList";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", 1);
        jo.put("pageSize", 100);
        String body = jo.toJSONString();
        HikvisionUtil.doPost(host, path, body, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 组织存在？
     *
     * @param project
     * @param orgIndex
     * @return
     */
    public boolean existOrg(Project project, String orgIndex) throws Exception {
        String rs = HikvisionUtil.getOrgV2(project, orgIndex, project.getProjectSn());
        JSONObject jo = HikvisionUtil.getJSONObjectData(rs);
        return jo.getJSONArray("list").size() > 0;
    }

    private HikvisionOrganization getHikvisionOrganization(Project project) {
        HikvisionOrganization hikvisionOrganization = new HikvisionOrganization();
        hikvisionOrganization.setClientId(null);
        hikvisionOrganization.setOrgIndexCode(project.getProjectSn());
        hikvisionOrganization.setOrgName(project.getProjectName());
        hikvisionOrganization.setParentIndexCode("root000000");
        return hikvisionOrganization;
    }


    /**
     * 保存预约车辆
     *
     * @param project
     * @param carInfo
     */
    public void saveReservationCar(Project project, CarInfo carInfo) throws Exception {
        //删除预约车辆
        deleteReservationCarFromHttp(carInfo, project, false);
        //临时车辆预约
        reservationCarFromHttp(project, carInfo);
    }

    /**
     * 取消车辆包期
     *
     * @param project
     * @param carInfo
     * @throws Exception
     */
    private void cancelCharge(Project project, CarInfo carInfo) throws Exception {
        //取消车辆包期
        String parkIndexCode = HikvisionUtil.getProjectParkCode(project);
        chargeDeletion(project, new ChargeDeletionParam(parkIndexCode, carInfo.getCarNumber()));
    }

    private void reservationCarFromHttp(Project project, CarInfo carInfo) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v2/parkingSpace/reservations/addition";
        String host = "https://" + project.getArtemisConfigHost();
        ParkReservation parkReservation = getParkReservation(project, carInfo);
        String rs = HikvisionUtil.doPost(host, path, JSON.toJSONString(parkReservation), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        sendNoticeAndSetStatusForCarInfo("添加预约车辆到海康isc", rs, carInfo, 6, 1, null, true);
    }

    private ParkReservation getParkReservation(Project project, CarInfo carInfo) throws Exception {
        String parkIndexCode = HikvisionUtil.getProjectParkCode(project);
        WorkerInfo workerInfo = workerInfoMapper.selectById(carInfo.getDriverWorkerId());
        ParkReservation parkReservation = new ParkReservation();
        parkReservation.setParkSyscode(parkIndexCode);
        parkReservation.setPlateNo(carInfo.getCarNumber());
        if (Objects.equals(carInfo.getCarModuleType(), 3)) {
            parkReservation.setOwner(carInfo.getDriverWorkerName());
        } else if (workerInfo != null) {
            parkReservation.setOwner(workerInfo.getWorkerName());
        }
        parkReservation.setPhoneNo(carInfo.getDriverTelephone());
        parkReservation.setAllowTimes(Convert.toLong(carInfo.getEntryAndExitPermit()));
        parkReservation.setIsCharge("0");
        parkReservation.setStartTime(DateUtil.format(carInfo.getReserveStartTime(), "yyyy-MM-dd'T'HH:mm:ss") + "+08:00");
        parkReservation.setEndTime(DateUtil.format(carInfo.getReserveEndTime(), "yyyy-MM-dd'T'HH:mm:ss") + "+08:00");
        return parkReservation;
    }


    public String saveToLocal(String url) {
        return UrlUtil.saveToLocal(url, basePath, IdUtil.simpleUUID() + ".png");
    }

    /**
     * 保存车辆群组绑定关系
     *
     * @param project
     * @param categoryCode
     * @param carInfo
     * @throws Exception
     */
    public void saveCarCategoryBind(Project project, String categoryCode, CarInfo carInfo) throws Exception {
        bindOrNotCarCategory(project, 2, categoryCode, carInfo);
        bindOrNotCarCategory(project, 1, categoryCode, carInfo);
    }

    /**
     * 车辆群组管理，解绑使用
     *
     * @param project
     * @param operation    绑定操作类型，1绑定、2解绑
     * @param categoryCode 车辆分类标识
     * @param carInfo
     */
    public void bindOrNotCarCategory(Project project, Integer operation, String categoryCode, CarInfo carInfo) throws Exception {
        String carId = this.getRemoteCarIdByCarNumber(carInfo.getCarNumber(), project);
        JSONObject param = new JSONObject();
        param.put("vehicleIds", carId == null ? carInfo.getId() : carId);
        param.put("operation", operation);
        param.put("categoryCode", categoryCode);
        JSONObject jo = HikvisionUtil.bindCarCategory(project, param);
        String rs = jo.toJSONString();
        if (Objects.equals(operation, 1)) {
            sendNoticeAndSetStatusForCarInfo("绑定" + FIXED_CAR_GROUP_NAME + "到海康isc", rs, carInfo, 5, 1, null, true);
        } else if (Objects.equals(operation, 2)) {
            sendNoticeAndSetStatusForCarInfo("解绑" + FIXED_CAR_GROUP_NAME + "到海康isc", rs, carInfo, 5, 3, null, true);
        }
    }

    /**
     * 人脸评分
     */
    public boolean faceScore(Project project, JSONObject param) throws Exception {
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/frs/v1/face/picture/check";
        String host = "https://" + project.getArtemisConfigHost();
        String rs = HikvisionUtil.doPost(host, path, param.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
        if (HikvisionUtil.isSuccess(rs)) {
            JSONObject rsJo = HikvisionUtil.getJSONObjectData(rs);
            return rsJo.getBoolean("checkResult");
        } else {
            return false;
        }
    }

    /**
     * 查询门禁点事件v2
     *
     * @param project
     * @param param
     */
    public String getDoorEventsForHttp(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/acs/v2/door/events";
        String host = "https://" + project.getArtemisConfigHost();
        return HikvisionUtil.doPost(host, path, param.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 查询过车记录
     *
     * @param project
     * @param param
     */
    public String getCrossRecordsForHttp(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/crossRecords/page";
        String host = "https://" + project.getArtemisConfigHost();
        JSONObject jo = new JSONObject();
        jo.put("pageNo", param.getIntValue("pageNo"));
        jo.put("pageSize", 1000);
        //ISO8601时间格式
        jo.put("startTime", param.getString("startTime"));
        jo.put("endTime", param.getString("endTime"));
        jo.put("parkSyscode", param.getString("parkSyscode"));
        return HikvisionUtil.doPost(host, path, jo.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret());
    }

    /**
     * 查询门禁点列表v2
     *
     * @param project
     * @param param
     * @return
     */
    public JSONObject doorSearchV2ForHttp(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/door/search";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, param.toJSONString(), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 简单同步权限下载_根据人员与设备通道指定下载
     *
     * @param project
     * @return
     */
    public JSONObject simpleDownload(Project project, String param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/acps/v1/authDownload/task/simpleDownload";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, param, null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * @param i 0新增，2删除
     */
    public void updatePersonAuth(WorkerInfo workerInfo, String devSn, StringBuilder sucSb, StringBuilder failSb, int i) throws Exception {
        Project project = projectMapper.selectOne(new LambdaQueryWrapper<Project>().eq(Project::getProjectSn, workerInfo.getProjectSn()));
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return;
        }
        UfaceDev dev = ufaceDevMapper.selectOne(new LambdaQueryWrapper<UfaceDev>()
                .eq(UfaceDev::getDevSn, devSn));
        String json = "{\n" +
                "    \"pageNo\": 1,\n" +
                "    \"pageSize\": 1,\n" +
                "\t \"expressions\": [\n" +
                "        {\n" +
                "            \"key\": \"resourceIndexCode\",\n" +
                "            \"operator\": 0,\n" +
                "            \"values\": [\n" +
                "                \"" + devSn + "\"\n" +
                "            ]\n" +
                "        }\n" +
                "    ],\n" +
                "}";
        JSONObject rs = doorSearchV2ForHttp(project, JSONObject.parseObject(json));
        if (HikvisionUtil.isFail(rs)) {
            log.error(workerInfo.getWorkerName() + "，" + dev.getDevName() + " fail：" + rs.toJSONString() + ",");
            failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：下发异常；");
            return;
        }
        JSONObject jo = HikvisionUtil.getJSONObjectData(rs);
        JSONArray listJa = jo.getJSONArray("list");
        if (CollUtil.isEmpty(listJa)) {
            failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败信息：isc不存在该设备；");
            return;
        }
        String channelNo = listJa.getJSONObject(0).getString("channelNo");
        String sdStr = "{\n" +
                "\t\"taskType\": 5,\n" +
                "\t\"resourceInfo\": {\n" +
                "\t\t\"channelNos\": [" + channelNo + "],\n" +
                "\t\t\"resourceIndexCode\": \"" + devSn + "\",\n" +
                "\t\t\"resourceType\": \"door\"\n" +
                "\t},\n" +
                "\t\"personInfo\": {\n" +
                "\t\t\"personId\": \"" + workerInfo.getId() + "\",\n" +
                "\t\t\"operatorType\": " + i + "\n" +
                "\t}\n" +
                "}";
        JSONObject sdRs = simpleDownload(project, sdStr);
        if (HikvisionUtil.isFail(sdRs)) {
            log.error("下发人员权限失败：" + workerInfo.getWorkerName() + "，" + dev.getDevName() + " fail：" + sdRs.toJSONString() + ",");
            String code = sdRs.getString("code");
            if (Objects.equals(code, "0x15403007")) {
                //已存在权限，下发成功
                updateSucForUpdatePersonAuth(workerInfo, devSn, i);
                sucSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "；");
                return;
            }
            if (Objects.equals(code, "0x02401033")) {
                failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：网络异常；");
            } else {
                failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：下发异常；");
            }
            return;
        }
        JSONObject sdRsJo = HikvisionUtil.getJSONObjectData(sdRs);
        Integer downloadResult = sdRsJo.getJSONObject("resourceDownloadResult").getInteger("downloadResult");
        if (downloadResult == 0) {
            updateSucForUpdatePersonAuth(workerInfo, devSn, i);
            sucSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "；");
        } else {
            log.error(workerInfo.getWorkerName() + "，" + dev.getDevName() + ",fail：" + sdRsJo.toJSONString());
            failSb.append(workerInfo.getWorkerName() + "，" + dev.getDevName() + "，失败原因：下发异常；");
        }
    }

    private void updateSucForUpdatePersonAuth(WorkerInfo workerInfo, String devSn, int i) {
        updateSuccessStatusByNow(workerInfo.getProjectSn(), workerInfo.getId(), 3, i == 0 ? 1 : 3, AsyncHikvision.getSyncTime(), devSn);
    }


    /**
     * 取消车辆包期，调用预约车之前需要调用
     *
     * @param project
     * @return
     */
    public JSONObject chargeDeletion(Project project, ChargeDeletionParam param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/pms/v1/car/charge/deletion";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 根据父组织编号获取下级组织列表
     *
     * @param project
     * @return
     */
    public JSONObject getSubOrgListByParentOrg(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/parentOrgIndexCode/subOrgList";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 根据组织编号获取组织详细信息
     *
     * @param project
     * @return
     */
    public JSONObject getOrgListByIndex(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v1/org/orgIndexCodes/orgInfo";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }

    /**
     * 获取组织下人员列表v2
     *
     * @param project
     * @return
     */
    public JSONObject getWorkerListByOrg(Project project, JSONObject param) throws Exception {
        if (project == null || !Objects.equals(project.getSyncHikvision(), 1)) {
            return null;
        }
        final String ARTEMIS_PATH = "/artemis";
        final String path = ARTEMIS_PATH + "/api/resource/v2/person/orgIndexCode/personList";
        String host = "https://" + project.getArtemisConfigHost();
        return JSON.parseObject(HikvisionUtil.doPost(host, path, JSON.toJSONString(param), null, project.getArtemisConfigAppKey(), project.getArtemisConfigAppSecret()));
    }


}