package com.ard.sample.wayline.service.impl;

import com.ard.sample.utils.TimestampUtils;
import com.ard.sample.wayline.model.dto.WaylineJobDTO;
import com.ard.sample.wayline.model.entity.WaylineJobEntity;
import com.ard.sample.wayline.model.enums.WaylineJobStatusEnum;
import com.ard.sample.wayline.model.param.CreateJobParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.TimeUnit;

@Slf4j
@Component
public class WaylineLoopTaskServiceImpl {

    @Autowired
    private WaylineJobServiceImpl _waylineJobService;
    @Autowired
    private TimestampUtils _timestampUtils;

    /**
     * 定时任务，生成循环任务在有效其内的每天的定时任务
     * */
//    @Scheduled(cron = "0 0 10 * * ?")
    @Scheduled(initialDelay = 1, fixedRate = 10, timeUnit = TimeUnit.SECONDS)
    public void loopTask() {
        try {
            // 执行定时任务逻辑，例如检查并执行已到时间的飞行任务
            List<WaylineJobEntity> lineList = _waylineJobService.selectList(3L, null, null);
            for (WaylineJobEntity waylineJobEntity : lineList) {
                // 获取taskType为3的数据列表，
                // 判断是否已完成
                if (waylineJobEntity.getStatus() == WaylineJobStatusEnum.SUCCESS.getVal()) {
                    continue;
                }

                // 判断时间是否在有期内,循环任务的逻辑是，开始执行时间+循环次数。
                Long beginTime = waylineJobEntity.getBeginTime();

                // 优化判断逻辑，定时任务每10分钟执行一次，将今天下发的循环任务，时间在当前时间之后的任务生成第一次定时任务。
                // 前提是时间要在当前时间10分钟以上的时间。
                // 判断父任务是否生成当天子任务，如果已经生成，则不重复生成。
                Long dayTime = _timestampUtils.combine(beginTime);
                // 先判断当前时间是否大于预生成子任务的执行时间
                Long dayTime10 = _timestampUtils.plusMinutesByMillis(dayTime, -10);
                if(dayTime10.compareTo(System.currentTimeMillis()) < 0)
                {
                    log.info("循环子任务时间在当前时间之前，主任务ID：{}。", waylineJobEntity.getJobId());
                    continue;
                }
                List<WaylineJobEntity> jobDayList = _waylineJobService.selectList(1L, dayTime, waylineJobEntity.getJobId());
                if(!jobDayList.isEmpty()){
                    log.info("循环子任务已经存在，主任务ID：{}。", waylineJobEntity.getJobId());
                    continue;
                }


                // 获取循环任务开始的那天的0点0分0秒的时间戳，方便比对时间有效期范围；
                // 循环任务按每天下发定时任务走，必须要在当次任务执行时间之前执行。
                Long beginTime_Start = _timestampUtils.getDayStartTimestamp(beginTime);
                Integer loopSum = waylineJobEntity.getLoopSum();
                Long endTime = _timestampUtils.plusDaysByMillis(beginTime, loopSum);
                if (beginTime_Start.compareTo(System.currentTimeMillis()) < 0 && endTime.compareTo(System.currentTimeMillis()) > 0) {
                    // 执行任务逻辑
                    // 如果在有效期内，判断任务是否已存在，如果存在则不生成子任务；新时间组成为：当前时间戳的年月日，主任务时间的时分秒。
                    Long newTime = _timestampUtils.combine(beginTime);
                    List<WaylineJobEntity> jobSum= _waylineJobService.selectList(null, null, waylineJobEntity.getJobId());
                    if(!jobSum.isEmpty() && jobSum.size() >= loopSum)
                    {
                        log.info("循环子任务已经完成，主任务ID：{}。", waylineJobEntity.getJobId());
                        // 循环子任务已经完成，修改主任务状态为已完成，即：status=3.
                        _waylineJobService.updateJob(WaylineJobDTO.builder()
                                .jobId(waylineJobEntity.getJobId())
                                .executeTime(LocalDateTime.now())
                                .status(WaylineJobStatusEnum.SUCCESS.getVal())
                                .completedTime(LocalDateTime.now())
                                .code(0).build());
                        continue;
                    }
//                    List<WaylineJobEntity> jobEntities = _waylineJobService.selectList(null, newTime, waylineJobEntity.getJobId());
//                    if (!jobEntities.isEmpty()) {
//                        log.info("循环子任务已经存在，主任务ID：{}，时间：{}！", waylineJobEntity.getJobId(), _timestampUtils.formatByMillis(newTime));
//                        continue;
//                    }
                    CreateJobParam param = getCreateJobParam(waylineJobEntity, newTime);
                    Optional<WaylineJobDTO> waylineJobDTO = _waylineJobService.createWaylineJob(param, waylineJobEntity.getUsername(), newTime, newTime);
                    _waylineJobService.publishFlightTaskPrepare(waylineJobDTO);
                    log.info("添加循环子任务成功，任务ID：{}，时间：{}！", waylineJobEntity.getJobId(), _timestampUtils.formatByMillis(newTime));
                }

            }
        }
        catch (Exception e) {
            e.printStackTrace();
            log.error("添加循环子任务出现异常，时间：{}！异常原因：{}", _timestampUtils.formatByMillis(System.currentTimeMillis()), e.getMessage());
        }
    }

    private CreateJobParam getCreateJobParam(WaylineJobEntity waylineJobEntity, Long newTime) {
        CreateJobParam param = new CreateJobParam();
        param.setRth_mode(1);
        param.setName(waylineJobEntity.getName() + "-子任务");
        param.setFileId(waylineJobEntity.getFileId());
        param.setDockSn(waylineJobEntity.getDockSn());
        param.setWaylineType(waylineJobEntity.getWaylineType());
        param.setTaskType(1);
        param.setExecuteTime(newTime);
        param.setRthAltitude(waylineJobEntity.getRthAltitude());
        param.setOutOfControlAction(waylineJobEntity.getOutOfControlAction());
        param.setParentId(waylineJobEntity.getJobId());
        param.setLoopSum(null);
        return param;
    }
}