package com.ard.vtdu.service.impl;

import com.ard.common.utils.DateUtils;
import com.ard.vtdu.domain.ArdVtdu;
import com.ard.vtdu.domain.Conf;
import com.ard.vtdu.mapper.ArdVtduMapper;
import com.ard.vtdu.service.IArdVtduService;
import com.ard.vtdu.service.IArdMediaService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * 流媒体管理Service业务层处理
 *
 * @author ard
 * @date 2023-08-29
 */
@Service
@Slf4j
public class ArdVtduServiceImpl implements IArdVtduService {
    @Resource
    private ArdVtduMapper ardVtduMapper;
    @Resource
    private IArdMediaService mediaService;



    @PostConstruct
    public void initMediaMTX() {
        //清空mediamtx流媒体数据
        mediaService.clearAll();
    }

    @Scheduled(cron = "0/5 * * * * ?")
    public void syncMediamtx() {
        log.debug("定时同步MediaMTX任务");
        List<String> nameList = mediaService.getNameList();
        List<ArdVtdu> ardVtduList = selectArdVtduList(new ArdVtdu());
        asyncMediaMTX(ardVtduList, nameList);
    }

    /**
     * 查询流媒体管理
     *
     * @param name 流媒体管理主键
     * @return 流媒体管理
     */
    @Override
    public ArdVtdu selectArdVtduByName(String name) {
        return ardVtduMapper.selectArdVtduByName(name);
    }

    /**
     * 查询流媒体管理列表
     *
     * @param ardVtdu 流媒体管理
     * @return 流媒体管理
     */
    @Override
    public List<ArdVtdu> selectArdVtduList(ArdVtdu ardVtdu) {
        return ardVtduMapper.selectArdVtduList(ardVtdu);
    }

    /**
     * 新增流媒体管理
     *
     * @param ardVtdu 流媒体管理
     * @return 结果
     */
    @Override
    public int insertArdVtdu(ArdVtdu ardVtdu) {
        ardVtdu = mediaService.addPath(ardVtdu);
        return ardVtduMapper.insertArdVtdu(ardVtdu);
    }

    /**
     * 修改流媒体管理
     *
     * @param ardVtdu 流媒体管理
     * @return 结果
     */
    @Override
    public int updateArdVtdu(ArdVtdu ardVtdu) {
        ardVtdu = mediaService.editPath(ardVtdu);
        ardVtdu.setUpdateTime(DateUtils.getNowDate());
        return ardVtduMapper.updateArdVtdu(ardVtdu);
    }

    /**
     * 批量删除流媒体管理
     *
     * @param names 需要删除的数据主键集合
     * @return 结果
     */
    @Override
    public int deleteArdVtduByNames(String[] names) {
        for (String name : names) {
            log.debug("流媒体【" + name + "】通道删除");
        }
        mediaService.removePath(names);
        return ardVtduMapper.deleteArdVtduByNames(names);
    }

    /**
     * 删除流媒体管理
     *
     * @param name 流媒体通道名称
     * @return 结果
     */
    @Override
    public int deleteArdVtduByName(String name) {
        mediaService.removePath(name);
        log.debug("流媒体【" + name + "】通道删除");
        return ardVtduMapper.deleteArdVtduByName(name);
    }

    /**
     * 删除流媒体管理信息
     *
     * @param cameraId 相机ID
     * @return 结果
     */
    @Override
    public int deleteArdVtduByCameraId(String cameraId) {
        return ardVtduMapper.deleteArdVtduByCameraId(cameraId);
    }

    /**
     * 清除所有流媒体数据
     *
     * @author 刘苏义
     * @date 2024/7/10 13:31
     */
    @Override
    public void clearAllArdVtdu() {
        ardVtduMapper.clearAllArdVtdu();
    }

    //需要更新的（流媒体和vtdu相同）
    @Override
    public List<ArdVtdu> sameList(List<ArdVtdu> vtduses, List<String> names) {
        return vtduses.stream().filter(vtdu -> names.contains(vtdu.getName())).collect(Collectors.toList());
    }

    //需要删除的（流媒体中多的）
    @Override
    public List<String> diffListToDel(List<ArdVtdu> vtduses, List<String> names) {
        if (vtduses.size() >= names.size()) {
            List<String> nameList = vtduses.stream().map(ArdVtdu::getName)
                    .filter(item -> !names.contains(item))
                    .collect(Collectors.toList());
            return nameList;
        } else {
            List<String> nameList =
                    names.stream().filter(item -> !vtduses.stream().map(ArdVtdu::getName).collect(Collectors.toList()).contains(item))
                    .collect(Collectors.toList());
            return nameList;
        }
    }

    //需要新增的（流媒体中少的）
    @Override
    public List<ArdVtdu> diffListToAdd(List<ArdVtdu> vtduses, List<String> names) {
        return vtduses.stream().filter(vtdu -> !names.contains(vtdu.getName())).collect(Collectors.toList());
    }

    /**
     * @return
     * @Author 刘苏义
     * @Description 同步本地vtdu库和流媒体中的数据
     * @Date 2024/7/10 15:26
     * @Param vtdus vtdu库的集合
     * @Param names 流媒体的name集合
     */
    @Override
    public void asyncMediaMTX(List<ArdVtdu> vtdus, List<String> names) {
        //需要更新的数据,参数顺序注意
        sameList(vtdus, names).forEach(vtdu -> {
            Conf conf = mediaService.getPathConfig(vtdu.getName());
            if (conf == null || conf.getSource() == null) {
                return;
            }
            String currentRtspSource = vtdu.getRtspSource();  // 提前获取需要比对的RTSP源
            String confRtspSource = conf.getSource();

            // 比较 RTSP 源是否一致
            boolean isRtspSourceChanged = !Objects.equals(confRtspSource, currentRtspSource);
            // 如果 RTSP 源发生变化，则更新路径
            if (isRtspSourceChanged) {
                mediaService.editPath(vtdu);
            }
        });
        //需要删除的数据
        diffListToDel(vtdus, names).forEach(name -> {
            mediaService.removePath(name);
        });
        //需要新增的数据
        diffListToAdd(vtdus, names).forEach(vtdu -> {
            mediaService.addPath(vtdu);
        });
    }

    //匹配rtsp地址
    private String matchRtsp(String value) {
        Matcher matcher = Pattern.compile("rtsp://[^\\s\"]+").matcher(value);
        if (matcher.find()) {
            return matcher.group();
        } else {
            return "";
        }
    }
}