package com.ruoyi.device.camera.service.impl;

import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
import com.ruoyi.alarmpoints.well.domain.ArdWellGuideCamera;
import com.ruoyi.alarmpoints.well.service.IArdAlarmpointsWellService;
import com.ruoyi.common.annotation.SdkOperate;
import com.ruoyi.common.constant.CacheConstants;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.camera.service.ICameraSdkService;
import com.ruoyi.device.camera.factory.CameraSDK;
import com.ruoyi.device.camera.factory.CameraSDKFactory;
import com.ruoyi.device.noguidezone.domain.ArdCameraNoGuideZone;
import com.ruoyi.device.noguidezone.service.IArdCameraNoGuideZoneService;
import com.ruoyi.utils.gis.GisUtil;
import com.ruoyi.utils.gis.Point;
import com.ruoyi.utils.sdk.common.GlobalVariable;
import com.ruoyi.utils.tools.ArdTool;
import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;


/**
 * @Description: 相机sdk业务
 * @ClassName: CameraSdkServiceImpl
 * @Author: 刘苏义
 * @Date: 2023年10月16日15:21:01
 **/
@Service
@Slf4j(topic = "SDK")
public class CameraSdkServiceImpl implements ICameraSdkService, ApplicationRunner {
    @Resource
    private IArdCamerasService ardCamerasService;
    @Resource
    private RedisCache redisCache;
    @Resource
    private CameraSDKFactory cameraSDKFactory;
    @Resource
    private IArdAlarmpointsWellService ardAlarmpointsWellService;
    @Resource
    private IArdCameraNoGuideZoneService ardCameraNoGuideZoneService;

    /**
     * 启动线程方法，用于执行初始化登录相机的逻辑
     *
     * @param args 命令行参数
     */
    @Override
    public void run(ApplicationArguments args) {

        try {
            // 从ardCamerasService中获取ArdCameras列表
            List<ArdCameras> ardCameras = ardCamerasService.selectArdCamerasListNoDataScope(new ArdCameras());
            for (ArdCameras camera : ardCameras) {
                login(camera);
            }
        } catch (Exception ex) {
            // 初始化登录相机异常，记录错误日志
            log.error("初始化登录相机异常：" + ex.getMessage());
        }
    }


    //登录
    @Override
    public Boolean login(ArdCameras ardCamera) {
        boolean result = false;
        try {
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                //sdkStrategy.login(ardCamera);//同步登录
                cameraSDK.asyncLogin(ardCamera);//异步登录
                result = true;
            }
        } catch (Exception ex) {
            log.error("登录异常：" + ex.getMessage());
            return false;
        }
        return result;
    }

    //注销
    @Override
    public boolean logout(String cameraId) {
        boolean result = false;
        try {
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.logout(cameraId);
            }
        } catch (Exception ex) {
            log.error("注销异常：" + ex.getMessage());
            return false;
        }
        return result;
    }

    //在线检测
    @Override
    public boolean isOnLine(CameraCmd cmd) {
        try {
            boolean onLine = false;
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                onLine = cameraSDK.isOnLine(cmd);
            }
            return onLine;
        } catch (Exception ex) {
            log.error("检测在线异常：" + ex.getMessage());
            return false;
        }
    }

    //云台控制
    @Override
    public boolean pTZControl(CameraCmd cmd) {
        try {
            boolean result = false;
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.pTZControl(cmd);
            }
            return result;
        } catch (Exception ex) {
            log.error("ptz控制异常：" + ex.getMessage());
            return false;
        }
    }

    //设置聚焦值
    @Override
    public boolean setFocusPos(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.setFocusPos(cmd);
            }
        } catch (Exception ex) {
            log.error("设置聚焦值异常：" + ex.getMessage());

        }
        return result;
    }

    //获取聚焦值
    @Override
    public int getFocusPos(CameraCmd cmd) {
        int result = 0;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.getFocusPos(cmd);
            }
        } catch (Exception ex) {
            log.error("获取聚焦值异常：" + ex.getMessage());
        }
        return result;
    }

    //设置预置位
    @Override
    public boolean setPreset(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.setPreset(cmd);
            }
        } catch (Exception ex) {
            log.error("设置预置位异常：" + ex.getMessage());
        }
        return result;
    }

    //调用预置位
    @Override
    public boolean gotoPreset(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.gotoPreset(cmd);
            }
        } catch (Exception ex) {
            log.error("调用预置位异常：" + ex.getMessage());
        }
        return result;
    }

    //获取码流压缩参数
    @Override
    public Map<String, Object> getVideoCompressionCfg(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                map = cameraSDK.getVideoCompressionCfg(cmd);
            }
        } catch (Exception ex) {
            log.error("获取码流压缩参数异常：" + ex.getMessage());
        }
        return map;
    }

    //透雾开关
    @Override
    public boolean controlDefogcfg(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.controlDefogcfg(cmd);
            }
        } catch (Exception ex) {
            log.error("操控透雾异常：" + ex.getMessage());
        }
        return result;
    }

    //红外开关
    @Override
    public boolean controlInfrarecfg(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.controlInfrarecfg(cmd);
            }
        } catch (Exception ex) {
            log.error("操控红外异常：" + ex.getMessage());
        }
        return result;
    }

    //手动/自动聚焦
    @Override
    public boolean controlFocusMode(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.controlFocusMode(cmd);
            }
        } catch (Exception ex) {
            log.error("操控聚焦模式异常：" + ex.getMessage());
        }
        return result;
    }

    //获取聚焦模式
    @Override
    public String getFocusMode(CameraCmd cmd) {
        String result = "";
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.getFocusMode(cmd);
            }
        } catch (Exception ex) {
            log.error("获取聚焦模式异常：" + ex.getMessage());
        }
        return result;
    }

    //云台加热
    @Override
    public boolean controlPTHeateRpwron(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.controlPTHeateRpwron(cmd);
            }
        } catch (Exception ex) {
            log.error("操控云台加热异常：" + ex.getMessage());
        }
        return result;
    }

    //镜头加热
    @Override
    public boolean controlCameraDeicing(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.controlCameraDeicing(cmd);
            }
        } catch (Exception ex) {
            log.error("操控云台加热异常：" + ex.getMessage());
        }
        return result;
    }

    //获取云台锁定信息
    @Override
    public int getPTZLockInfo(CameraCmd cmd) {
        int result = 99;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.getPTZLockInfo(cmd);
            }
        } catch (Exception ex) {
            log.error("获取云台锁定信息异常：" + ex.getMessage());
        }
        return result;
    }

    @Override
    public String captureJPEGPicture(CameraCmd cmd) {
        return null;
    }

    //抓图
    @Override
    public String picCutCate(CameraCmd cmd) {
        String url = "";
        try {
            //获取摄像头ID
            String cameraId = cmd.getCameraId();
            //从redis中获取摄像头信息
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                //获取摄像头工厂
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                url = cameraSDK.picCutCate(cmd);
            }
        } catch (Exception ex) {
            log.error("抓图异常：" + ex.getMessage());
        }
        return url;
    }

    //获取ptz
    @Override
    public Map<String, Object> getPtz(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                map = cameraSDK.getPtz(cmd);
            }
        } catch (Exception ex) {
            log.error("获取ptz异常：" + ex.getMessage());
        }
        return map;
    }

    //获取ptz范围
    @Override
    public Map<String, Object> getPtzScope(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                map = cameraSDK.getPtzScope(cmd);
            }
        } catch (Exception ex) {
            log.error("获取ptz范围异常：" + ex.getMessage());
        }
        return map;
    }

    //设置ptz
    @Override
    public boolean setPtz(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                String gdtype = ardCamera.getGdtype();
                if (gdtype.equals("1")) {
                    //大光电使用高精度ptz设置
                    result = cameraSDK.setPtz(cmd);
                } else {
                    result = cameraSDK.setPtz1(cmd);
                }

            }
        } catch (Exception ex) {
            log.error("设置ptz异常：" + ex.getMessage());
        }
        return result;
    }

    //设置零方位角
    @Override
    public boolean setZeroPtz(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.setZeroPtz(cmd);
            }
        } catch (Exception ex) {
            log.error("设置零方位角异常：" + ex.getMessage());
        }
        return result;
    }

    //引导指向目标
    @Override
    public boolean guideTargetPosition(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.guideTargetPosition(cmd);
            }
        } catch (Exception ex) {
            log.error("引导指向目标异常：" + ex.getMessage());
        }
        return result;
    }

    //引导指向井
    @Override
    public AjaxResult guideTargetWell(CameraCmd cmd) {

        //按日夜切换配置获取相机通道
        Integer chanNo = ArdTool.getChannelBydayNightTime(redisCache.getCacheObject("sys_config:dayNightTime"));
        cmd.setChanNo(chanNo);

        //获取井
        ArdAlarmpointsWell well = ardAlarmpointsWellService.selectArdAlarmpointsWellById(cmd.getWellId());
        if (well == null) {
            return AjaxResult.error("井不存在");
        }
        cmd.setTargetPosition(new double[]{well.getLongitude(), well.getLatitude()});

        //获取井配置的引导相机列表
        List<ArdWellGuideCamera> ardWellGuideCameraList = well.getArdWellGuideCameraList();
        if (ardWellGuideCameraList != null && ardWellGuideCameraList.size() > 0) {
            //获取相机和井的距离进行排序，取出最近的一个相机
            Map<String, Double> distanceMap = new HashMap<>();
            for (ArdWellGuideCamera ardWellGuideCamera : ardWellGuideCameraList) {
                ArdCameras cameras = ardCamerasService.selectArdCamerasById(ardWellGuideCamera.getCameraId());
                if (cameras == null) {
                    continue;
                }
                double[] targetPosition = new double[]{well.getLongitude(), well.getLatitude()};
                double[] camPosition = new double[]{cameras.getLongitude(), cameras.getLatitude()};
                double distance = GisUtil.getDistance(targetPosition, camPosition);
                distanceMap.put(ardWellGuideCamera.getCameraId(), distance);//存入缓存map
            }
            //从缓存里取出距离最近相机ID
            String cameraId = ArdTool.getKeyByMinValue(distanceMap);
            cmd.setCameraId(cameraId);
            //获取最近相机的对象
            Optional<ArdWellGuideCamera> first = ardWellGuideCameraList.stream().filter(s -> s.getCameraId().equals(cameraId)).findFirst();
            if(first.isPresent())
            {
                ArdWellGuideCamera ardWellGuideCamera = first.get();
                Map<String, Double> ptzMap = null;
                //通过通道获取预置位
                switch (chanNo) {
                    case 1:
                        if (ardWellGuideCamera.getP1() != null) {
                            ptzMap = new HashMap<>();
                            ptzMap.put("p", ardWellGuideCamera.getP1());
                            ptzMap.put("t", ardWellGuideCamera.getT1());
                            ptzMap.put("z", ardWellGuideCamera.getZ1());
                        }
                        break;
                    case 2:
                        if (ardWellGuideCamera.getP2() != null) {
                            ptzMap = new HashMap<>();
                            ptzMap.put("p", ardWellGuideCamera.getP2());
                            ptzMap.put("t", ardWellGuideCamera.getT2());
                            ptzMap.put("z", ardWellGuideCamera.getZ2());
                        }
                        break;

                }
                //引导
                if (ptzMap != null) {
                    //使用ptz引导
                    cmd.setPtzMap(ptzMap);
                    boolean res = setPtz(cmd);
                    if (!res) {
                        return AjaxResult.error("ptz引导失败", "cameraId:" + cameraId);
                    }
                    return AjaxResult.success("ptz引导成功", "cameraId:" + cameraId);
                }
            }

        }
        log.debug("未找到ptz引导相机,查找最近相机");

        //从附近相机找最近的一个相机
        String cameraId = getCameraByNear(new double[]{well.getLongitude(), well.getLatitude()});
        cmd.setCameraId(cameraId);
        if ("".equals(cameraId)) {
            return AjaxResult.error("未找到引导相机");
        }
        //判断禁引区
        if (isInPolygon(cameraId, new Double[]{well.getLongitude(), well.getLatitude()})) {
            return AjaxResult.error("井位置属于相机禁止引导区域");
        }
        //按井坐标开始引导
        if (!guideTargetPosition(cmd)) {
            return AjaxResult.error("井坐标引导失败", "cameraId:" + cameraId);
        }
        return AjaxResult.success("井坐标引导成功", "cameraId:" + cameraId);

    }

    /**
     * 获取最近距离的光电
     * 1-相机在线
     * 2-开启报警引导功能
     * 3-配置了最大可视距离
     */
    private String getCameraByNear(double[] targetPosition) {
        String minDistanceCameraId = "";
        try {
            //获取所有大光电
            List<Object> Objects = redisCache.getListKey(CacheConstants.CAMERA_LIST_KEY);
            //统计所有大光电可视范围内与报警点的距离
            Map<String, Double> distanceMap = new HashMap<>();
            for (Object obj : Objects) {
                ArdCameras camera = (ArdCameras) obj;

                if (!GlobalVariable.loginMap.containsKey(camera.getId())) {
                    log.debug("该光电未登录");
                    continue;
                }
                if (camera.getCamMaxVisibleDistance() == null) {
                    log.debug("该光电未配置最大可视距离");
                    continue;
                }
                if (camera.getCamAlarmGuideEnable().equals(0)) {
                    log.debug("该光电未开启报警引导");
                    continue;
                }

                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double distance = GisUtil.getDistance(targetPosition, camPosition);
                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                    distanceMap.put(camera.getId(), distance);
                    if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
                        camera.setCamAlarmGuideEnable(0);
                    }
                }
            }
            if (distanceMap.size() > 0) {
                log.debug("尝试查找最近光电");
                //获取距离字典中最近的一个相机ID
                minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
                log.debug("查找到最近光电:" + minDistanceCameraId);
            }
        } catch (Exception ex) {
            log.error("获取附近开启报警引导功能光电异常:" + ex.getMessage());
        }
        return minDistanceCameraId;
    }

    //判断相机和引导位置是否在禁止引导区域
    public boolean isInPolygon(String cameraId, Double[] targetPosition) {
        boolean result = false;
        //拦截手动引导
        ArdCameraNoGuideZone ardCameraNoGuideZone = new ArdCameraNoGuideZone();
        ardCameraNoGuideZone.setCameraId(cameraId);
        ardCameraNoGuideZone.setEnabled("1");
        //获取当前相机的禁引可视域列表
        List<ArdCameraNoGuideZone> ardCameraNoGuideZones = ardCameraNoGuideZoneService.selectArdCameraNoGuideZoneList(ardCameraNoGuideZone);
        if (ardCameraNoGuideZones.size() > 0) {
            //获取到当前相机的坐标集合
            for (ArdCameraNoGuideZone zone : ardCameraNoGuideZones) {
                String[] parts = zone.getPoi().split(",");
                List<Point> pointList = new ArrayList<>();
                for (int i = 0; i < parts.length; i += 3) {
                    Point point = new Point();
                    point.setLongitude(Double.valueOf(parts[i]));
                    point.setLatitude(Double.valueOf(parts[i + 1]));
                    pointList.add(point);
                }
                double lon = targetPosition[0];
                double lat = targetPosition[1];
                Point targetPoint = new Point(lon, lat);
                //判断引导目标是否在坐标集合组成的多边形内
                boolean inPolygon = GisUtil.isInPolygon(targetPoint, pointList);
                if (inPolygon) {
                    result = inPolygon;
                }
            }
        }
        return result;
    }

    /**
     * @描述 操控锁定
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 0-解锁 1-锁定
     */
    @Override
    @SdkOperate
    public boolean controlLock(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();//申请锁的相机
        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);
        Date now = new Date();
        now.setTime(now.getTime() + cmd.getExpired() * 1000);
        ardCameras.setOperatorExpired(now);//设置当前过期时间
        ardCamerasService.updateArdCameras(ardCameras);
        return true;
    }

    /**
     * @描述 操控解锁
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/6/30 15:36
     * @修改人和其它信息
     */
    @Override
    public boolean controlUnLock(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();//申请解锁的相机
        String operator = cmd.getOperator();//申请者
        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);
        if (ardCameras.getOperatorId().equals(operator)) {
            //如果解锁相机的当前用户是申请者，则清空该相机的过期时间
            ardCameras.setOperatorExpired(null);
            int i = ardCamerasService.updateArdCameras(ardCameras);
            if (i > 0) {
                log.debug(cameraId + "--解锁成功");
            }
        }
        return true;
    }

    //录像
    @SdkOperate
    @Override
    public String record(CameraCmd cmd) {
        String url = "";
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                url = cameraSDK.record(cmd);
            }
        } catch (Exception ex) {
            log.error("录像异常：" + ex.getMessage());
        }
        return url;
    }

    //开始录像
    @Override
    public boolean recordStart(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.recordStart(cmd);
            }
        } catch (Exception ex) {
            log.error("开始录像异常：" + ex.getMessage());
        }
        return result;
    }

    //停止录像并存入minio
    @Override
    public String recordStopToMinio(CameraCmd cmd) {
        String url = "";
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                url = cameraSDK.recordStopToMinio(cmd);
            }
        } catch (Exception ex) {
            log.error("停止录像异常：" + ex.getMessage());
        }
        return url;
    }

    //停止录像并不存入minio
    @Override
    public boolean recordStopNotToMinio(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                result = cameraSDK.recordStopNotToMinio(cmd);
            }
        } catch (Exception ex) {
            log.error("停止录像异常：" + ex.getMessage());
        }
        return result;
    }

    //获取相机架设参数
    @Override
    public Map<String, Object> getGisInfo(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);
            if (ardCamera != null) {
                String factory = ardCamera.getFactory();
                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
                map = cameraSDK.getGisInfo(cmd);
            }
        } catch (Exception ex) {
            log.error("获取相机架设参数异常：" + ex.getMessage());
        }
        return map;
    }

}