package com.zhgd.xmgl.task;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.CalendarUtil;
import cn.hutool.core.date.DateField;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import com.zhgd.xmgl.modules.checking.entity.CheckingPoint;
import com.zhgd.xmgl.modules.checking.enums.PointFrequencyTypeEnum;
import com.zhgd.xmgl.modules.checking.mapper.CheckingPointMapper;
import com.zhgd.xmgl.modules.checking.service.CheckingPointAlarmService;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author 邱平毅
 * @ClassName CheckingTask
 * @date 2022/11/21 15:43
 * @Version 1.0
 */
@Slf4j
@Component
public class CheckingTask {
    @Resource
    CheckingPointMapper checkingPointMapper;

    @Resource
    CheckingPointAlarmService checkingPointAlarmService;

    /**
     * 统计天为巡检类型的巡检任务未达标的数据
     */
    @SchedulerLock(name = "dayCheckingPointAlarmData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 0 * * ?")
    public void dayCheckingPointAlarmData() {
        log.info("CheckingTask#dayCheckingPointAlarmData每天统计巡检任务未达标的数据");
        // 每天为巡检类型的数据
        List<CheckingPoint> pointList = checkingPointMapper.getStartingListByFrequencyType(PointFrequencyTypeEnum.DAY.getId());
        // 昨天
        DateTime yesterday = DateUtil.yesterday();
        checkingPointAlarmService.pointListHandler(pointList, yesterday.toString());

        // 结束时间为昨天的数据，统一处理结束的巡检点任务
        List<CheckingPoint> finishList = checkingPointMapper.getFinishList();
        log.info("已结束的巡检点任务列表为：{}", finishList);
        if (CollUtil.isNotEmpty(finishList)) {
            // 根据不同频率类型处理对应数据
            Map<Integer, List<CheckingPoint>> frequencyTypePointListMap = finishList.stream().collect(Collectors.groupingBy(CheckingPoint::getFrequencyType));
            frequencyTypePointListMap.forEach((type, mapPointList) -> {
                // 通过类型id获取对应的枚举类
                PointFrequencyTypeEnum pointFrequencyTypeEnum = PointFrequencyTypeEnum.getById(type);
                String dateTime;

                switch (pointFrequencyTypeEnum) {
                    default:
                    case SECOND:
                        // 从1900年开始计算
                        dateTime = "1900-01-01";
                        break;
                    case DAY:
                        // 昨天
                        dateTime = yesterday.toString();
                        break;
                    case WEEK:
                        // 获得本周第一天
                        dateTime = DateUtil.formatDate(CalendarUtil.beginOfWeek(CalendarUtil.calendar()).getTime());
                        break;
                    case MONTH:
                        // 获得本月第一天
                        dateTime = DateUtil.formatDate(CalendarUtil.beginOfMonth(CalendarUtil.calendar()).getTime());
                        break;
                    case YEAR:
                        // 获得今年第一天
                        dateTime = DateUtil.formatDate(CalendarUtil.beginOfYear(CalendarUtil.calendar()).getTime());
                        break;
                }
                checkingPointAlarmService.pointListHandler(mapPointList, dateTime);
            });
        }

    }

    /**
     * 每周一统计巡检任务未达标的数据
     */
    @SchedulerLock(name = "weekCheckingPointAlarmData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 0 ? * 1")
    public void weekCheckingPointAlarmData() {
        log.info("CheckingTask#weekCheckingPointAlarmData每周一统计巡检任务未达标的数据");
        // 每周为巡检类型的数据
        List<CheckingPoint> pointList = checkingPointMapper.getStartingListByFrequencyType(PointFrequencyTypeEnum.WEEK.getId());
        // 上周
        DateTime lastWeek = DateUtil.lastWeek();
        checkingPointAlarmService.pointListHandler(pointList, lastWeek.toString());
    }


    /**
     * 每个月一号统计巡检任务未达标的数据
     */
    @SchedulerLock(name = "monthCheckingPointAlarmData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 0 1 * ?")
    public void monthCheckingPointAlarmData() {
        log.info("CheckingTask#monthCheckingPointAlarmData每个月一号统计巡检任务未达标的数据");
        // 每月为巡检类型的数据
        List<CheckingPoint> pointList = checkingPointMapper.getStartingListByFrequencyType(PointFrequencyTypeEnum.MONTH.getId());
        // 上个月
        DateTime lastMonth = DateUtil.lastMonth();
        checkingPointAlarmService.pointListHandler(pointList, lastMonth.toString());
    }

    /**
     * 每年统计巡检任务未达标的数据
     */
    @SchedulerLock(name = "yearCheckingPointAlarmData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 0 1 1 ?")
    public void yearCheckingPointAlarmData() {
        log.info("CheckingTask#yearCheckingPointAlarmData每年统计巡检任务未达标的数据");
        // 每年为巡检类型的数据
        List<CheckingPoint> pointList = checkingPointMapper.getStartingListByFrequencyType(PointFrequencyTypeEnum.YEAR.getId());
        // 去年
        DateTime lastYear = DateUtil.offset(new Date(), DateField.YEAR, -1);
        checkingPointAlarmService.pointListHandler(pointList, lastYear.toString());
    }
}