package com.zhgd.xmgl.task;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.zhgd.jeecg.common.mybatis.EntityMap;
import com.zhgd.xmgl.async.AsyncCommon;
import com.zhgd.xmgl.modules.basicdata.mapper.VerificationCodeMapper;
import com.zhgd.xmgl.modules.basicdata.service.ISystemUserService;
import com.zhgd.xmgl.modules.environment.entity.AirQualityAnalysis;
import com.zhgd.xmgl.modules.environment.mapper.AirQualityAnalysisMapper;
import com.zhgd.xmgl.modules.environment.mapper.DustNoiseDataMapper;
import com.zhgd.xmgl.modules.project.entity.FenceRoadHardenReport;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.mapper.FenceRoadHardenReportMapper;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.IProjectDevStatisticsService;
import com.zhgd.xmgl.modules.standard.entity.StandardSampleNotice;
import com.zhgd.xmgl.modules.standard.mapper.StandardSampleNoticeMapper;
import com.zhgd.xmgl.modules.standard.mapper.StandardSampleRecordMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerAttendancePresenceMapper;
import com.zhgd.xmgl.modules.worker.service.IWorkerMonthAttendanceStatisticsService;
import com.zhgd.xmgl.util.AqiUtil;
import lombok.extern.log4j.Log4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.lang.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Log4j
@Component
public class ProjectTask {
    @Resource
    private VerificationCodeMapper verificationCodeMapper;
    @Autowired
    private IWorkerMonthAttendanceStatisticsService workerMonthAttendanceStatisticsService;
    @Autowired
    private ProjectMapper projectMapper;
    @Autowired
    private DustNoiseDataMapper dustNoiseDataMapper;
    @Autowired
    private AirQualityAnalysisMapper airQualityAnalysisMapper;
    @Autowired
    private StandardSampleNoticeMapper standardSampleNoticeMapper;
    @Autowired
    private StandardSampleRecordMapper standardSampleRecordMapper;
    @Autowired
    private IProjectDevStatisticsService projectDevStatisticsService;

    @Autowired
    private WorkerAttendancePresenceMapper workerAttendancePresenceMapper;
    @Autowired
    private FenceRoadHardenReportMapper fenceRoadHardenReportMapper;
    @Autowired
    ISystemUserService systemUserService;
    @Autowired
    AsyncCommon asyncCommon;
    public static Map<String, Integer> sendcodecount = new HashMap<>();


    /**
     * 定时清除无效的校验码
     */
    @Scheduled(cron = "0 0/3 * * * ?")
    ///任务名称必须唯一 ，lockAtMostFor最长锁表时间单位 毫秒：（防止节点奔溃，不释放锁） lockAtLeastFor 最短锁表时间单位 毫秒 ,防止任务重复跑
    @SchedulerLock(name = "cleanVerificationCod", lockAtMostFor = 1000 * 60 * 2, lockAtLeastFor = 1000 * 60 * 1)
    public void cleanVerificationCod() {
        try {
            verificationCodeMapper.cleanVerificationCode();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 定时清除无效的校验码
     */
    @SchedulerLock(name = "cleanVerificationCodephone", lockAtMostFor = 1000 * 60 * 2, lockAtLeastFor = 1000 * 60 * 1)
    @Scheduled(cron = "59 59 23 * * ?")
    public void cleanVerificationCodephone() {
        try {
            sendcodecount.clear();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 定时清除无效的校验码
     * "0 15 10 15 * ?" 每月15日上午10:15触发
     */
    @SchedulerLock(name = "createFenceRoadHardenReport", lockAtMostFor = 1000 * 60 * 2, lockAtLeastFor = 1000 * 60 * 1)
    @Scheduled(cron = "0 0 1 1 * ?")
    public void createFenceRoadHardenReport() {
        try {
            SimpleDateFormat sft = new SimpleDateFormat("yyyy-MM-dd");
            String monthTime = sft.format(new Date());
            QueryWrapper<Project> queryWrapper = new QueryWrapper<>();
            List<Project> list = projectMapper.selectList(queryWrapper);
            if (list != null && list.size() > 0) {
                for (Project project : list) {
                    saveFenceRoadHardenReport(1, project.getProjectSn(), monthTime);
                    saveFenceRoadHardenReport(2, project.getProjectSn(), monthTime);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 生成未填写的围挡上报和路面硬化上报
     *
     * @param type
     * @param projectSn
     * @param monthTime
     */
    private void saveFenceRoadHardenReport(Integer type, String projectSn, String monthTime) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        QueryWrapper<FenceRoadHardenReport> queryWrapper1 = new QueryWrapper();
        queryWrapper1.lambda().eq(FenceRoadHardenReport::getMonthTime, monthTime)
                .eq(FenceRoadHardenReport::getProjectSn, projectSn)
                .eq(FenceRoadHardenReport::getType, type);
        Integer count = fenceRoadHardenReportMapper.selectCount(queryWrapper1);
        if (count == 0) {
            FenceRoadHardenReport fenceRoadHardenReport = new FenceRoadHardenReport();
            fenceRoadHardenReport.setMonthTime(monthTime);
            fenceRoadHardenReport.setType(type);
            fenceRoadHardenReport.setProjectSn(projectSn);
            fenceRoadHardenReport.setCreateTime(sdf.format(new Date()));
            fenceRoadHardenReportMapper.insert(fenceRoadHardenReport);
        }
    }

    /**
     * 统计前一天的考勤状况
     */
    @SchedulerLock(name = "getMonthAttendanceStatistics", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 3 * * ?")
    public void getMonthAttendanceStatistics() {
        try {
            SimpleDateFormat sft = new SimpleDateFormat("yyyy-MM-dd");
            //计算前一天的考勤状况
            Date date = DateUtils.addDays(new Date(), -1);
            workerMonthAttendanceStatisticsService.getMonthAttendanceStatistics(sft.format(date));
        } catch (Exception e) {
            log.error("定时任务计算前一天的考勤状态失败", e);
        }
    }

    /**
     * 巡检提醒
     */
    @SchedulerLock(name = "inspectionToRemind", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    @Scheduled(cron = "0 0 7 * * ?")
    public void inspectionToRemind() {
        asyncCommon.sendMqAndAppSnSet("每日巡检通知", "请按时完成巡检任务哦", "每日巡检通知", null, "/pages/projectEnd/dailyCheck/index");
    }

    //计算项目空气质量分析
    @Scheduled(cron = "0 0 1 * * ?")
    @SchedulerLock(name = "getSparyAqi", lockAtMostFor = 1000 * 60 * 20, lockAtLeastFor = 1000 * 60 * 2)
    public void getSparyAqi() {
        try {
            SimpleDateFormat sft = new SimpleDateFormat("yyyy-MM-dd");
            //计算前一天的空气质量分析
            Date date = DateUtils.addDays(new Date(), -1);
            QueryWrapper<Project> queryWrapper = new QueryWrapper<>();
            List<Project> list = projectMapper.selectList(queryWrapper);
            if (list != null && list.size() > 0) {
                String dayTime = sft.format(date);
                for (Project project : list) {
                    Double value = dustNoiseDataMapper.selectAvgPm25Value(project.getProjectSn(), dayTime);
                    if (value != null) {
                        //根据平均值计算指标
                        value = AqiUtil.getPm25IAQI(value);
                    } else {
                        //没有数据时候，查询项目所在天气的指标
                        value = AqiUtil.getWeatherInfo(project.getCityCode());
                    }
                    if (value != null) {
                        AirQualityAnalysis airQualityAnalysis = new AirQualityAnalysis();
                        airQualityAnalysis.setProjectSn(project.getProjectSn());
                        airQualityAnalysis.setAnalysisTime(dayTime);
                        airQualityAnalysis.setAnalysisData(value);
                        airQualityAnalysis.setAnalysisType(AqiUtil.getDegree(AqiUtil.getPollutionDegree(value)));
                        airQualityAnalysisMapper.insert(airQualityAnalysis);
                    }
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
            log.error("定时任务计算前一天的项目空气质量分析", e);
        }
    }

    /**
     * 每天执行一次将今天之前的绿色设备实时数据移到历史表中，不执行数据迁移
     */
    //@Scheduled(cron = "0 0 2 * * ?")
    @SchedulerLock(name = "insertDustNoiseHistoryData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
    public void insertDustNoiseHistoryData() {
        try {
            int result = dustNoiseDataMapper.insertDustNoiseHistoryData();
            if (result > 0) {
                dustNoiseDataMapper.deleteDustNoiseDataToHistory();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 项目设备每天统计数量和在线数量
     */
    @Scheduled(cron = "0 0 5 * * ?")
    @SchedulerLock(name = "insertDustNoiseHistoryData", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 3)
    public void devStatisticsTask() {
        SimpleDateFormat sft = new SimpleDateFormat("yyyy-MM-dd");
        projectDevStatisticsService.addProjectDevStatistics(sft.format(new Date()));
    }

    /**
     * 到期样品提醒
     */
    @Scheduled(cron = "0 0 4 * * ?")
    @SchedulerLock(name = "expireSampleNoticeTask", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 3)
    public void expireSampleNoticeTask() {
        SimpleDateFormat sft = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        List<EntityMap> list = standardSampleRecordMapper.selectExpireStandardSampleRecordList();
        if (list != null && list.size() > 0) {
            String currentTime = sft.format(new Date());
            for (EntityMap data : list) {
                StandardSampleNotice notice = new StandardSampleNotice();
                notice.setCreateTime(currentTime);
                notice.setDevSn(MapUtils.getString(data, "devSn"));
                notice.setCuringPeriod(MapUtils.getString(data, "curingPeriod"));
                notice.setFormingTime(MapUtils.getString(data, "formingTime"));
                notice.setSampleNo(MapUtils.getString(data, "sampleNo"));
                notice.setLocationName(MapUtils.getString(data, "locationName"));
                notice.setProjectSn(MapUtils.getString(data, "projectSn"));
                notice.setSampleAddTime(MapUtils.getString(data, "addTime"));
                notice.setSampleTypeName(MapUtils.getString(data, "sampleTypeName"));
                notice.setSecondLocationName(MapUtils.getString(data, "secondLocationName"));
                standardSampleNoticeMapper.insert(notice);
            }
        }
    }

    /**
     * @param
     * @return void    返回类型
     * @throws
     * @Title: deleteAttendancePresence
     * @Description: 清除无效在场数据
     */
    /*@Scheduled(cron = "0 0 2 * * ?")*/
    @Scheduled(cron = "0 0 */1 * * ?")
    @SchedulerLock(name = "deleteAttendancePresence", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 3)
    public void deleteAttendancePresence() {
        workerAttendancePresenceMapper.deleteAttendancePresence();
    }

}