package com.ruoyi.inspect.service.impl;

import java.text.SimpleDateFormat;
import java.util.*;

import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;
import com.ruoyi.alarmpoints.well.mapper.ArdAlarmpointsWellMapper;
import com.ruoyi.alarmpoints.well.service.IArdAlarmpointsWellService;
import com.ruoyi.common.utils.DateUtils;

import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import com.ruoyi.device.hiksdk.service.IHikClientService;
import com.ruoyi.inspect.domain.ArdVideoInspectRecord;
import com.ruoyi.inspect.mapper.ArdVideoInspectRecordMapper;
import com.ruoyi.inspect.service.IArdVideoInspectRecordService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.SecurityUtils;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.inspect.domain.ArdVideoInspectTaskStep;
import com.ruoyi.inspect.mapper.ArdVideoInspectTaskMapper;
import com.ruoyi.inspect.domain.ArdVideoInspectTask;
import com.ruoyi.inspect.service.IArdVideoInspectTaskService;

import javax.annotation.Resource;

/**
 * 视频巡检任务Service业务层处理
 *
 * @author ruoyi
 * @date 2023-05-30
 */
@Service
@Slf4j
public class ArdVideoInspectTaskServiceImpl implements IArdVideoInspectTaskService {
    @Resource
    private ArdVideoInspectTaskMapper ardVideoInspectTaskMapper;
    @Resource
    private ArdAlarmpointsWellMapper ardAlarmpointsWellMapper;
    @Resource
    private ArdVideoInspectRecordMapper ardVideoInspectRecordMapper;
    @Resource
    private ArdCamerasMapper ardCamerasMapper;
    @Resource
    private IHikClientService hikClientService;

    /**
     * 查询视频巡检任务
     *
     * @param id 视频巡检任务主键
     * @return 视频巡检任务
     */
    @Override
    public ArdVideoInspectTask selectArdVideoInspectTaskById(String id) {
        return ardVideoInspectTaskMapper.selectArdVideoInspectTaskById(id);
    }

    /**
     * 查询视频巡检任务列表
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 视频巡检任务
     */
    @Override
    public List<ArdVideoInspectTask> selectArdVideoInspectTaskList(ArdVideoInspectTask ardVideoInspectTask) {
        return ardVideoInspectTaskMapper.selectArdVideoInspectTaskList(ardVideoInspectTask);
    }

    /**
     * 新增视频巡检任务
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 结果
     */
    @Transactional
    @Override
    public int insertArdVideoInspectTask(ArdVideoInspectTask ardVideoInspectTask) {
        ardVideoInspectTask.setCreateBy(SecurityUtils.getUsername());
        ardVideoInspectTask.setCreateTime(DateUtils.getNowDate());
        ardVideoInspectTask.setUserId(SecurityUtils.getUserId());
        int rows = ardVideoInspectTaskMapper.insertArdVideoInspectTask(ardVideoInspectTask);
        insertArdVideoInspectTaskStep(ardVideoInspectTask);
        return rows;
    }

    /**
     * 修改视频巡检任务
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 结果
     */
    @Transactional
    @Override
    public int updateArdVideoInspectTask(ArdVideoInspectTask ardVideoInspectTask) {
        ardVideoInspectTask.setUpdateBy(SecurityUtils.getUsername());
        ardVideoInspectTask.setUpdateTime(DateUtils.getNowDate());
        ardVideoInspectTaskMapper.deleteArdVideoInspectTaskStepByTaskId(ardVideoInspectTask.getId())
        ;
        insertArdVideoInspectTaskStep(ardVideoInspectTask);
        return ardVideoInspectTaskMapper.updateArdVideoInspectTask(ardVideoInspectTask);
    }

    @Override
    public int updateArdVideoInspectTaskNoUpdater(ArdVideoInspectTask ardVideoInspectTask) {
        return ardVideoInspectTaskMapper.updateArdVideoInspectTask(ardVideoInspectTask);
    }

    /**
     * 批量删除视频巡检任务
     *
     * @param ids 需要删除的视频巡检任务主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteArdVideoInspectTaskByIds(String[] ids) {
        ardVideoInspectTaskMapper.deleteArdVideoInspectTaskStepByTaskIds(ids);
        return ardVideoInspectTaskMapper.deleteArdVideoInspectTaskByIds(ids);
    }

    /**
     * 删除视频巡检任务信息
     *
     * @param id 视频巡检任务主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteArdVideoInspectTaskById(String id) {
        ardVideoInspectTaskMapper.deleteArdVideoInspectTaskStepByTaskId(id);
        return ardVideoInspectTaskMapper.deleteArdVideoInspectTaskById(id);
    }

    /**
     * 新增视频巡检步骤信息
     *
     * @param ardVideoInspectTask 视频巡检任务对象
     */
    public void insertArdVideoInspectTaskStep(ArdVideoInspectTask ardVideoInspectTask) {
        List<ArdVideoInspectTaskStep> ardVideoInspectTaskStepList = ardVideoInspectTask.getArdVideoInspectTaskStepList();
        String id = ardVideoInspectTask.getId();
        if (StringUtils.isNotNull(ardVideoInspectTaskStepList)) {
            List<ArdVideoInspectTaskStep> list = new ArrayList<ArdVideoInspectTaskStep>();
            for (ArdVideoInspectTaskStep ardVideoInspectTaskStep : ardVideoInspectTaskStepList) {
                ardVideoInspectTaskStep.setTaskId(id);
                list.add(ardVideoInspectTaskStep);
            }
            if (list.size() > 0) {
                ardVideoInspectTaskMapper.batchArdVideoInspectTaskStep(list);
            }
        }
    }


    /**
     * 手动巡检任务
     */
    @Override
    public void manualTaskRun() {
        /*扫描所有可执行任务1-时间满足2-自动*/
        ArdVideoInspectTask ardVideoInspectTask = new ArdVideoInspectTask();
        ardVideoInspectTask.setInspectMode("手动");
        ardVideoInspectTask.setMenualSwitch("开");
        List<ArdVideoInspectTask> ardVideoInspectTasks = ardVideoInspectTaskMapper.selectArdVideoInspectTaskList(ardVideoInspectTask);
        for (ArdVideoInspectTask videoInspectTask : ardVideoInspectTasks) {
            /*获取当前任务的所有巡检步骤*/
            List<ArdVideoInspectTaskStep> ardVideoInspectTaskStepList = ardVideoInspectTaskMapper.selectArdVideoInspectTaskById(videoInspectTask.getId()).getArdVideoInspectTaskStepList();
            if (ardVideoInspectTaskStepList.size() == 0) {
                continue;
            }
            videoInspectTask.setArdVideoInspectTaskStepList(ardVideoInspectTaskStepList);
            String currentStepId = videoInspectTask.getCurrentStepId();
            if (StringUtils.isNull(currentStepId)) {
                videoInspectTask.setCurrentStepId(ardVideoInspectTaskStepList.get(0).getId());
                startRunStep(videoInspectTask);//开始当前任务的第一个步骤
            } else /*当前任务已经执行，判断是否到期*/ {
                if (StringUtils.isNull(videoInspectTask.getCurrentStepStartTime())) {
                    //当前任务启动时间为null，则说明当前步骤被中断，直接启动当前步骤
                    startRunStep(videoInspectTask);
                } else {
                    boolean expird = isExpirdStep(videoInspectTask); /*判断当前步骤时间是否过期*/
                    if (expird) {
                        //停止录像
                        stopRunStep(videoInspectTask);
                        //切换步骤
                        String nextStepId = changeNextStep(videoInspectTask);
                        //开始下一步骤
                        videoInspectTask.setCurrentStepId(nextStepId);
                        startRunStep(videoInspectTask);
                    }
                }
            }
        }
    }

    /**
     * 自动巡检任务
     */
    @Override
    public void autoTaskRun() {
        /*扫描所有可执行任务1-时间满足2-自动*/
        ArdVideoInspectTask ardVideoInspectTask = new ArdVideoInspectTask();
        ardVideoInspectTask.setInspectMode("自动");
        List<ArdVideoInspectTask> ardVideoInspectTasks = ardVideoInspectTaskMapper.selectArdVideoInspectTaskList(ardVideoInspectTask);
        for (ArdVideoInspectTask videoInspectTask : ardVideoInspectTasks) {
            /*遍历所有时间满足的自动任务*/
            boolean timeCompare = DateUtils.TimeCompare(videoInspectTask.getStartTime(), videoInspectTask.getEndTime());
            if (timeCompare) {
                log.info("自动任务启动：" + videoInspectTask.getId());
                /*获取当前任务的所有巡检步骤*/
                List<ArdVideoInspectTaskStep> ardVideoInspectTaskStepList = ardVideoInspectTaskMapper.selectArdVideoInspectTaskById(videoInspectTask.getId()).getArdVideoInspectTaskStepList();
                if (ardVideoInspectTaskStepList.size() == 0) {
                    continue;
                }
                videoInspectTask.setArdVideoInspectTaskStepList(ardVideoInspectTaskStepList);
                String currentStepId = videoInspectTask.getCurrentStepId();
                if (StringUtils.isNull(currentStepId)) {
                    videoInspectTask.setCurrentStepId(ardVideoInspectTaskStepList.get(0).getId());
                    startRunStep(videoInspectTask);//开始当前任务的第一个步骤
                } else /*当前任务已经执行，判断是否到期*/ {
                    if (StringUtils.isNull(videoInspectTask.getCurrentStepStartTime())) {
                        //当前任务启动时间为null，则说明当前步骤被中断，直接启动当前步骤
                        startRunStep(videoInspectTask);
                    } else {
                        boolean expird = isExpirdStep(videoInspectTask); /*判断当前步骤时间是否过期*/
                        if (expird) {
                            //停止录像
                            stopRunStep(videoInspectTask);
                            //切换步骤
                            String nextStepId = changeNextStep(videoInspectTask);
                            //开始下一步骤
                            videoInspectTask.setCurrentStepId(nextStepId);
                            startRunStep(videoInspectTask);
                        }
                    }
                }
            }
        }
    }
    @Override
    public void taskRun() {
        /*扫描所有可执行任务1-时间满足2-自动*/
        ArdVideoInspectTask ardVideoInspectTask = new ArdVideoInspectTask();
        List<ArdVideoInspectTask> ardVideoInspectTasks = ardVideoInspectTaskMapper.selectArdVideoInspectTaskList(ardVideoInspectTask);
        for (ArdVideoInspectTask videoInspectTask : ardVideoInspectTasks) {
            if (videoInspectTask.getInspectMode().equals("自动")) {
                boolean timeCompare = DateUtils.TimeCompare(videoInspectTask.getStartTime(), videoInspectTask.getEndTime());
                if (!timeCompare) {
                    continue;
                }
            } else {
                if (videoInspectTask.getMenualSwitch().equals("关")) {
                    continue;
                }
            }
            /*获取当前任务的所有巡检步骤*/
            List<ArdVideoInspectTaskStep> ardVideoInspectTaskStepList = ardVideoInspectTaskMapper.selectArdVideoInspectTaskById(videoInspectTask.getId()).getArdVideoInspectTaskStepList();
            if (ardVideoInspectTaskStepList.size() == 0) {
                continue;
            }
            videoInspectTask.setArdVideoInspectTaskStepList(ardVideoInspectTaskStepList);
            String currentStepId = videoInspectTask.getCurrentStepId();
            if (StringUtils.isNull(currentStepId)) {
                videoInspectTask.setCurrentStepId(ardVideoInspectTaskStepList.get(0).getId());
                startRunStep(videoInspectTask);//开始当前任务的第一个步骤
            } else /*当前任务已经执行，判断是否到期*/ {
                if (StringUtils.isNull(videoInspectTask.getCurrentStepStartTime())) {
                    //当前任务启动时间为null，则说明当前步骤被中断，直接启动当前步骤
                    startRunStep(videoInspectTask);
                } else {
                    boolean expird = isExpirdStep(videoInspectTask); /*判断当前步骤时间是否过期*/
                    if (expird) {
                        //停止录像
                        stopRunStep(videoInspectTask);
                        //切换步骤
                        String nextStepId = changeNextStep(videoInspectTask);
                        //开始下一步骤
                        videoInspectTask.setCurrentStepId(nextStepId);
                        startRunStep(videoInspectTask);
                    }
                }
            }
        }
    }

    //步骤开始
    private void startRunStep(ArdVideoInspectTask ardVideoInspectTask) {
        try {
            String currentStepId = ardVideoInspectTask.getCurrentStepId();
            if (StringUtils.isNull(currentStepId)) {
                log.info("当前开始巡检步骤id为空");
                return;
            }
            log.info("步骤：" + currentStepId + "开始");
            String cameraId = ardVideoInspectTask.getCameraId();
            Integer channel = ardVideoInspectTask.getChannel();
            Optional<ArdVideoInspectTaskStep> objectOptional = ardVideoInspectTask.getArdVideoInspectTaskStepList().stream()
                    .filter(obj -> obj.getId().equals(currentStepId))
                    .findFirst();
            if (objectOptional.isPresent()) {
                ArdVideoInspectTaskStep step = objectOptional.get();
                String wellId = step.getWellId();
                if (!StringUtils.isNull(wellId)) {
                    /*获取井坐标*/
                    ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellById(wellId);
                    double[] targetPositon = new double[3];
                    targetPositon[0] = ardAlarmpointsWell.getLongitude();
                    targetPositon[1] = ardAlarmpointsWell.getLatitude();
                    targetPositon[2] = ardAlarmpointsWell.getAltitude();
                    /*获取相机坐标*/
                    ArdCameras cameras = ardCamerasMapper.selectArdCamerasById(cameraId);
                    double[] cameraPositon = new double[3];
                    cameraPositon[0] = cameras.getLongitude();
                    cameraPositon[1] = cameras.getLatitude();
                    cameraPositon[2] = cameras.getAltitude();
                    /*控制相机巡检*/
                    CameraCmd cmd = new CameraCmd();
                    cmd.setCameraId(cameraId);
                    cmd.setChannelNum(channel);
                    cmd.setCamPosition(cameraPositon);
                    cmd.setTargetPosition(targetPositon);
                    cmd.setOperator("sys_patrol_inspect");
                    cmd.setExpired(step.getRecordingTime());
                    boolean setTargetPosition = hikClientService.setTargetPosition(cmd);
                    if (setTargetPosition) {
                        /*控制相机巡检成功，开始录像*/
                        cmd.setEnable(true);//启动录像
                        hikClientService.recordToMinio(cmd);
                        /*更新任务当前步骤id和步骤启动时间*/
                        ArdVideoInspectTask avit = new ArdVideoInspectTask();
                        avit.setId(ardVideoInspectTask.getId());
                        avit.setCurrentStepId(step.getId());
                        avit.setCurrentStepStartTime(DateUtils.getTime());
                        ardVideoInspectTaskMapper.updateArdVideoInspectTask(avit);
                    } else {
                        cmd.setEnable(false);//停止录像
                        hikClientService.recordToMinio(cmd);
                        /*控制失败,当前步骤启动时间置null*/
                        ArdVideoInspectTask avit = new ArdVideoInspectTask();
                        avit.setId(ardVideoInspectTask.getId());
                        avit.setCurrentStepId(step.getId());
                        avit.setCurrentStepStartTime(null);
                        ardVideoInspectTaskMapper.updateArdVideoInspectTask(avit);
                    }
                }
            }
        } catch (Exception ex) {
            log.error("巡检开始异常：" + ex.getMessage());
        }
    }

    //步骤停止
    private void stopRunStep(ArdVideoInspectTask ardVideoInspectTask) {
        try {
            String currentStepId = ardVideoInspectTask.getCurrentStepId();
            log.info("步骤：" + currentStepId + "停止");
            if (StringUtils.isNull(currentStepId)) {
                log.info("当前停止巡检步骤id为空");
                return;
            }
            String currentStepStartTime = ardVideoInspectTask.getCurrentStepStartTime();
            String cameraId = ardVideoInspectTask.getCameraId();
            Integer channel = ardVideoInspectTask.getChannel();
            Optional<ArdVideoInspectTaskStep> objectOptional = ardVideoInspectTask.getArdVideoInspectTaskStepList().stream()
                    .filter(obj -> obj.getId().equals(currentStepId))
                    .findFirst();
            if (objectOptional.isPresent()) {
                ArdVideoInspectTaskStep step = objectOptional.get();
                /*停止录像*/
                CameraCmd cmd = new CameraCmd();
                cmd.setCameraId(cameraId);
                cmd.setChannelNum(channel);
                cmd.setOperator("sys_patrol_inspect");
                cmd.setEnable(false);//停止录像
                String uuid = UUID.randomUUID().toString().replace("-", "");
                String time = new SimpleDateFormat("yyyyMMdd").format(new Date());
                String recordName = cameraId + "/" + time + "/" + uuid + ".mp4";
                cmd.setRecordBucketName("record");
                cmd.setRecordObjectName(recordName);
                hikClientService.recordToMinio(cmd);
                /*插入巡检记录*/
                ArdVideoInspectRecord ardVideoInspectRecord = new ArdVideoInspectRecord();
                ardVideoInspectRecord.setStepId(step.getId());
                Date currentStepStartDate = DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS, currentStepStartTime);
                Date currentStepStopDate = DateUtils.addMinutes(currentStepStartDate, step.getRecordingTime());
                ardVideoInspectRecord.setStartTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, currentStepStartDate));
                ardVideoInspectRecord.setEndTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, currentStepStopDate));
                String url = MinioClientSingleton.domainUrl + "/" + cmd.getRecordBucketName() + "/" + recordName;
                ardVideoInspectRecord.setRecordFilePath(url);
                ardVideoInspectRecordMapper.insertArdVideoInspectRecord(ardVideoInspectRecord);
            }
        } catch (Exception ex) {
            log.error("巡检停止异常:" + ex.getMessage());
        }
    }

    //步骤判断是否过期
    private boolean isExpirdStep(ArdVideoInspectTask ardVideoInspectTask) {
        try {
            List<ArdVideoInspectTaskStep> ardVideoInspectTaskStepList = ardVideoInspectTask.getArdVideoInspectTaskStepList();
            /*获取当前任务正在执行的步骤和当前步骤开始的时间*/
            String currentStepId = ardVideoInspectTask.getCurrentStepId();
            String currentStepStartTime = ardVideoInspectTask.getCurrentStepStartTime();
            Optional<ArdVideoInspectTaskStep> objectOptional = ardVideoInspectTaskStepList.stream()
                    .filter(ardVideoInspectTaskStep -> ardVideoInspectTaskStep.getId().equals(currentStepId))
                    .findFirst();
            if (objectOptional.isPresent()) {
                /*获取当前步骤信息*/
                ArdVideoInspectTaskStep currentStep = objectOptional.get();
                /*获取到当前步骤的开始和结束时间*/
                Date currentStepStartDate = DateUtils.dateTime(DateUtils.YYYY_MM_DD_HH_MM_SS, currentStepStartTime);
                Date currentStepStopDate = DateUtils.addMinutes(currentStepStartDate, currentStep.getRecordingTime());
                /*判断当前步骤时间是否过期*/
                if (!DateUtils.TimeCompare(currentStepStartDate, currentStepStopDate)) {
                    return true;
                } else {
                    return false;
                }
            } else {
                return false;
            }
        } catch (Exception ex) {
            log.error("判断巡检步骤过期异常：" + ex.getMessage());
            return false;
        }
    }

    //步骤切换
    private String changeNextStep(ArdVideoInspectTask ardVideoInspectTask) {
        try {
            String currentStepId = ardVideoInspectTask.getCurrentStepId();
            Optional<ArdVideoInspectTaskStep> objectOptional = ardVideoInspectTask.getArdVideoInspectTaskStepList().stream()
                    .filter(obj -> obj.getId().equals(currentStepId))
                    .findFirst();
            if (objectOptional.isPresent()) {
                ArdVideoInspectTaskStep step = objectOptional.get();
                Integer currentStepOrderNumber = step.getOrderNumber();
                /*判断当前步骤序号是否小于步骤总数*/
                if (currentStepOrderNumber < ardVideoInspectTask.getArdVideoInspectTaskStepList().size()) {
                    /*小于则执行下一步骤*/
                    currentStepOrderNumber++;
                } else {
                    /*否则从1开始执行*/
                    currentStepOrderNumber = 1;
                }
                Integer nextStepOrderNumber = currentStepOrderNumber;
                /*更新当前任务切换新步骤*/
                ArdVideoInspectTask avit = new ArdVideoInspectTask();
                avit.setId(ardVideoInspectTask.getId());
                String nextStepId = ardVideoInspectTask.getArdVideoInspectTaskStepList().stream()
                        .filter(obj -> obj.getOrderNumber() == nextStepOrderNumber)
                        .map(ArdVideoInspectTaskStep::getId)
                        .findFirst()
                        .orElse(null);
                avit.setCurrentStepId(nextStepId);
                ardVideoInspectTaskMapper.updateArdVideoInspectTask(avit);
                log.info("步骤：" + currentStepId + "切换为" + nextStepId);
                return nextStepId;
            }
        } catch (Exception ex) {
            log.error("巡检步骤切换异常：" + ex.getMessage());
        }
        return "";
    }
}