package com.ard.qs.service.impl;

import cn.hutool.core.util.IdUtil;
import com.ard.common.core.constant.SecurityConstants;
import com.ard.common.core.domain.R;
import com.ard.common.core.enums.LiveStreamType;
import com.ard.common.core.utils.DateUtils;
import com.ard.common.core.utils.file.FileMultipartFile;
import com.ard.common.security.utils.SecurityUtils;
import com.ard.gb28181.api.RemoteGb28181Service;
import com.ard.qs.api.domain.QsDevice;
import com.ard.qs.api.domain.QsGroup;
import com.ard.qs.api.domain.QsRegion;
import com.ard.qs.domain.*;
import com.ard.qs.mapper.QsDeviceMapper;
import com.ard.qs.mapper.QsRegionMapper;
import com.ard.qs.service.IQsDeviceService;
import com.ard.qs.utils.StreamDetector;
import com.ard.qs.utils.VideoSnapshotUtil;
import com.ard.system.api.RemoteFileService;
import com.ard.system.api.domain.SysFile;
import com.ard.zlm.api.RemoteZlmService;
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.concurrent.ThreadPoolTaskExecutor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.ObjectUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 视频监控设备Service业务层处理
 *
 * @author fengcheng
 * @date 2026-03-27
 */
@Slf4j
@Service
@Transactional(rollbackFor = Exception.class)
public class QsDeviceServiceImpl implements IQsDeviceService {
    @Autowired
    private QsDeviceMapper qsDeviceMapper;

    @Autowired
    private RemoteGb28181Service remoteGb28181Service;

    @Autowired
    private RemoteZlmService remoteZlmService;

    @Autowired
    private StreamDetector streamDetector;

    @Autowired
    private ThreadPoolTaskExecutor taskExecutor;

    @Autowired
    private QsRegionMapper qsRegionMapper;

    @Autowired
    private VideoSnapshotUtil videoSnapshotUtil;

    @Resource
    private RemoteFileService remoteFileService;

    /**
     * 查询视频监控设备
     *
     * @param id 视频监控设备主键
     * @return 视频监控设备
     */
    @Override
    public QsDevice selectQsDeviceById(Long id) {
        return qsDeviceMapper.selectQsDeviceById(id);
    }

    /**
     * 查询视频监控设备列表
     *
     * @param qsDevice 视频监控设备
     * @return 视频监控设备
     */
    @Override
    public List<QsDevice> selectQsDeviceList(QsDevice qsDevice) {
        return qsDeviceMapper.selectQsDeviceList(qsDevice);
    }

    /**
     * 新增视频监控设备
     *
     * @param qsDevice 视频监控设备
     * @return 结果
     */
    @Override
    public int insertQsDevice(QsDevice qsDevice) {
        qsDevice.setCreateBy(String.valueOf(SecurityUtils.getUserId()));
        qsDevice.setCreateTime(DateUtils.getNowDate());
        qsDevice.setDeviceStatus("ON");
        // RTSP协议
        if (LiveStreamType.RTSP.getCode().equals(qsDevice.getType())) {
            qsDevice.setDeviceCode("device_" + IdUtil.getSnowflakeNextId());
            if (!isValidRtspFormat(qsDevice.getLiveAddress())) {
                throw new RuntimeException("RTSP地址格式不正确");
            }
        }

        // RTMP协议
        if (LiveStreamType.RTMP.getCode().equals(qsDevice.getType())) {
            qsDevice.setDeviceCode("device_" + IdUtil.getSnowflakeNextId());
            if (!isValidRtmpFormat(qsDevice.getLiveAddress())) {
                throw new RuntimeException("RTMP地址格式不正确");
            }
        }

        // 推流模式
        if (LiveStreamType.PUSH.getCode().equals(qsDevice.getType())) {
            qsDevice.setDeviceCode("device_" + IdUtil.getSnowflakeNextId());
            qsDevice.setDeviceStatus("OFFLINE");
        }

        // gb28181协议
        if (LiveStreamType.GB28181.getCode().equals(qsDevice.getType())) {
            qsDevice.setDeviceCode("device_" + IdUtil.getSnowflakeNextId());
        }

        // JT1078协议
        if (LiveStreamType.JT1078.getCode().equals(qsDevice.getType())) {
            qsDevice.setDeviceCode("device_" + IdUtil.getSnowflakeNextId());
        }
        return qsDeviceMapper.insertQsDevice(qsDevice);
    }

    /**
     * 修改视频监控设备
     *
     * @param qsDevice 视频监控设备
     * @return 结果
     */
    @Override
    public int updateQsDevice(QsDevice qsDevice) {
        qsDevice.setUpdateBy(String.valueOf(SecurityUtils.getUserId()));
        qsDevice.setUpdateTime(DateUtils.getNowDate());

        // RTSP协议
        if (LiveStreamType.RTSP.getCode().equals(qsDevice.getType())) {
            if (!isValidRtspFormat(qsDevice.getLiveAddress())) {
                throw new RuntimeException("RTSP地址格式不正确");
            }
        }

        // RTMP协议
        if (LiveStreamType.RTMP.getCode().equals(qsDevice.getType())) {
            if (!isValidRtmpFormat(qsDevice.getLiveAddress())) {
                throw new RuntimeException("RTMP地址格式不正确");
            }
        }

        // FLV协议
        if (LiveStreamType.FLV.getCode().equals(qsDevice.getType())) {
            String flvType = getProtocolTypeSimple(qsDevice.getLiveAddress());
            qsDevice.setFlvType(flvType);
            if (!isValidFlvAddress(qsDevice.getLiveAddress())) {
                throw new RuntimeException("FLV地址格式不正确");
            }
        }

        // HLS协议
        if (LiveStreamType.HLS.getCode().equals(qsDevice.getType())) {
            if (!isValidHlsAddress(qsDevice.getLiveAddress())) {
                throw new RuntimeException("HLS地址格式不正确");
            }
        }

        // 视频文件
        if (LiveStreamType.VIDEO_FILE.getCode().equals(qsDevice.getType())) {
            if (!isValidMp4Address(qsDevice.getLiveAddress())) {
                throw new RuntimeException("视频文件格式不正确");
            }
        }

//        // 海康SDK
//        if (LiveStreamType.HIK_SDK.getCode().equals(qsDevice.getType())) {
//
//            LoginDevice loginDevice = new LoginDevice();
//            loginDevice.setIpAddress(qsDevice.getIpAddress());
//            loginDevice.setPort(Short.parseShort(String.valueOf(qsDevice.getPort())));
//            loginDevice.setUserName(qsDevice.getUserName());
//            loginDevice.setPassword(qsDevice.getPassword());
//            R<Integer> r = remoteHaiKangService.loginDevice(loginDevice, SecurityConstants.INNER);
//            if (r.getCode() != Constants.SUCCESS) {
//                throw new RuntimeException(r.getMsg());
//            }
//        }

//        // 大华sdk
//        if (LiveStreamType.DAHUA_SDK.getCode().equals(qsDevice.getType())) {
//
//            com.ruoyi.dahua.api.domain.LoginDevice loginDevice = new com.ruoyi.dahua.api.domain.LoginDevice();
//
//            // 1=主动添加
//            if("1".equals(qsDevice.getOnlineType())){
//                qsDevice.setDeviceCode("dahua_" + IdUtil.getSnowflakeNextId());
//                loginDevice.setIpAddress(qsDevice.getIpAddress());
//                loginDevice.setPort(qsDevice.getPort());
//                loginDevice.setUserName(qsDevice.getUserName());
//                loginDevice.setPassword(qsDevice.getPassword());
//            }
//
//            // 2=主动注册
//            if("2".equals(qsDevice.getOnlineType())){
//                R<DahuaDevice> dahuaDevicer = remoteDaHuaService.getDahuaDevice(qsDevice.getIpAddress(),
//                SecurityConstants.INNER);
//                if(dahuaDevicer.getCode() != Constants.SUCCESS){
//                    throw new RuntimeException(dahuaDevicer.getMsg());
//                }
//                if(dahuaDevicer.getData() == null){
//                    throw new RuntimeException("未找到设备");
//                }
//                loginDevice.setIpAddress(qsDevice.getIpAddress());
//                loginDevice.setPort(Integer.valueOf(dahuaDevicer.getData().getPort()));
//                loginDevice.setDeviceId(dahuaDevicer.getData().getDeviceId());
//                loginDevice.setUserName(qsDevice.getUserName());
//                loginDevice.setPassword(qsDevice.getPassword());
//                loginDevice.setOnlineType(qsDevice.getOnlineType());
//            }
//
//            R<Void> r = remoteDaHuaService.loginDevice(loginDevice, SecurityConstants.INNER);
//            if (r.getCode() != Constants.SUCCESS) {
//                throw new RuntimeException(r.getMsg());
//            }
//        }
        return qsDeviceMapper.updateQsDevice(qsDevice);
    }

    /**
     * 批量删除视频监控设备
     *
     * @param ids 需要删除的视频监控设备主键
     * @return 结果
     */
    @Override
    public int deleteQsDeviceByIds(Long[] ids) {
        return qsDeviceMapper.deleteQsDeviceByIds(ids);
    }

    /**
     * 删除视频监控设备信息
     *
     * @param id 视频监控设备主键
     * @return 结果
     */
    @Override
    public int deleteQsDeviceById(Long id) {
        return qsDeviceMapper.deleteQsDeviceById(id);
    }

    /**
     * 状态修改
     *
     * @param qsDevice 视频监控设备
     * @return
     */
    @Override
    public int updateQsDeviceStatus(QsDevice qsDevice) {
        return qsDeviceMapper.updateQsDeviceStatus(qsDevice.getId(), qsDevice.getStatus());
    }

    /**
     * 更新设备在线状态
     *
     * @param onlineDeviceSet 在线设备集合
     * @param deviceStatus    设备状态
     * @return
     */
    @Override
    public Boolean updateQsDeviceStatusList(Set<Long> onlineDeviceSet, String deviceStatus) {
        return qsDeviceMapper.updateQsDeviceStatusList(onlineDeviceSet, deviceStatus);
    }

    /**
     * 修改视频监控设备
     *
     * @param qsDevice 视频监控设备
     * @return
     */
    @Override
    public int editQsDevice(QsDevice qsDevice) {
        return qsDeviceMapper.updateQsDevice(qsDevice);
    }

    /**
     * 更具流id获取视频监控设备
     *
     * @param stream 流id
     * @return
     */
    @Override
    public QsDevice getQsDeviceStream(String stream) {
        return qsDeviceMapper.getQsDeviceStream(stream);
    }

    /**
     * 修改所有设备播状态离线和设备状态离线
     */

    @Override
    public void updateAllQsDevicesToOffline() {
        qsDeviceMapper.updateAllQsDevicesToOffline();
    }

    /**
     * 获取所有视频监控设备流地址
     *
     * @return
     */
    @Override
    public List<QsDevice> fetchAllQsDeviceStreamUrls() {
        return qsDeviceMapper.fetchAllQsDeviceStreamUrls();
    }

    /**
     * 更新所有视频监控设备流地址
     *
     * @param newQsDeviceList
     */
    @Override
    public void updateAllQsDeviceStreamUrls(List<QsDevice> newQsDeviceList) {
        qsDeviceMapper.updateAllQsDeviceStreamUrls(newQsDeviceList);
    }

    @Async("taskExecutor")
    @Override
    public void task() {
        List<QsDevice> qsDeviceList = fetchAllQsDeviceStreamUrls();
        if (qsDeviceList.isEmpty()) {
            return;
        }

        // 处理所有设备，替换 ws/wss 为 http/https，先替换 wss 防止被误判
        qsDeviceList.forEach(device -> {
            String originalUrl = device.getLiveAddress();
            if (originalUrl != null && !originalUrl.isEmpty()) {
                // 注意替换顺序，先替换 wss -> https，再替换 ws -> http
                String newUrl = originalUrl.replace("wss://", "https://")
                        .replace("ws://", "http://");
                device.setLiveAddress(newUrl);
            }
        });

        List<StreamDetector.StreamResult> streamResults = streamDetector.batchDetect(qsDeviceList, taskExecutor);

        List<QsDevice> newQsDeviceList = new ArrayList<>();
        for (StreamDetector.StreamResult streamResult : streamResults) {
            QsDevice device = new QsDevice();
            device.setId(streamResult.getId());
            device.setDeviceStatus(streamResult.getStatus());
            newQsDeviceList.add(device);
        }

        if (!newQsDeviceList.isEmpty()) {
            updateAllQsDeviceStreamUrls(newQsDeviceList);
        }
    }

    /**
     * 获取计划记录对应的视频监控设备
     *
     * @param qsDevice 视频监控设备
     * @return
     */
    @Override
    public List<QsDevice> listPlanRecordQsDevice(QsDevice qsDevice) {
        return qsDeviceMapper.listPlanRecordQsDevice(qsDevice);
    }

    /**
     * 设备关联录制计划
     *
     * @param deviceIds
     * @param planId
     */
    @Override
    public void link(List<Long> deviceIds, Long planId) {
        qsDeviceMapper.link(deviceIds, planId);
    }

    /**
     * 清理设备计划id
     *
     * @param planId 设备id
     */
    @Override
    public void cleanRecordPlanId(Long planId) {
        qsDeviceMapper.cleanRecordPlanId(planId);
    }

    /**
     * 根据设备id集合查询设备信息
     *
     * @param startDeviceIdList 设备id集合
     * @return
     */
    @Override
    public List<QsDevice> queryByIds(List<Long> startDeviceIdList) {
        return qsDeviceMapper.queryByIds(startDeviceIdList);
    }

    /**
     * 根据计划id查询设备数量
     *
     * @param planId 设备id
     * @return
     */
    @Override
    public Integer countRecordPlanDevice(Long planId) {
        return qsDeviceMapper.countRecordPlanDevice(planId);
    }

    /**
     * 根据行政区划编码更新设备行政区划编码
     *
     * @param oldCivilCode 旧的行政区划编码
     * @param newCivilCode 新的行政区划编码
     */
    @Override
    public void updateCivilCode(String oldCivilCode, String newCivilCode) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByCivilCode(oldCivilCode);
        if (deviceList.isEmpty()) {
            return;
        }
        int result = qsDeviceMapper.updateCivilCodeByDeviceList(newCivilCode, deviceList);
    }

    /**
     * 根据行政区划编码删除设备
     *
     * @param allChildren 所有子节点
     */
    @Override
    public void removeCivilCode(List<QsRegion> allChildren) {
        qsDeviceMapper.removeCivilCode(allChildren);
    }

    /**
     * 根据设备id查询设备关联的行政区划树
     *
     * @param deviceId 区域国标编号
     * @return
     */
    @Override
    public List<QsRegionTree> queryForRegionTreeByCivilCode(String deviceId) {
        return qsDeviceMapper.queryForRegionTreeByCivilCode(deviceId);
    }

    /**
     * 根据业务分组更新设备业务分组
     *
     * @param oldBusinessGroup
     * @param newBusinessGroup
     */
    @Override
    public void updateBusinessGroup(String oldBusinessGroup, String newBusinessGroup) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByBusinessGroup(oldBusinessGroup);
        if (deviceList.isEmpty()) {
            log.info("[更新业务分组] 发现未关联任何设备： {}", oldBusinessGroup);
            return;
        }
        int result = qsDeviceMapper.updateBusinessGroupBydeviceList(newBusinessGroup, deviceList);
    }

    /**
     * 根据业务分组更新设备
     *
     * @param oldParentId
     * @param newParentId
     */
    @Override
    public void updateParentIdGroup(String oldParentId, String newParentId) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByParentId(oldParentId);
        if (deviceList.isEmpty()) {
            return;
        }
        int result = qsDeviceMapper.updateParentIdByDeviceList(newParentId, deviceList);
    }

    /**
     * 根据业务分组删除设备
     *
     * @param businessGroup
     */
    @Override
    public void removeParentIdByBusinessGroup(String businessGroup) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByBusinessGroup(businessGroup);
        if (deviceList.isEmpty()) {
            return;
        }
        int result = qsDeviceMapper.removeParentIdByDevices(deviceList);
    }

    /**
     * 根据业务分组删除设备
     *
     * @param groupList
     */
    @Override
    public void removeParentIdByGroupList(List<QsGroup> groupList) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByGroupList(groupList);
        if (deviceList.isEmpty()) {
            return;
        }
        qsDeviceMapper.removeParentIdByDevices(deviceList);
    }

    /**
     * 根据业务分组查询设备关联的业务分组树
     *
     * @param query
     * @param parent
     * @return
     */
    @Override
    public List<QsGroupTree> queryForGroupTreeByParentId(String query, String parent) {
        return qsDeviceMapper.queryForGroupTreeByParentId(query, parent);
    }

    /**
     * 根据行政区域获取视频监控设备列表
     *
     * @param qsDevice
     * @return
     */
    @Override
    public List<QsDevice> queryListByCivilCode(QsDevice qsDevice) {
        return qsDeviceMapper.queryListByCivilCode(qsDevice);
    }

    /**
     * 根据行政区划编码添加设备
     *
     * @param civilCode
     * @param deviceIds
     */
    @Override
    public void addDeviceToRegion(String civilCode, List<Long> deviceIds) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByIds(deviceIds);
        if (deviceList.isEmpty()) {
            throw new RuntimeException("所有设备Id不存在");
        }
        for (QsDevice device : deviceList) {
            device.setGbCivilCode(civilCode);
        }
        int result = qsDeviceMapper.updateRegion(civilCode, deviceList);
    }

    /**
     * 设备删除行政区划
     *
     * @param civilCode
     * @param deviceIds
     */
    @Override
    public void deleteDeviceToRegion(String civilCode, List<Long> deviceIds) {
        if (!ObjectUtils.isEmpty(civilCode)) {
            deleteToRegionByCivilCode(civilCode);
        }
        if (!ObjectUtils.isEmpty(deviceIds)) {
            deleteToRegionByChannelIds(deviceIds);
        }
    }

    /**
     * 存在行政区划但无法挂载的通道列表
     *
     * @param qsDevice
     * @return
     */
    @Override
    public List<QsDevice> queryListByCivilCodeForUnusual(QsDevice qsDevice) {
        return qsDeviceMapper.queryListByCivilCodeForUnusual(qsDevice);
    }

    /**
     * 清除存在行政区划但无法挂载的设备列表
     *
     * @param all
     * @param deviceIds
     */
    @Override
    public void clearDeviceCivilCode(Boolean all, List<Long> deviceIds) {
        List<Long> deviceIdsForClear;
        if (all != null && all) {
            deviceIdsForClear = qsDeviceMapper.queryAllForUnusualCivilCode();
        } else {
            deviceIdsForClear = deviceIds;
        }
        qsDeviceMapper.removeCivilCodeByDeviceIds(deviceIdsForClear);
    }

    /**
     * 获取编码列表
     *
     * @return
     */
    @Override
    public List<NetworkIdentificationType> getNetworkIdentificationTypeList() {
        NetworkIdentificationTypeEnum[] values = NetworkIdentificationTypeEnum.values();
        List<NetworkIdentificationType> result = new ArrayList<>(values.length);
        for (NetworkIdentificationTypeEnum value : values) {
            result.add(NetworkIdentificationType.getInstance(value));
        }
        Collections.sort(result);
        return result;
    }

    /**
     * 获取编码列表
     *
     * @return
     */
    @Override
    public List<DeviceType> getDeviceTypeList() {
        DeviceTypeEnum[] values = DeviceTypeEnum.values();
        List<DeviceType> result = new ArrayList<>(values.length);
        for (DeviceTypeEnum value : values) {
            result.add(DeviceType.getInstance(value));
        }
        Collections.sort(result);
        return result;
    }

    /**
     * 获取行业编码列表
     *
     * @return
     */
    @Override
    public List<IndustryCodeType> getIndustryCodeList() {
        IndustryCodeTypeEnum[] values = IndustryCodeTypeEnum.values();
        List<IndustryCodeType> result = new ArrayList<>(values.length);
        for (IndustryCodeTypeEnum value : values) {
            result.add(IndustryCodeType.getInstance(value));
        }
        Collections.sort(result);
        return result;
    }

    /**
     * 获取关联业务分组通道列表
     *
     * @param qsDevice
     * @return
     */
    @Override
    public List<QsDevice> queryListByParentId(QsDevice qsDevice) {
        return qsDeviceMapper.queryListByParentId(qsDevice);
    }

    /**
     * 设备设置业务分组
     *
     * @param parentId
     * @param businessGroup
     * @param deviceIds
     */
    @Override
    public void addChannelToGroup(String parentId, String businessGroup, List<Long> deviceIds) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByIds(deviceIds);
        if (deviceList.isEmpty()) {
            throw new RuntimeException("所有设备Id不存在");
        }
        int result = qsDeviceMapper.updateGroup(parentId, businessGroup, deviceList);
    }

    /**
     * 删除业务分组设备
     *
     * @param parentId
     * @param businessGroup
     * @param deviceIds
     */
    @Override
    public void deleteDeviceToGroup(String parentId, String businessGroup, List<Long> deviceIds) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByIds(deviceIds);
        if (deviceList.isEmpty()) {
            throw new RuntimeException("所有通道Id不存在");
        }
        qsDeviceMapper.removeParentIdByDevices(deviceList);
    }

    /**
     * 存在父节点编号但无法挂载的设备列表
     *
     * @param qsDevice
     * @return
     */
    @Override
    public List<QsDevice> queryListByParentForUnusual(QsDevice qsDevice) {
        return qsDeviceMapper.queryListByParentForUnusual(qsDevice);
    }

    /**
     * 清除存在分组节点但无法挂载的设备列表
     *
     * @param all
     * @param deviceIds
     */
    @Override
    public void clearDeviceParent(Boolean all, List<Long> deviceIds) {
        List<Long> deviceIdsForClear;
        if (all != null && all) {
            deviceIdsForClear = qsDeviceMapper.queryAllForUnusualParent();
        } else {
            deviceIdsForClear = deviceIds;
        }
        qsDeviceMapper.removeParentIdByDeviceIds(deviceIdsForClear);
    }

    /**
     * 获取设备统计信息
     *
     * @return
     */
    @Override
    public DeviceStats getDeviceStatistics() {
        return qsDeviceMapper.getDeviceStatistics();
    }

    /**
     * 新增视频监控设备
     *
     * @param qsDevice
     * @return
     */
    @Override
    public int addQsDevice(QsDevice qsDevice) {
        return qsDeviceMapper.insertQsDevice(qsDevice);
    }

    /**
     * 根据 gbDeviceId 更新设备在线状态
     *
     * @param gbDeviceId   国标设备编号
     * @param deviceStatus 设备状态
     * @return
     */
    @Override
    public Boolean updateDeviceStatusByGbDeviceId(String gbDeviceId, String deviceStatus) {
        // 先查询是否有对应的设备
        QsDevice queryDevice = new QsDevice();
        queryDevice.setGbDeviceId(gbDeviceId);
        List<QsDevice> deviceList = qsDeviceMapper.selectQsDeviceList(queryDevice);
        if (deviceList.isEmpty()) {
            log.warn("[更新设备状态] 未找到 gbDeviceId 对应的设备：{}", gbDeviceId);
            return false;
        }
        // 更新设备状态
        QsDevice qsDevice = new QsDevice();
        qsDevice.setId(deviceList.get(0).getId());
        qsDevice.setDeviceStatus(deviceStatus);
        int result = qsDeviceMapper.updateQsDevice(qsDevice);
        return result > 0;
    }

    /**
     * 根据 jtMobileNo 更新设备在线状态
     *
     * @param jtMobileNo   设备手机号
     * @param deviceStatus 设备状态
     * @return
     */
    @Override
    public Boolean updateDeviceStatusByJtMobileNo(String jtMobileNo, String deviceStatus) {
        // 先查询是否有对应的设备
        QsDevice queryDevice = new QsDevice();
        queryDevice.setJtMobileNo(jtMobileNo);
        List<QsDevice> deviceList = qsDeviceMapper.selectQsDeviceList(queryDevice);
        if (deviceList.isEmpty()) {
            log.warn("[更新设备状态] 未找到 jtMobileNo 对应的设备：{}", jtMobileNo);
            return false;
        }
        // 更新设备状态
        QsDevice qsDevice = new QsDevice();
        qsDevice.setId(deviceList.get(0).getId());
        qsDevice.setDeviceStatus(deviceStatus);
        int result = qsDeviceMapper.updateQsDevice(qsDevice);
        return result > 0;
    }

    private void deleteToRegionByChannelIds(List<Long> deviceIds) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByIds(deviceIds);
        if (deviceList.isEmpty()) {
            throw new RuntimeException("所有通道Id不存在");
        }
        int result = qsDeviceMapper.removeCivilCodeByDeletes(deviceList);
    }

    private void deleteToRegionByCivilCode(String civilCode) {
        List<QsDevice> deviceList = qsDeviceMapper.queryByCivilCode(civilCode);
        if (deviceList.isEmpty()) {
            throw new RuntimeException("所有设备Id不存在");
        }
        int result = qsDeviceMapper.removeCivilCodeByDeletes(deviceList);
    }

    /**
     * 录制计划关联所有设备
     *
     * @param planId
     */
    @Override
    public void linkAll(Long planId) {
        qsDeviceMapper.linkAll(planId);
    }

    /**
     * 录制计划取消关联所有设备
     *
     * @param planId
     */
    @Override
    public void cleanAll(Long planId) {
        qsDeviceMapper.cleanAll(planId);
    }

    /**
     * 判断是否为合法的 RTSP 地址格式
     *
     * @param url 直播地址
     * @return true 表示格式正确且为 RTSP 协议
     */
    public static boolean isValidRtspFormat(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }

        try {
            URI uri = new URI(url);
            // 1. 检查协议头是否为 rtsp
            if (!"rtsp".equalsIgnoreCase(uri.getScheme())) {
                return false;
            }
            // 2. 检查是否有主机地址（防止 rtsp:// 这种空地址）
            return uri.getHost() != null;
        } catch (URISyntaxException e) {
            return false;
        }
    }

    /**
     * 使用正则表达式判断是否为合法的 RTMP 地址
     * 匹配规则：rtmp:// + 域名/IP + 可选端口 + 路径
     */
    public static boolean isValidRtmpFormat(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }

        // 正则解释：
        // ^rtmp://              : 必须以 rtmp:// 开头
        // [a-zA-Z0-9-.]+        : 域名或IP
        // (:[\\d]{1,5})?        : 可选的端口号 (如 :1935)
        // /.*                   : 后面必须跟斜杠和路径（应用名/流ID）
        String regex = "^rtmp://[a-zA-Z0-9-.]+(:[\\d]{1,5})?/.*$";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(url);

        return matcher.matches();
    }

    /**
     * 判断是否为合法的 FLV 地址
     * 规则：
     * 1. 协议头支持：http://, https://, ws://, wss://
     * 2. 必须以 .flv 结尾（忽略大小写）
     * 3. 允许后面跟随查询参数（如 ?token=xxx）
     */
    public static boolean isValidFlvAddress(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }

        // 正则解释：
        // ^https?://       : 匹配 http:// 或 https://
        // |                : 或者
        // wss?://          : 匹配 ws:// 或 wss://
        // .+               : 匹配中间的域名和路径
        // \.flv            : 必须以 .flv 结尾
        // (\\?.*)?$        : 允许后面跟随 ? 开头的参数（可选）
        String regex = "^(https?|wss?)://.+\\.flv(\\?.*)?$";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(url);

        return matcher.matches();
    }

    /**
     * 判断是否为合法的 HLS 地址
     * 规则：必须以 http:// 或 https:// 开头，且以 .m3u8 结尾（忽略大小写，允许带参数）
     */
    public static boolean isValidHlsAddress(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }

        // 正则解释：
        // ^https?://       : 匹配 http:// 或 https://
        // .+               : 匹配中间的域名和路径
        // \.m3u8           : 必须以 .m3u8 结尾
        // (\\?.*)?$        : 允许后面跟随 ? 开头的参数（如 token=xxx），且参数是可选的
        String regex = "^https?://.+\\.m3u8(\\?.*)?$";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(url);

        return matcher.matches();
    }

    /**
     * 判断是否为合法的 MP4 地址
     * 规则：必须以 http:// 或 https:// 开头，且以 .mp4 结尾（忽略大小写，允许带参数）
     */
    public static boolean isValidMp4Address(String url) {
        if (url == null || url.trim().isEmpty()) {
            return false;
        }

        // 正则解释：
        // ^https?://       : 匹配 http:// 或 https://
        // .+               : 匹配中间的域名和路径
        // \.mp4            : 必须以 .mp4 结尾
        // (\\?.*)?$        : 允许后面跟随 ? 开头的参数（如 token=xxx），且参数是可选的
        String regex = "^https?://.+\\.mp4(\\?.*)?$";

        Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(url);

        return matcher.matches();
    }

    /**
     * 判断 URL 协议类型 (无前缀版本)
     */
    public static String getProtocolTypeSimple(String url) {
        if (url == null) return null;

        // 转小写以防万一
        String lowerUrl = url.toLowerCase();

        if (lowerUrl.startsWith("http://") || lowerUrl.startsWith("https://")) {
            return "flv";
        }

        if (lowerUrl.startsWith("ws://") || lowerUrl.startsWith("wss://")) {
            return "ws";
        }

        return null;
    }

    /**
     * 将方向字符串转换为海康 ISUP PTZ 命令码
     */
    private int convertDirectionToHikIsupPtz(String direction) {
        if (direction == null || direction.isEmpty()) {
            throw new RuntimeException("云台控制方向不能为空");
        }
        String lowerDir = direction.toLowerCase();
        switch (lowerDir) {
            case "up":
            case "tilt_up":
                return 0; // PTZ_UP
            case "down":
            case "tilt_down":
                return 1; // PTZ_DOWN
            case "left":
            case "pan_left":
                return 2; // PTZ_LEFT
            case "right":
            case "pan_right":
                return 3; // PTZ_RIGHT
            case "upleft":
            case "up_left":
                return 4; // PTZ_UPLEFT
            case "downleft":
            case "down_left":
                return 5; // PTZ_DOWNLEFT
            case "upright":
            case "up_right":
                return 6; // PTZ_UPRIGHT
            case "downright":
            case "down_right":
                return 7; // PTZ_DOWNRIGHT
            case "zoomin":
            case "zoom_in":
                return 8; // PTZ_ZOOMIN
            case "zoomout":
            case "zoom_out":
                return 9; // PTZ_ZOOMOUT
            case "near":
            case "focus_near":
                return 10; // PTZ_FOCUSNEAR
            case "far":
            case "focus_far":
                return 11; // PTZ_FOCUSFAR
            case "in":
            case "iris_open":
                return 12; // PTZ_IRISSTARTUP
            case "out":
            case "iris_close":
                return 13; // PTZ_IRISSTOPDOWN
            default:
                throw new RuntimeException("不支持的云台控制方向: " + direction);
        }
    }

    @Override
    public void startPtz(Long id, String direction, Integer controlSpeed) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        Integer channel = device.getChannel() != null ? device.getChannel() : 0;
        String deviceType = device.getType();

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            // GB28181协议
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            // 根据控制类型调用不同的 GB28181 接口
            String controlType = getPtzControlType(direction);
            Integer speed = (controlSpeed != null) ? controlSpeed : 50;

            switch (controlType) {
                case "rotate":
                    Integer horizonSpeed = speed;
                    Integer verticalSpeed = speed;
                    Integer zoomSpeed = (speed / 10);
                    remoteGb28181Service.ptz(device.getGbDeviceId(), device.getGbChannelId(), direction, horizonSpeed
                            , verticalSpeed, zoomSpeed, SecurityConstants.INNER);
                    break;
                case "focus":
                    remoteGb28181Service.focus(device.getGbDeviceId(), device.getGbChannelId(), direction, speed,
                            SecurityConstants.INNER);
                    break;
                case "iris":
                    remoteGb28181Service.iris(device.getGbDeviceId(), device.getGbChannelId(), direction, speed,
                            SecurityConstants.INNER);
                    break;
                case "zoom":
                    // GB28181 的缩放通过 ptz 接口处理
                    Integer horizonSpeedForZoom = 0;
                    Integer verticalSpeedForZoom = 0;
                    Integer zoomSpeedForZoom = speed;
                    remoteGb28181Service.ptz(device.getGbDeviceId(), device.getGbChannelId(), direction,
                            horizonSpeedForZoom, verticalSpeedForZoom, zoomSpeedForZoom, SecurityConstants.INNER);
                    break;
                default:
                    throw new RuntimeException("不支持的云台控制类型: " + controlType);
            }

        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }

    private String getPtzControlType(String direction) {
        switch (direction) {
            case "up":
            case "down":
            case "left":
            case "right":
                return "rotate";
            case "zoomin":
            case "zoomout":
                return "zoom";
            case "near":
            case "far":
                return "focus";
            case "in":
            case "out":
                return "iris";
            default:
                return "rotate";
        }
    }

    @Override
    public void endPtz(Long id, String direction, Integer controlSpeed) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        Integer channel = device.getChannel() != null ? device.getChannel() : 0;
        String deviceType = device.getType();

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            // GB28181协议
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            // 根据控制类型调用不同的 GB28181 停止接口
            String controlType = getPtzControlType(direction);
            String stopCommand = "stop";
            Integer stopSpeed = 0;

            switch (controlType) {
                case "rotate":
                    remoteGb28181Service.ptz(device.getGbDeviceId(), device.getGbChannelId(), stopCommand, 0, 0, 0,
                            SecurityConstants.INNER);
                    break;
                case "focus":
                    remoteGb28181Service.focus(device.getGbDeviceId(), device.getGbChannelId(), stopCommand,
                            stopSpeed, SecurityConstants.INNER);
                    break;
                case "iris":
                    remoteGb28181Service.iris(device.getGbDeviceId(), device.getGbChannelId(), stopCommand, stopSpeed
                            , SecurityConstants.INNER);
                    break;
                case "zoom":
                    remoteGb28181Service.ptz(device.getGbDeviceId(), device.getGbChannelId(), stopCommand, 0, 0, 0,
                            SecurityConstants.INNER);
                    break;
                default:
                    // 默认调用 ptz 停止
                    remoteGb28181Service.ptz(device.getGbDeviceId(), device.getGbChannelId(), stopCommand, 0, 0, 0,
                            SecurityConstants.INNER);
                    break;
            }

        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }


    @Override
    public List<Preset> getPresetList(Long id, Integer channelId) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        String deviceType = device.getType();
        Integer channel = channelId != null ? channelId : (device.getChannel() != null ? device.getChannel() : 0);

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            R<Object> result = remoteGb28181Service.queryPreset(device.getGbDeviceId(), device.getGbChannelId(),
                    SecurityConstants.INNER);
            Object data = result.getData();
            List<Preset> presetList = new ArrayList<>();
            if (data instanceof List) {
                List<?> list = (List<?>) data;
                for (Object item : list) {
                    if (item instanceof Map) {
                        Map<?, ?> map = (Map<?, ?>) item;
                        Preset preset = new Preset();
                        Object indexObj = map.get("index");
                        Object nameObj = map.get("name");
                        preset.setIndex(indexObj != null ? Integer.parseInt(indexObj.toString()) : null);
                        preset.setName(nameObj != null ? nameObj.toString() : null);
                        presetList.add(preset);
                    }
                }
            }
            return presetList;
        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }

    @Override
    public void setPreset(Long id, Integer channelId, Integer presetIndex, String presetName) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        String deviceType = device.getType();
        Integer channel = channelId != null ? channelId : (device.getChannel() != null ? device.getChannel() : 0);

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            remoteGb28181Service.addPreset(device.getGbDeviceId(), device.getGbChannelId(), presetIndex,
                    SecurityConstants.INNER);
        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }

    @Override
    public void gotoPreset(Long id, Integer channelId, Integer presetIndex, Integer speed) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        String deviceType = device.getType();
        Integer channel = channelId != null ? channelId : (device.getChannel() != null ? device.getChannel() : 0);
        Integer useSpeed = speed != null ? speed : 50;

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            remoteGb28181Service.callPreset(device.getGbDeviceId(), device.getGbChannelId(), presetIndex,
                    SecurityConstants.INNER);
        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }

    @Override
    public void deletePreset(Long id, Integer channelId, Integer presetIndex) {
        QsDevice device = selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        String deviceType = device.getType();
        Integer channel = channelId != null ? channelId : (device.getChannel() != null ? device.getChannel() : 0);

        if (LiveStreamType.GB28181.getCode().equals(deviceType)) {
            if (device.getGbDeviceId() == null || device.getGbChannelId() == null) {
                throw new RuntimeException("设备未配置 GB28181 设备ID或通道ID");
            }
            remoteGb28181Service.deletePreset(device.getGbDeviceId(), device.getGbChannelId(), presetIndex,
                    SecurityConstants.INNER);
        } else {
            throw new RuntimeException("不支持的设备类型: " + deviceType);
        }
    }

    @Override
    public void getVideoSnapshot(Long id) {
        QsDevice device = this.selectQsDeviceById(id);
        if (device == null) {
            throw new RuntimeException("设备不存在");
        }

        if (device.getLiveAddress() == null || device.getLiveAddress().isEmpty()) {
            throw new RuntimeException("设备直播地址为空");
        }

        try {
//            String videoPath = convertUrlToPath(device.getLiveAddress(), this.fileDomain, this.filePrefix, this.filePath);
//
//            String fileName = "/video_file-" + device.getDeviceCode() + ".jpg";
//
//            String savePath = this.filePath + "/snap" + fileName;

            // 截取第 1 秒的画面
          //  videoSnapshotUtil.takeSnapshot(videoPath, savePath, 1.0);

         //   String filePath = fileDomain + filePrefix + "/snap/" + fileName;
            // 通过文件服务上传到 MinIO
//            File snapFile = new File(localSnapPath);
//            FileMultipartFile multipartFile = new FileMultipartFile(snapFile, fileName, "image/jpeg");
//            R<SysFile> fileResult = remoteFileService.upload(multipartFile);
//            if (fileResult == null || fileResult.getData() == null) {
//                throw new RuntimeException("上传截图到文件服务失败");
//            }
//
//            QsDevice qsDevice = new QsDevice();
//            qsDevice.setId(id);
//            qsDevice.setSnap(filePath);
//            this.updateQsDevice(qsDevice);
        } catch (Exception e) {
            log.error("[获取视频截图失败] 设备ID: {}, 错误: {}", id, e.getMessage());
        }
    }
}