package com.ard.work.sdk.service;

import com.ard.common.core.constant.CacheConstants;
import com.ard.common.core.exception.ServiceException;
import com.ard.common.core.exception.device.CameraSDKException;
import com.ard.common.core.web.domain.AjaxResult;
import com.ard.common.redis.service.RedisService;
import com.ard.common.security.utils.SecurityUtils;
import com.ard.work.api.domian.*;
import com.ard.work.device.camera.domain.PtzParamDTO;
import com.ard.work.device.noview.domain.ArdNoViewingZone;
import com.ard.work.device.noview.service.IArdNoViewingZoneService;
import com.ard.work.sdk.annotation.SdkOperate;
import com.ard.work.sdk.common.RecordManager;
import com.ard.work.sdk.factory.CameraSDKFactory;
import com.ard.work.sdk.model.DeviceCFG;
import com.ard.work.sdk.model.PtzScope;
import com.ard.work.utils.gis.GisUtil;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;


/**
 * @Description: 相机sdk业务
 * @ClassName: CameraSdkServiceImpl
 * @Author: 刘苏义
 * @Date: 2023年10月16日15:21:01
 **/
@Service
@Slf4j
public class CameraSDKService {

    @Resource
    private RedisService redisService;
    @Resource
    private CameraSDKFactory cameraSDKFactory;
    @Resource
    private IArdNoViewingZoneService ardNoViewingZoneService;

    //登录
    @Async("cameraSdkExecutor")
    public void login(ArdCamera ardCamera) {
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(null);
        }
        CameraSDK sdk = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        sdk.login(ardCamera);
    }

    //注销
    public void logout(String cameraId) {
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
            return;
        }
        if(ardCamera.getFactory()!= null) {
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
            cameraSDK.logout(cameraId);
        }
    }


    //在线检测
    public boolean isOnLine(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cameraId);
        if (loginId == null) {
            return false;
        }
        cmd.setLoginId(loginId);
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        return cameraSDK.isOnLine(cmd);
    }

    //云台控制
    @SdkOperate
    public Boolean pTZControl(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);

        // 调用各厂商 SDK 方法，异常由各自 SDK 实现抛出
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        return cameraSDK.pTZControl(cmd);
    }

    //设置聚焦值
    public Boolean setFocusPos(CameraCmd cmd) {
        // 1️⃣ 获取相机信息
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);

        // 3️⃣ 调用对应厂商 SDK
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setFocusPos(cmd);
    }

    //获取聚焦值
    public Integer getFocusPos(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }

        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getFocusPos(cmd);
    }

    //设置预置位
    public Boolean setPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setPreset(cmd);
    }

    //调用预置位
    public Boolean gotoPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.gotoPreset(cmd);
    }

    //获取码流压缩参数
    public VideoCompressionCfg getVideoCompressionCfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getVideoCompressionCfg(cmd);
    }

    //透雾开关
    public Boolean controlDefog(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlDefog(cmd);
    }

    //查询是否开启透雾
    public Boolean isEnableDefog(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.isEnableDefog(cmd);
    }

    //红外开关
    public Boolean controlInfrared(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlInfrared(cmd);

    }

    //查询是否开启红外
    public Boolean isEnableInfrared(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.isEnableInfrared(cmd);
    }

    //手动/自动聚焦
    public Boolean controlFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlFocusMode(cmd);
    }

    //获取聚焦模式
    public Boolean getFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getFocusMode(cmd);
    }

    //云台加热
    public Boolean controlPTHeater(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlPTHeater(cmd);
    }

    //镜头加热
    public Boolean controlCameraDeicing(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.controlCameraDeicing(cmd);
    }

    //获取云台锁定信息
    public Boolean getPTZLockInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getPTZLockInfo(cmd);
    }

    //设置云台锁定信息
    public Boolean setPTZLockInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();//0未锁 1锁定
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setPTZLockInfo(cmd);
    }

    //本地抓图
    public byte[] localCapture(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }

        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.localCapture(cmd);
    }

    //抓图
    @SdkOperate
    public String picCutCate(CameraCmd cmd) {
        //从redis中获取摄像头信息
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            return "";
        }
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            return "";
        }
        cmd.setLoginId(loginId);
        //获取摄像头工厂
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.picCutCate(cmd);
    }

    //抓图
    @SdkOperate
    public String picCutCate(CameraCmd cmd, String bucketName, String objectName) {
        String url = "";
        try {
            //从redis中获取摄像头信息
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            if (ardCamera == null) {
                return "";
            }
            Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
            if (loginId == null) {
                return "";
            }
            cmd.setLoginId(loginId);
            //获取摄像头工厂
            String factory = ardCamera.getFactory();
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
            url = cameraSDK.picCutCate(cmd, bucketName, objectName);

        } catch (Exception ex) {
            log.error("抓图异常：{}", ex.getMessage());
        }
        return url;
    }

    //获取ptz
    public PtzDto getPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        String type = ardCamera.getType();
        if ("1".equals(type)) {
            return cameraSDK.getPtzHigh(cmd);
        } else {
            return cameraSDK.getPtz(cmd);
        }
    }

    //获取ptz范围
    public PtzScope getPtzScope(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getPtzScope(cmd);
    }

    //设置ptz
    @SdkOperate
    public Boolean setPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());
        String type = ardCamera.getType();
        if ("1".equals(type)) {
            DeviceCFG systemInfo = cameraSDK.getSystemInfo(cmd);
            if (systemInfo != null && "5.5.112".equals(systemInfo.getDwSoftwareVersion())) {
                //大光电新固件使用高精度ptz透传设置
                return cameraSDK.setPtzHighT(cmd);
            } else {
                //使用高精度ptz设置
                return cameraSDK.setPtzHigh(cmd);
            }

        } else {
            return cameraSDK.setPtz(cmd);
        }
    }

    //设置零方位角
    public Boolean setZeroPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.setZeroPtz(cmd);
    }

    //引导指向目标
    @SdkOperate
    public Boolean guideTargetPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        //判断是否超出引导距离
        if (isOutMaxDistance(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.OVER_GUIDANCE_RANGE.getCode(), cameraId,
                    "目标超出最大引导距离");
        }
        //判断是否在不可视域
        if (isInNoViewingZone(cameraId, cmd.getTargetPosition())) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.BEYOND_VISIBILITY_RANGE.getCode(), cameraId
                    , "目标超出最大引导距离");
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        cmd.setBaseYaw(ardCamera.getBaseYaw());
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.guideTargetPosition(cmd);
    }

    //判断坐标是否超出引导范围
    private Boolean isOutMaxDistance(String cameraId, Point targetPoint) {
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cameraId);
        if (ardCamera == null) {
            log.error("设备不存在");
            return true;
        }
        Point cameraCoordinate = new Point(ardCamera.getLongitude(), ardCamera.getLatitude(), ardCamera.getAltitude());
        double distance = GisUtil.getDistance(cameraCoordinate, targetPoint);
        if (ardCamera.getCamMaxVisibleDistance() == null) {
            throw new CameraSDKException(CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getCode(),
                    cameraId, CameraSDKException.ErrorCode.CAMERA_MAX_VISIBLE_DISTANCE_NULL.getMsg());
        }
        double camMaxVisibleDistance = ardCamera.getCamMaxVisibleDistance();
        return distance > camMaxVisibleDistance;
    }

    //判断坐标是否在不可视域
    private Boolean isInNoViewingZone(String cameraId, Point targetPoint) {
        ArdNoViewingZone ardNoViewingZone = new ArdNoViewingZone();
        ardNoViewingZone.setCameraId(cameraId);
        List<ArdNoViewingZone> ardNoViewingZones =
                ardNoViewingZoneService.selectArdNoViewingZoneList(ardNoViewingZone);//获取相机的不可视域列表
        List<Point> pointList = new ArrayList<>();
        if (ardNoViewingZones.isEmpty()) {
            return false;
        }
        ardNoViewingZones.forEach(noViewingZone -> {
            String poi = noViewingZone.getPoi();
            String[] parts = poi.split(",");
            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);
            }
        });
        return GisUtil.isInPolygon(targetPoint, pointList);
    }

    //录像
    public String record(CameraCmd cmd) {
        String url = "";
        try {
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            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;
    }

    //开始录像
    public Boolean recordStart(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        Boolean result = cameraSDK.recordStart(cmd);
        if (result != null && result) {
            RecordManager.addRecord(cmd.getCameraId() + "_" + cmd.getChanNo());
        }
        return result;
    }

    //停止录像并存入minio
    public String recordStop(CameraCmd cmd) {
        String url = "";
        try {
            ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
            if (ardCamera == null) {
                return url;
            }
            Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
            if (loginId == null) {
                return url;
            }
            cmd.setLoginId(loginId);
            String factory = ardCamera.getFactory();
            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
            url = cameraSDK.recordStop(cmd);
            String key = cmd.getCameraId() + "_" + cmd.getChanNo();
            RecordManager.stopRecord(key);
        } catch (Exception ex) {
            log.error("停止录像异常：{}", ex.getMessage());
        }
        return url;
    }


    //获取相机架设参数
    public PtzParamDTO getGisInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.getGisInfo(cmd);
    }

    //获取相机通道信息
    public List<ArdChannel> getChannels(ArdCamera camera) {
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, camera.getId());
        if (loginId == null) {
            return new ArrayList<>();
        }
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(camera.getFactory());
        return cameraSDK.getChannels(camera);
    }

    //NET_DVR_PTZSelZoomIn
    public Boolean set3DPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.set3DPosition(cmd);
    }

    //录像超时检查
    @Scheduled(fixedRate = 30 * 1000)
    public void checkVideoTimeout() {
        Date now = new Date();
        RecordManager.getActiveRecords().forEach((name, date) -> {
            long duration = now.getTime() - date.getTime();
            if (duration > 15 * 60 * 1000) {
                CameraCmd cmd = new CameraCmd();
                String cameraId = name.split("_")[0];
                Integer chanNo = Integer.parseInt(name.split("_")[1]);
                cmd.setCameraId(cameraId);
                cmd.setChanNo(chanNo);
                recordStop(cmd);
                log.info("录像超时检测：停止{}_{}的录像,已录像时间超过15分钟", cameraId, chanNo);
            }
        });
    }

    //获取相机架设参数
    public Double correctPitch(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        // 设备存在性检查
        ArdCamera ardCamera = redisService.getCacheMapValue(CacheConstants.CAMERA_LIST, cmd.getCameraId());
        if (ardCamera == null) {
            throw CameraSDKException.cameraNotExist(cameraId);
        }
        // 设备在线检查
        Long loginId = redisService.getCacheMapValue(CacheConstants.CAMERA_ONLINE, cmd.getCameraId());
        if (loginId == null) {
            throw CameraSDKException.cameraOffline(cameraId);
        }
        cmd.setLoginId(loginId);
        String factory = ardCamera.getFactory();
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);
        return cameraSDK.correctPitch(cmd);
    }
    public AjaxResult getCameraVideoLable(CameraCmd cmd) {
        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK("1");
        try {
            List<Map<String, Object>>  r= cameraSDK.getCameraVideoLable(SecurityUtils.getUserId(), cmd);
            return AjaxResult.success(r);
        }catch (ServiceException e){
            return AjaxResult.error(e.getMessage());
        }
    }

}