package com.ycl.task;


import com.ycl.calculate.CalculationStrategy;
import com.ycl.factory.IndexCalculationFactory;
import com.ycl.platform.domain.entity.CheckIndexVideo;
import com.ycl.platform.domain.entity.ImageResourceSecurity;
import com.ycl.platform.domain.entity.ImageResourceSecurityDetail;
import com.ycl.platform.domain.form.VideoExportForm;
import com.ycl.platform.domain.result.SYS.TMonitorResult;
import com.ycl.platform.domain.result.UY.*;
import com.ycl.platform.domain.vo.PlatformOnlineVO;
import com.ycl.platform.domain.vo.TMonitorVO;
import com.ycl.platform.mapper.*;
import com.ycl.platform.service.IImageResourceSecurityService;
import com.ycl.utils.DateUtils;
import com.ycl.utils.DictUtils;
import constant.ApiConstants;
import constant.CalculationStrategyConstants;
import constant.CheckConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 视频计算考核指标任务
 * 凌晨执行计算昨天数据
 */
@Slf4j
@Component("videoTask")
@RequiredArgsConstructor
public class VideoTask {
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private PlatformOnlineMapper platformOnlineMapper;
    @Autowired
    private TMonitorMapper monitorMapper;

    private final IImageResourceSecurityService imageResourceSecurityService;
    private final CheckIndexVideoMapper checkIndexVideoMapper;
    private final ImageResourceSecurityDetailMapper imageResourceSecurityDetailMapper;
    private final ImageResourceSecurityMapper imageResourceSecurityMapper;

    private static final BigDecimal NUM = new BigDecimal("0.15");

    public void siteOnlineTask() {
        log.info("开始计算点位在线率");
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算点位在线率和重点点位在线率和指挥图像在线率
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));//<&== 昨天的开始时间 < 结束时间
        List<VideoOnlineResult> results = mongoTemplate.find(query, VideoOnlineResult.class);//
        //优云上有车辆和人脸的设备数据，需要过滤出视频设备
        List<String> videoIds = monitorMapper.getVideoIds();
        if(!CollectionUtils.isEmpty(results)){
            results = results.stream().filter(result -> videoIds.contains(result.getNo())).collect(Collectors.toList());
        }
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_SiteOnline);
        calculator.calculate(results);
        log.info("结束计算点位在线率");
    }

    public void videoUsabilityTask() {
        log.info("开始计算录像可用率和重点录像可用率");
        Date yesterday = DateUtils.addDays(new Date(), -1);
        //计算录像可用率和重点录像可用率
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));

        List<RecordMetaDSumResult> results = mongoTemplate.find(query, RecordMetaDSumResult.class);
        //优云上有车辆和人脸的设备数据，需要过滤出视频设备
        List<String> videoIds = monitorMapper.getVideoIds();
        if(!CollectionUtils.isEmpty(results)){
            results = results.stream().filter(result -> videoIds.contains(result.getNo())).collect(Collectors.toList());
        }
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_Usability);
        calculator.calculate(results);
        log.info("结束计算录像可用率和重点录像可用率");
    }

    public void oneMonitorFileTask() {
        log.info("开始计算一机一档注册率、档案考核比");
        //计算一机一档注册率、档案考核比
        Date yesterday = DateUtils.addDays(new Date(), -1);
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        List<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_MonitorRegis_ArchiveRate);
        calculator.calculate(results);
        log.info("结束计算一机一档注册率、档案考核比");
    }

    public void oneMonitorQualifyTask() {
        log.info("开始计算一机一档合格率");
        //计算一机一档合格率
        Date yesterday = DateUtils.addDays(new Date(), -1);
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        List<MonitorQualifyResult> results = mongoTemplate.find(query, MonitorQualifyResult.class);
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_MonitorQualify);
        calculator.calculate(results);
        log.info("结束计算一机一档合格率");
    }

    public void platformOnlineTask() {
        log.info("开始计算平台在线率");
        //计算平台在线率
        List<PlatformOnlineVO> list = platformOnlineMapper.yesterdayData(DateUtils.getMouthStart(new Date()), DateUtils.getMouthEnd(new Date()));
        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_PlatformOnline);
        calculator.calculate(list);
        log.info("结束计算平台在线率");
    }

    public void osdTask() {
        log.info("开始计算Osd标注、时间准确率");
        //计算Osd标注、时间准确率
        Date yesterday = DateUtils.addDays(new Date(), -1);
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(yesterday)).lt(DateUtils.getDayEnd(yesterday)));
        List<OsdCheckResult> results = mongoTemplate.find(query, OsdCheckResult.class);

        CalculationStrategy calculator = IndexCalculationFactory.getCalculator(CalculationStrategyConstants.Video_OsdTime);
        calculator.calculate(results);
        log.info("结束计算Osd标注、时间准确率");
    }

    /**
     * 视频图像资源安全，需要排在平台在线率后面。
     */
    @Transactional(rollbackFor = Exception.class)
    public void videoSecurity() {
        ArrayList<ImageResourceSecurity> imageResourceSecurities = new ArrayList<>();
        List<CheckIndexVideo> list = checkIndexVideoMapper.selectAndDeptName();
        List<ImageResourceSecurityDetail> detail = imageResourceSecurityDetailMapper.getList();

        // 每个部门循环一次计算数据
        for (CheckIndexVideo checkIndexVideo : list) {
            ImageResourceSecurity imageResourceSecurity = new ImageResourceSecurity();
            imageResourceSecurity.setDeptId(checkIndexVideo.getDeptId());
            // 直接取指标
            imageResourceSecurity.setPlatformOnline(checkIndexVideo.getPlatformOnline());
            imageResourceSecurity.setPropertyAccuracy(checkIndexVideo.getMonitorQualification());
            // 获取当前部门的detail进行计算
            List<ImageResourceSecurityDetail> detailList = detail.stream().filter(imageResourceSecurityDetail -> Objects.equals(imageResourceSecurityDetail.getDeptId(), checkIndexVideo.getDeptId())).toList();
            int score = 100;
            int count = 0;
            // 循环detail计算
            for (ImageResourceSecurityDetail imageResourceSecurityDetail : detailList) {
                // 扣除分数
                score -= imageResourceSecurityDetail.getAlarmCategory().getScore();
                // 统计数量
                if (Integer.parseInt(imageResourceSecurityDetail.getAlarmLevel().getValue()) > 1) {
                    count++;
                }
            }
            imageResourceSecurity.setWeakPassword(BigDecimal.valueOf(score).divide(new BigDecimal(100), 4, RoundingMode.HALF_UP));
            // 获取字典值-总数
            int onlineAssetsTotal = Integer.parseInt(DictUtils.getDictValue("online_assets_total", checkIndexVideo.getDeptName()));
            imageResourceSecurity.setRiskProperty(BigDecimal.valueOf(count / onlineAssetsTotal));
            imageResourceSecurity.setCreateTime(DateUtils.getNowDate());
            imageResourceSecurities.add(imageResourceSecurity);
            //获取最近一次数据手动打分
            ImageResourceSecurity latest = imageResourceSecurityMapper.getLatest(checkIndexVideo.getDeptId(),new Date());
            imageResourceSecurity.setBoundaryIntegrity(latest ==null?BigDecimal.ONE:latest.getBoundaryIntegrity());
            // 更新指标数据
            checkIndexVideo.setImageResourceSecurity(
                    imageResourceSecurity.getPlatformOnline()
                            .add(imageResourceSecurity.getPropertyAccuracy()
                                    .add(imageResourceSecurity.getWeakPassword()
                                            .add(imageResourceSecurity.getRiskProperty()))).multiply(NUM)
                            .add(imageResourceSecurity.getBoundaryIntegrity()).multiply(new BigDecimal("0.45"))
            );
            checkIndexVideoMapper.updateById(checkIndexVideo);
        }
        imageResourceSecurityService.saveBatch(imageResourceSecurities);

    }
}