package com.ard.work.inspect.service.impl;

import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.stream.Collectors;

import com.ard.common.core.constant.SecurityConstants;
import com.ard.common.core.domain.R;
import com.ard.common.core.utils.DateUtils;
import com.ard.common.core.utils.StringUtils;
import com.ard.common.core.utils.uuid.IdUtils;
import com.ard.common.datascope.annotation.DataScope;
import com.ard.system.api.RemoteConfigService;
import com.ard.work.api.domian.ArdCamera;
import com.ard.work.device.camera.service.IArdCameraService;
import com.ard.work.inspect.domain.ArdVideoInspectTaskStep;
import com.ard.work.inspect.dto.TimeSlot;
import com.ard.work.inspect.mapper.ArdVideoInspectTaskStepMapper;
import com.ard.work.inspect.task.TaskStatus;
import com.ard.work.inspect.task.TaskWrapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import com.ard.work.inspect.mapper.ArdVideoInspectTaskMapper;
import com.ard.work.inspect.domain.ArdVideoInspectTask;
import com.ard.work.inspect.service.IArdVideoInspectTaskService;
import org.springframework.transaction.annotation.Transactional;

import jakarta.annotation.Resource;

import static java.util.stream.Collectors.toList;

/**
 * 视频巡检任务Service业务层处理
 *
 * @author ruoyi
 * @date 2024-09-12
 */
@Service
@Slf4j
public class ArdVideoInspectTaskServiceImpl implements IArdVideoInspectTaskService {
    @Resource
    private ArdVideoInspectTaskMapper ardVideoInspectTaskMapper;
    @Resource
    private ArdVideoInspectTaskStepMapper ardVideoInspectTaskStepMapper;
    @Resource
    private IArdCameraService ardCameraService;
    @Resource
    private RemoteConfigService remoteConfigService;
    private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(50);
    private final Map<String, TaskWrapper> taskWrapperMap = new ConcurrentHashMap<>();
    private final Map<String, List<String>> pauseTaskMap = new ConcurrentHashMap<>();//暂停任务列表


    /**
     * 查询视频巡检任务
     *
     * @param id 视频巡检任务主键
     * @return 视频巡检任务
     */
    @Override
    public ArdVideoInspectTask selectArdVideoInspectTaskById(String id) {
        ArdVideoInspectTask task = ardVideoInspectTaskMapper.selectArdVideoInspectTaskById(id);
        if (task != null) {
            ArdVideoInspectTaskStep step = new ArdVideoInspectTaskStep();
            step.setTaskId(task.getId());
            List<ArdVideoInspectTaskStep> steps = ardVideoInspectTaskStepMapper.selectArdVideoInspectTaskStepList(step);
            task.setArdVideoInspectTaskSteps(steps);
            TaskStatus taskStatus = getTaskStatus(task.getId());
            task.setTaskStatus(taskStatus);
        }
        return task;
    }

    /**
     * 查询视频巡检任务列表
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 视频巡检任务
     */
    @Override
    @DataScope(deptAlias = "d", userAlias = "u")
    public List<ArdVideoInspectTask> selectArdVideoInspectTaskList(ArdVideoInspectTask ardVideoInspectTask) {

        List<ArdVideoInspectTask> tasks = ardVideoInspectTaskMapper.selectArdVideoInspectTaskList(ardVideoInspectTask);
        tasks.forEach(task -> {
            ArdVideoInspectTaskStep step = new ArdVideoInspectTaskStep();
            step.setTaskId(task.getId());
            List<ArdVideoInspectTaskStep> steps = ardVideoInspectTaskStepMapper.selectArdVideoInspectTaskStepList(step);
            task.setArdVideoInspectTaskSteps(steps);
            TaskStatus taskStatus = getTaskStatus(task.getId());
            task.setTaskStatus(taskStatus);
        });
        return tasks;
    }

    /**
     * 新增视频巡检任务
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 结果
     */
    @Override
    @Transactional
    public int insertArdVideoInspectTask(ArdVideoInspectTask ardVideoInspectTask) {
        ardVideoInspectTask.setId(IdUtils.simpleUUID());
        ardVideoInspectTask.setCreateTime(DateUtils.getNowDate());
        ardVideoInspectTask.getArdVideoInspectTaskSteps().forEach(step -> {
            step.setTaskId(ardVideoInspectTask.getId());
            step.setId(IdUtils.simpleUUID());
            ardVideoInspectTaskStepMapper.insertArdVideoInspectTaskStep(step);
        });
        return ardVideoInspectTaskMapper.insertArdVideoInspectTask(ardVideoInspectTask);
    }

    /**
     * 修改视频巡检任务
     *
     * @param ardVideoInspectTask 视频巡检任务
     * @return 结果
     */
    @Override
    @Transactional
    public int updateArdVideoInspectTask(ArdVideoInspectTask ardVideoInspectTask) {
        ardVideoInspectTask.setUpdateTime(DateUtils.getNowDate());
        //修改先删除任务关联的全部步骤再重新添加
        ardVideoInspectTaskStepMapper.deleteArdVideoInspectTaskStepByTaskId(ardVideoInspectTask.getId());
        if (ardVideoInspectTask.getArdVideoInspectTaskSteps() != null) {
            ardVideoInspectTask.getArdVideoInspectTaskSteps().forEach(step -> {
                step.setTaskId(ardVideoInspectTask.getId());
                step.setId(IdUtils.simpleUUID());
                ardVideoInspectTaskStepMapper.insertArdVideoInspectTaskStep(step);
            });
        }
        return ardVideoInspectTaskMapper.updateArdVideoInspectTask(ardVideoInspectTask);
    }

    /**
     * 批量删除视频巡检任务
     *
     * @param ids 需要删除的视频巡检任务主键
     * @return 结果
     */
    @Override
    public int deleteArdVideoInspectTaskByIds(String[] ids) {
        Arrays.asList(ids).forEach(id -> {
            ardVideoInspectTaskStepMapper.deleteArdVideoInspectTaskStepByTaskId(id);
        });
        return ardVideoInspectTaskMapper.deleteArdVideoInspectTaskByIds(ids);
    }

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


    /**
     * 获取单个相机的空闲时段
     *
     * @param cameraId 相机ID
     * @return 返回空闲时段列表
     */
    public List<TimeSlot> getCameraIdleTimeList(String cameraId) {
        List<TimeSlot> idleTimeSlots = new LinkedList<>();

        // 获取该相机的占用时段
        List<TimeSlot> usedPeriods = ardVideoInspectTaskMapper.getTaskUsedCameraPeriods(cameraId);

        // 如果没有占用时间段，返回全天空闲
        if (usedPeriods.isEmpty()) {
            idleTimeSlots.add(new TimeSlot(LocalTime.MIN, LocalTime.MAX)); // 全天空闲
            return idleTimeSlots;
        }

        // 遍历已用的时间段并处理空闲时间段
        LocalTime startOfDay = LocalTime.MIN;  // 00:00:00
        LocalTime endOfDay = LocalTime.MAX;    // 23:59:59

        LocalTime previousEndTime = startOfDay;

        for (TimeSlot usedPeriod : usedPeriods) {
            LocalTime currentStartTime = usedPeriod.getStartTime();
            LocalTime currentEndTime = usedPeriod.getEndTime();

            // 如果当前使用的开始时间在上一个结束时间之后，则存在空闲时间
            if (previousEndTime.isBefore(currentStartTime)) {
                idleTimeSlots.add(new TimeSlot(previousEndTime, currentStartTime));
            }

            // 更新前一个结束时间
            previousEndTime = currentEndTime;
        }

        // 检查是否存在最后一个空闲时段（即从最后一个已用时间段结束到当天结束的时间段）
        if (previousEndTime.isBefore(endOfDay)) {
            idleTimeSlots.add(new TimeSlot(previousEndTime, endOfDay));
        }

        return idleTimeSlots;
    }

    /**
     * 获取所有相机的空闲时段
     */
    public List<Map<String, Object>> getOptions() {
        ArdCamera ardCamera = new ArdCamera("1");
        List<ArdCamera> ardCameras = ardCameraService.selectArdCameraList(ardCamera);
        return ardCameras.stream()
                .map(camera -> {
                    Map<String, Object> option = new HashMap<>();
                    option.put("value", camera.getId());
                    option.put("label", camera.getName());
                    option.put("channelList",
                            Optional.ofNullable(camera.getChannelList()).orElse(Collections.emptyList())); // 防止
                    // channelList 为空
                    option.put("idleTimeList", getCameraIdleTimeList(camera.getId()));
                    return option;
                })
                .collect(toList());
    }

    /**
     * 获取任务关联相机的其他任务
     */
    @Override
    public List<ArdVideoInspectTask> getOtherTasks(String taskId) {
        return ardVideoInspectTaskMapper.getOtherTasks(taskId);
    }

    private final Object lock = new Object();

    /**
     * 启动任务
     */
    @Override
    public Boolean startTask(String taskId) {
        if (taskWrapperMap.containsKey(taskId)) {
            log.warn("Task with ID {} is already running", taskId);
            return false;
        }
        ArdVideoInspectTask task = selectArdVideoInspectTaskById(taskId);
        if (task == null) {
            log.error("Task with ID {} not found", taskId);
            return false;
        }
        TaskWrapper taskWrapper = new TaskWrapper(task);
        taskWrapperMap.put(task.getId(), taskWrapper);  // 存储 TaskWrapper 实例
        scheduler.submit(taskWrapper);
        log.info("Task with ID {} has been started", taskId);
        return true;
    }

    /**
     * 暂停任务
     */
    @Override
    public boolean pauseTask(String taskId) {
        return Optional.ofNullable(taskWrapperMap.get(taskId))
                .map(task -> {
                    task.pause();
                    return true;
                })
                .orElse(false);
    }

    /**
     * 恢复任务
     */
    @Override
    public boolean resumeTask(String taskId) {
        return Optional.ofNullable(taskWrapperMap.get(taskId))
                .map(task -> {
                    if (task.isPaused()) { // 假设 TaskWrapper 有 isPaused 方法
                        task.resume();
                        pauseOtherTasks(taskId);
                        return true;
                    } else {
                        log.warn("Task with ID {} is already running.", taskId);
                        return false;
                    }
                })
                .orElse(false);
    }

    /**
     * 取消任务
     */
    @Override
    public boolean cancelTask(String taskId) {
        log.info(taskId);
        if (StringUtils.isBlank(taskId)){
            return false;
        }
        if (Objects.isNull(taskWrapperMap.get(taskId))) {
            return false;
        }
        return Optional.ofNullable(taskWrapperMap.get(taskId))
                .map(task -> {
                    task.cancel();
                    taskWrapperMap.remove(taskId);
                    return true;
                })
                .orElse(false);
    }

    @Override
    public void manualStartTask(String taskId) {
        startTask(taskId);
        pauseOtherTasks(taskId);
    }

    @Override
    public void manualStopTask(String taskId) {
        cancelTask(taskId);
        //恢复其他任务
        List<String> tasksToResume = pauseTaskMap.get(taskId);
        if (tasksToResume != null) {
            tasksToResume.forEach(this::resumeTask);
        }
    }

    //判断当前时间是否在任务的开始时间和结束时间之间
    public static boolean isWithinTimeRange(ArdVideoInspectTask task) {
        // 使用 isAfter 和 isBefore 方法来判断
        return !LocalTime.now().isBefore(task.getStartTime()) && !LocalTime.now().isAfter(task.getEndTime());
    }

    public TaskStatus getTaskStatus(String taskId) {
        TaskStatus status = taskWrapperMap.get(taskId) != null ? taskWrapperMap.get(taskId).status :
                TaskStatus.NOT_RUNNING;
        return status;
    }

    //每5秒执行一次自动任务扫描，满足时间的自动启动任务
    //容器启动后，先等待 10秒，然后每隔 5秒 执行一次
    // @Scheduled(cron = "0/5 * * * * ?")
    @Scheduled(fixedRate = 5000, initialDelay = 10000)
    public void autoStartTask() {
        ArdVideoInspectTask ardTask = new ArdVideoInspectTask();
        ardTask.setInspectMode("1");
        List<ArdVideoInspectTask> tasks = selectArdVideoInspectTaskList(ardTask);
        synchronized (lock) {  // 加锁以防止多线程同时执行
            tasks.forEach(task -> {

                //查询相机的其他任务是否有正在手动控制并且正在运行
                List<ArdVideoInspectTask> otherTasks = getOtherTasks(task.getId());
                boolean isManualControl = otherTasks.stream().anyMatch(
                        otherTask -> {
                            TaskWrapper otherTaskWrapper = taskWrapperMap.get(otherTask.getId());
                            return otherTaskWrapper != null &&
                                    otherTask.getInspectMode().equals("0") &&
                                    otherTaskWrapper.status.equals(TaskStatus.RUNNING);
                        }
                );
                if (isManualControl) {
                    return;
                }
                //遍历所有自动任务,对满足启动时间并且未启动的任务进行启动
                boolean isTaskActive = taskWrapperMap.containsKey(task.getId());
                boolean withinTimeRange = isWithinTimeRange(task);
                if (withinTimeRange && !isTaskActive) {
                    startTask(task.getId());
                } else if (!withinTimeRange && isTaskActive) {
                    cancelTask(task.getId());
                }
            });
        }
    }

    //暂停当前任务相机的其他任务
    public void pauseOtherTasks(String taskId) {
        //获取当前任务相机的其他任务
        List<ArdVideoInspectTask> otherTasks = getOtherTasks(taskId);
        // 将需要暂停的任务 ID 转换为列表
        // 如果任务正在运行，直接暂停
        List<ArdVideoInspectTask> filteredTasks = otherTasks.stream()
                .filter(task -> taskWrapperMap.containsKey(task.getId()))  // 过滤掉不在 taskWrapperMap 中的任务
                .collect(Collectors.toList());  // 收集结果到 List 中
        filteredTasks.forEach(task -> pauseTask(task.getId()));
        List<String> pauseTaskList =
                filteredTasks.stream().map(ArdVideoInspectTask::getId).collect(Collectors.toList());  // 收集到列表
        pauseTaskMap.put(taskId, pauseTaskList);
    }


}