package com.zc.business.controller;

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.ruoyi.common.constant.HttpStatus;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.system.service.ISysConfigService;
import com.zc.business.constant.DeviceTypeConstants;
import com.zc.business.domain.DcDevice;
import com.zc.business.enums.CameraDirectionEnum;
import com.zc.business.enums.LaneDirectionEnum;
import com.zc.business.service.IDcDeviceService;
import com.zc.business.service.IMiddleDatabaseService;
import com.zc.common.core.httpclient.OkHttp;
import com.zc.common.core.httpclient.exception.HttpException;
import com.zc.common.core.httpclient.request.RequestParams;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import okhttp3.Response;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PatchMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.io.IOException;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static com.ruoyi.common.constant.Constants.HTTP;
import static com.ruoyi.common.constant.Constants.HTTPS;
import static java.util.Comparator.comparing;


/**
 * License
 *
 * @author Athena-xiepufeng
 */
@Api(tags = "视频接口")
@RestController
@RequestMapping("/video")
public class VideoController extends BaseController {

//    private static final String ID = "admin";
//    private static final String SECRET = "21232f297a57a5a743894a0e4a801fc3";
//    private static final String CALLBACKURL = "http://10.0.81.209/broadcast/logIn";
//    private final static String TOKENKEY = "tokenRoadTestBroadcastPlatform";


//    private static final String USERNAME = "jhgskj";
//    private static final String PASSWORD = "jhgskj@2023";
    private static String TOKEN;

//    private final static String URL = HTTP + "10.166.147.60:9021";

    public static final Integer UNAUTHORIZED = 401;


    public static final Integer ERROR = 500;

    @Value("${iot.address}")
    private String iotAddress;

    @Resource
    private RedisCache redisCache;
    @Resource
    private IDcDeviceService iDcDeviceService;

    @Resource
    private IMiddleDatabaseService middleDatabaseService;
    @Autowired
    private ISysConfigService configService;

    // 组织机构id
//    private final static String CAM_DEPT_ID = "1301730";

    /**
     * 同步物联网ID。
     * 该方法用于查询未同步物联网ID的摄像头设备信息，并从外部API获取这些设备的详细信息，然后更新它们的物联网ID。
     * 该过程主要涉及查询未初始化物联网ID的摄像头、构建设备IP与设备映射、从API获取设备详细信息以及批量更新设备的物联网ID。
     */
    @ApiOperation("同步监控摄像设备ID")
    @PatchMapping(value = "/sync/id")
    public AjaxResult synchronizeIotIds() {
        // 查询未同步物联ID的摄像头设备信息
        LambdaQueryWrapper<DcDevice> query = new LambdaQueryWrapper<>();
        query.eq(DcDevice::getDeviceType, DeviceTypeConstants.CAMERA)
                .isNull(DcDevice::getIotDeviceId);

        List<DcDevice> uninitializedCameras = iDcDeviceService.list(query);

        if (uninitializedCameras.isEmpty()) {
            return AjaxResult.success("没有需要同步的设备"); // 若无待同步设备，则直接返回
        }

        // 将未初始化的摄像头列表转换为Map，以设备的桩号、方向和子类型拼接作为键，设备本身作为值
        Map<String, DcDevice> cameraMap = new HashMap<>();
        uninitializedCameras.forEach(dcDevice -> {
            String otherConfig = dcDevice.getOtherConfig();
            if (otherConfig == null) return;
            JSONObject otherConfigJson = JSONObject.parseObject(otherConfig);
            String ptzCtrl = otherConfigJson.getString("ptzCtrl");
            String key = dcDevice.getStakeMark() + "|" + dcDevice.getDirection() + "|" + ptzCtrl;
            cameraMap.put(key, dcDevice);
        });

        try {
            // 获取部门下的摄像头详细信息
            JSONObject camApiResponse = getCamByDept();

            if (camApiResponse == null || !camApiResponse.containsKey("data")) {
                return AjaxResult.error("根据组织机构获取摄像机信息失败"); // 如果获取信息失败或不含有效数据，直接返回
            }

            JSONArray camDataArray = camApiResponse.getJSONArray("data");

            // 遍历并更新具备匹配IP的摄像头设备物联ID
            List<DcDevice> devicesToUpdate = new ArrayList<>();
            camDataArray.forEach(item -> {
                JSONObject cameraInfo = (JSONObject) item;
                // 桩号
                String pileNum = cameraInfo.getString("pileNum");
                // 方向
                Integer camOrientation = cameraInfo.getInteger("camOrientation");
                LaneDirectionEnum laneDirectionEnum = CameraDirectionEnum.fromCode(camOrientation).toLaneDirection();

                // 是否有云台控制 0 有（球机） 1 ⽆（枪机）
                String ptzCtrl = cameraInfo.getString("ptzCtrl");

                String key = pileNum + "|" + laneDirectionEnum.getValue() + "|" + ptzCtrl;

                if (cameraMap.containsKey(key)) {
                    DcDevice dcDevice = cameraMap.get(key);
                    dcDevice.setIotDeviceId(cameraInfo.getString("camId"));
                    devicesToUpdate.add(dcDevice);
                }
            });

            // 批量更新摄像头设备的物联ID
            iDcDeviceService.updateBatchById(devicesToUpdate);
            return AjaxResult.success("同步物联ID成功", devicesToUpdate);
        } catch (Exception e) {
            logger.error("获取摄像头信息失败！", e);
        }

        return AjaxResult.error("同步物联ID失败");
    }

    /**
     * 查询附近相机
     */
    @ApiOperation("查询附近相机")
    @GetMapping(value = "/nearCamListDistance")
    public JSONObject nearCamListDistance(@ApiParam(value = "纬度", name = "devLat", required = true) String devLat,
                                          @ApiParam(value = "经度", name = "devLon", required = true) String devLon) throws HttpException, IOException {

        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        // 1000 米
        String distance = "1000";

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("devLat", devLat);
        requestParams.put("devLon", devLon);
        requestParams.put("distance", distance);

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/videoInfo/api/nearCamListDistance") // 请求地址
                .data(requestParams) // 请求参数
                .get(); // 请求方法

        return getJsonResult(response,okHttp);

    }

    /***
     * 根据相机中的设备状态，修改数据平台设备的设备状态
     */
    @Scheduled(cron = "0 0/5 * * * ?")
    public void updateDeviceState() throws HttpException, IOException {
        logger.debug("开始执行：同步数据平台视频设备设备的设备状态！！");
        JSONObject cameraData = synchronizeCameraData();
        if (cameraData.get("code").equals(200)) {
            JSONObject data = JSONObject.parseObject(JSONArray.parseArray(cameraData.get("data").toString()).get(0).toString());
            JSONObject dataChildren = JSONObject.parseObject(JSONArray.parseArray(data.get("children").toString()).get(0).toString());
            JSONObject qiLuGaoSu = JSONObject.parseObject(JSONArray.parseArray(dataChildren.get("children").toString()).get(0).toString());
            JSONObject jiHeYunGuan = JSONObject.parseObject(JSONArray.parseArray(qiLuGaoSu.get("children").toString()).get(0).toString());
            JSONArray jiHeYunGuanG35 = JSONArray.parseArray(jiHeYunGuan.get("children").toString());
            List<DcDevice> list = new ArrayList<>();
            for (Object json : jiHeYunGuanG35) {
                JSONObject item = JSONObject.parseObject(json.toString());
                DcDevice device = new DcDevice();
                if (item.get("status").equals("0")) {
                    device.setDeviceState("1");
                } else {
                    device.setDeviceState("0");
                }
                device.setIotDeviceId(item.get("camId").toString());
                list.add(device);
            }

            iDcDeviceService.batchUpdate(list);

            //更新中间库的设备状态
            middleDatabaseService.updateMiddleDatabaseDeviceByList(list);

            logger.debug("执行：同步数据平台视频设备的设备状态成功！！");

        }
        logger.debug("开始执行：同步物联平台设备的设备状态！！");
        AjaxResult ajaxResult = synchronizingDeviceStatus();
        if (ajaxResult.get("code").equals(200)) {
            JSONArray data = (JSONArray) ajaxResult.get("data");
            ArrayList<DcDevice> dcDevices = new ArrayList<>();
            for (Object datum : data) {
                DcDevice dcDevice = new DcDevice();
                JSONObject datum1 = (JSONObject) datum;
                dcDevice.setIotDeviceId(datum1.getString("id"));
                dcDevice.setDeviceState(Objects.equals(datum1.getString("deviceState"), "online") ? "1" : "0");
                dcDevices.add(dcDevice);
            }
            iDcDeviceService.batchUpdate(dcDevices);

            //更新中间库的设备状态
            middleDatabaseService.updateMiddleDatabaseDeviceByList(dcDevices);

            logger.debug("执行：同步物联平台设备的设备状态成功！！");

        }
        logger.debug("开始执行：同步广播设备的设备状态！！");
        AjaxResult ajaxResultBroadcast = synchronizingBroadcastDeviceStatus();
        if (Objects.equals(String.valueOf(ajaxResultBroadcast.get("retCode")), "0")) {
            JSONArray data = (JSONArray) ajaxResultBroadcast.get("termList");
            for (Object datum : data) {
                DcDevice dcDevice = new DcDevice();
                JSONObject datum1 = (JSONObject) datum;
                dcDevice.setIotDeviceId(datum1.getString("termDN"));
                dcDevice.setDeviceState(Objects.equals(datum1.getString("regState"), "online") ? "1" : "0");
                LambdaQueryWrapper<DcDevice> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(DcDevice::getIotDeviceId, dcDevice.getIotDeviceId());
                iDcDeviceService.update(dcDevice, queryWrapper);

                //更新中间库的设备状态
                middleDatabaseService.updateMiddleDatabaseDevice(dcDevice);
            }
            logger.debug("执行：同步广播设备的设备状态成功！！");

        }

    }

    private AjaxResult synchronizingBroadcastDeviceStatus() throws HttpException, IOException {
        OkHttp okHttp = new OkHttp();
        RequestParams requestParams = new RequestParams();
        JSONObject broadcast = JSONObject.parseObject(configService.selectConfigByKey("broadcast"));

        String tokenRoadTestBroadcastPlatform = redisCache.getCacheObject(broadcast.getString("TOKENKEY"));
        if (tokenRoadTestBroadcastPlatform == null) {
            tokenRoadTestBroadcastPlatform = getBroadcastToken();
        }
        requestParams.put("zoneId", "*6001");
        requestParams.put("termDN", "");
        Response response // 请求响应
                = okHttp
                .headers(new HashMap<>())
                .data(requestParams) // 请求参数
                .url(broadcast.getString("URL") + "queryTerm.do?accessToken=" + tokenRoadTestBroadcastPlatform) // 请求地址
                .post(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }

    public String getBroadcastToken() throws HttpException, IOException {

        JSONObject broadcast = JSONObject.parseObject(configService.selectConfigByKey("broadcast"));

        OkHttp okHttp = new OkHttp();
        RequestParams requestParams = new RequestParams();
        requestParams.put("id", broadcast.getString("ID"));
        requestParams.put("secret", broadcast.getString("SECRET"));
        requestParams.put("callbackUrl", broadcast.getString("CALLBACKURL"));
        Response response // 请求响应
                = okHttp
                .headers(new HashMap<>())
                .url(broadcast.getString("URL") + "login.do") // 请求地址
                .data(requestParams) // 请求参数
                .post(); // 请求方法
        if (response.body() != null) {
            String accessToken = JSONObject.parseObject(response.body().string()).getString("accessToken");
            redisCache.setCacheObject(broadcast.getString("TOKENKEY"), accessToken, 5, TimeUnit.MINUTES);
            return accessToken;
        }
        return null;
    }


    private AjaxResult synchronizingDeviceStatus() throws HttpException, IOException {

        OkHttp okHttp = new OkHttp();

        Response response // 请求响应
                = okHttp
                .url(iotAddress + "/api/iot/device/query") // 请求地址
                .get(); // 请求方法
        return JSON.parseObject(response.body().string(), AjaxResult.class);
    }


    /**
     * 查询同步相机数据
     */
    public JSONObject synchronizeCameraData() throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/system/dept/camTreeselect") // 请求地址
                .data(requestParams) // 请求参数
                .get(); // 请求方法

        return getJsonResult(response,okHttp);

    }

    /**
     * 根据桩号查询附近相机
     */
    @ApiOperation("根据桩号查询附近相机")
    @GetMapping(value = "/nearCamListPileNum")
    public Object nearCamListPileNum(@ApiParam(value = "桩号", name = "pileNum", required = true) String pileNum) throws HttpException, IOException {

        // 获取济菏运管中心相机信息
        JSONObject camInfo = getCamByDept();

        if (!camInfo.containsKey("data")) {
            return camInfo;
        }

        JSONArray camData = camInfo.getJSONArray("data");

        List<Object> resultList = new ArrayList<>();

        camData.forEach(item -> {
            JSONObject jsonObject = (JSONObject) item;
            if (isNearbyPileNum(pileNum, jsonObject.getString("pileNum"))) {
                resultList.add(item);
            }
        });

        return AjaxResult.success(resultList);
    }

    /**
     * 根据桩号查询上下行相机
     */
    @ApiOperation("根据桩号查询上下行相机")
    @GetMapping(value = "/nearCamPileNum")
    public Object nearCamPileNum(@ApiParam(value = "桩号", name = "pileNum", required = true) String pileNum) throws HttpException, IOException {

        // 获取济菏运管中心相机信息
        /*JSONObject camInfo = getCamByDept("1301730");

        if (!camInfo.containsKey("data")) {
            return camInfo;
        }

        List<Map<String,Object>> datalist = (List<Map<String, Object>>) camInfo.get("data");

        Integer pileNumDistance = pileNumTransformMetre(pileNum);
        Map<String,Object> result = new HashMap<>();

        //上行列表(包含双向)
        List<Map<String,Object>> upCameraList = datalist.stream()
                .map(item->{
                    item.put("distance",Math.abs(pileNumTransformMetre(item.get("pileNum").toString()) - pileNumDistance));
                    return item;
                })
                .filter(item ->
                        ("0".equals(item.get("camOrientation")) || "2".equals(item.get("camOrientation")))
                                && Integer.parseInt(item.get("distance").toString()) < 2000)
                .sorted(comparing(item -> Integer.parseInt(item.get("distance").toString())))
                .collect(Collectors.toList());
        result.put("upCamera",upCameraList);


        //下行列表
        List<Map<String,Object>> downCameraList = datalist.stream()
                .map(item->{
                    item.put("distance",Math.abs(pileNumTransformMetre(item.get("pileNum").toString()) - pileNumDistance));
                    return item;
                })
                .filter(item -> "1".equals(item.get("camOrientation")) && Integer.parseInt(item.get("distance").toString()) < 2000)
                .sorted(comparing(item -> Integer.parseInt(item.get("distance").toString())))
                .collect(Collectors.toList());
        result.put("downCamera",downCameraList);*/

        Map<String,Object> result = new HashMap<>();

        Integer pileNumDistance = pileNumTransformMetre(pileNum);
        String startMileage = String.valueOf(pileNumDistance - 2000);
        String endMileage = String.valueOf(pileNumDistance + 2000);
        List<DcDevice> upCameraList = iDcDeviceService.selectNearCamPile("1",startMileage,endMileage);
        List<DcDevice> downCameraList = iDcDeviceService.selectNearCamPile("3",startMileage,endMileage);
        result.put("upCamera",upCameraList);
        result.put("downCamera",downCameraList);

        return AjaxResult.success(result);
    }

    /**
     * 获取视频流信息
     */
    @ApiOperation("获取视频流信息")
    @GetMapping(value = "/externalVideoStreaming")
    public JSONObject externalVideoStreaming(@ApiParam(value = "摄像头标识", name = "camId", required = true) String camId) throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        JSONObject jsonResult = null;

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("type", "1");
        requestParams.put("camId", camId);

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/videoInfo/api/externalVideoStreaming") // 请求地址
                .data(requestParams) // 请求参数
                .post(); // 请求方法

        if (response.body() != null) {
            jsonResult = JSONObject.parseObject(response.body().string());

            if (jsonResult.containsKey("code")) {
                if (HttpStatus.SUCCESS == jsonResult.getInteger("code")) {
                    Map<String,Object> data = jsonResult.getJSONObject("data");
                    String liveUrl = data.get("liveUrl").toString();
                    liveUrl = configService.selectConfigByKey("dc.cameraUrl") + liveUrl.substring(7);
                    data.put("liveUrl",liveUrl);
                    jsonResult.put("data",data);
                } else if (UNAUTHORIZED.equals(jsonResult.getInteger("code"))) {
                    getToken();
                    okHttp.post();
                    if (response.body() != null) {
                        jsonResult = JSONObject.parseObject(response.body().string());
                        if (HttpStatus.SUCCESS == jsonResult.getInteger("code")) {
                            Map<String,Object> data = jsonResult.getJSONObject("data");
                            String liveUrl = data.get("liveUrl").toString();
                            liveUrl = configService.selectConfigByKey("cameraUrl") + liveUrl.substring(7);
                            data.put("liveUrl",liveUrl);
                            jsonResult.put("data",data);
                        }
                    }
                }
            }
        }

        return jsonResult;
    }

    /**
     * 新增预置位
     */
    @ApiOperation("新增预置位")
    @GetMapping(value = "/addPreset")
    public JSONObject addPreset(@ApiParam(value = "相机id", name = "camId", required = true) String camId,
                                @ApiParam(value = "预置位名称", name = "presetName", required = true) String presetName) throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));
        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("camId", camId);
        requestParams.put("presetName", presetName);

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/preset/addPreset") // 请求地址
                .data(requestParams) // 请求参数
                .post(); // 请求方法

        // 新增预置位
        JSONObject addPresetResult = getJsonResult(response, okHttp);
        if (addPresetResult.get("code").equals(200)) {
            JSONObject data = JSON.parseObject(addPresetResult.get("data").toString());
            return PTZControl(camId, "8", data.getString("presetId"));
        }else {
            JSONObject error = new JSONObject();
            error.put("code",500);
            error.put("msg","新增预置位失败");
            return error;
        }

    }

    /**
     * 查询预置位列表
     */
    @ApiOperation("查询预置位列表")
    @GetMapping(value = "/presetList")
    public JSONObject presetList(@ApiParam(value = "相机id", name = "camId", required = true) String camId) throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("camId", camId);

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/preset/presetList") // 请求地址
                .data(requestParams) // 请求参数
                .get(); // 请求方法

        return getJsonResult(response,okHttp);
    }
    /**
     * 返回结果处理
     */
    public JSONObject getJsonResult(Response response, OkHttp okHttp) throws HttpException, IOException {
        JSONObject jsonResult = null;
        if (response.body() != null) {
            jsonResult = JSONObject.parseObject(response.body().string());

            if (jsonResult.containsKey("code") && UNAUTHORIZED.equals(jsonResult.getInteger("code"))) {
                getToken();
                okHttp.get();
                if (response.body() != null) {
                    jsonResult = JSONObject.parseObject(response.body().string());
                }
            }
        }
        return jsonResult;
    }


    /**
     * 云平台控制
     */
    @ApiOperation("云平台控制")
    @GetMapping(value = "/PTZControl")
    public JSONObject PTZControl(@ApiParam(value = "相机id", name = "camId", required = true) String camId,
                                 @ApiParam(value = "指令类型", name = "cmdType", required = true) String cmdType,
                                 @ApiParam(value = "速度", name = "speed", required = true) String speed) throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("msgType", "3");
        requestParams.put("camId", camId);
        requestParams.put("cmdType", cmdType);
        requestParams.put("speed", speed);

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/videoInfo/api/PTZControl") // 请求地址
                .data(requestParams) // 请求参数
                .get(); // 请求方法

        return getJsonResult(response,okHttp);
    }


    public void getToken() throws HttpException, IOException {

        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("username", cameraInfo.getString("USERNAME"));
        requestParams.put("password", cameraInfo.getString("PASSWORD"));

        Response response // 请求响应
                = okHttp
                .url(cameraInfo.getString("URL") + "/apiLogin") // 请求地址
                .data(requestParams) // 请求参数
                .post(); // 请求方法

        if (response.body() != null) {
            JSONObject jsonResult = JSONObject.parseObject(response.body().string());
            if (jsonResult.containsKey("token")) {
                VideoController.TOKEN = jsonResult.getString("token");
            }
        }
    }


    /**
     * 根据组织机构获取摄像机信息
     *
     * @param
     * @return
     */
    public JSONObject getCamByDept() throws HttpException, IOException {
        JSONObject cameraInfo = JSONObject.parseObject(configService.selectConfigByKey("dc.cameraInfo"));

        OkHttp okHttp = new OkHttp();

        RequestParams requestParams = new RequestParams();
        requestParams.put("deptId", cameraInfo.getString("CAM_DEPT_ID"));

        Map<String, String> header = new HashMap<>();

        if (VideoController.TOKEN == null) {
            getToken();
        }

        header.put("Authorization", TOKEN);

        Response response // 请求响应
                = okHttp
                .headers(header)
                .url(cameraInfo.getString("URL") + "/system/camera/camList") // 请求地址
                .data(requestParams) // 请求参数
                .get(); // 请求方法

        return getJsonResult(response,okHttp);
    }

    /**
     * 判断是否是附近桩号
     *
     * @return
     */
    private boolean isNearbyPileNum(String centralPileNum, String nearbyPileNum) {

        int centralPileNumMetre = pileNumTransformMetre(centralPileNum);
        int nearbyPileNumMetre = pileNumTransformMetre(nearbyPileNum);

        return (nearbyPileNumMetre <= centralPileNumMetre + 1000) && (nearbyPileNumMetre >= centralPileNumMetre - 1000);
    }


    /**
     * 转换转换成米
     *
     * @param pileNum 桩号
     * @return
     */
    private int pileNumTransformMetre(String pileNum) {
        String[] parts = pileNum.split("[+ ]");
        if (parts.length < 2) {
            return 0;
        }
        int kilometer = Integer.parseInt(parts[0].substring(1)); // 移除开头的字母
        int meter = Integer.parseInt(parts[1]);
        return kilometer * 1000 + meter;
    }

}