package com.ycl.task;


import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mongodb.client.result.DeleteResult;
import com.ycl.platform.domain.entity.*;
import com.ycl.platform.domain.result.HK.SnapshotDataMonitorResult;
import com.ycl.platform.domain.result.UY.VideoOnlineResult;
import com.ycl.platform.domain.vo.CalculateRuleVO;
import com.ycl.platform.domain.vo.ContractVO;
import com.ycl.platform.domain.vo.ReportVO;
import com.ycl.platform.mapper.*;
import com.ycl.platform.service.IContractScoreService;
import com.ycl.utils.DateUtils;
import constant.ApiConstants;
import constant.RedisConstant;
import enumeration.ContractRule;
import enumeration.general.AuditingStatus;
import enumeration.general.RuleDeductCategoryEnum;
import lombok.extern.slf4j.Slf4j;
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.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.management.monitor.Monitor;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 合同考核定时任务
 */
@Slf4j
@Component("contractTask")
public class ContractTask {
    @Autowired
    private MongoTemplate mongoTemplate;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private TMonitorMapper monitorMapper;
    @Autowired
    private TContractMapper contractMapper;
    @Autowired
    private YwPointMapper ywPointMapper;
    @Autowired
    private ReportMapper reportMapper;
    @Autowired
    private ContractRuleRecordMapper recordMapper;
    @Autowired
    private IContractScoreService contractScoreService;

    private static final Integer Online = 1;
    private static final Integer Offline = -1;
    private static final String AuditStatus_Pass = "1";
    private static final String Remark = "系统生成";

    /**
     * 合同考核 在线率每日任务检测
     * 查生效的合同关联的公司，获取unitId集合
     * 根据unitId查询对应点位获取各个公司管理的设备Ids
     * 查询三种设备在线不在线情况，封装为一个map<国标码,在线状态>
     * 计算每日每家公司的在线率存入mysql
     * 月底计算平均值，根据在线率和合同标准扣减分数
     */
    public void onlineCheck() {
        log.info("开始计算合同点位在线率");
        List<CalculateRuleVO> ruleVos = contractMapper.getCalculateRule(new Date()).stream()
                .filter(calculateRuleVO -> ContractRule.CONTRACT_RULE_Online.getName().equals(calculateRuleVO.getRuleName()))
                .collect(Collectors.toList());
        List<Integer> unitIds = ruleVos.stream().map(CalculateRuleVO::getUnitId).collect(Collectors.toList());
        List<YwPoint> ywPoints = ywPointMapper.selectList(new QueryWrapper<YwPoint>().in("unit_id", unitIds));
        //key是unitId value是设备编码集合
        Map<Long, List<String>> unitMap = ywPoints.stream()
                .collect(Collectors.groupingBy(
                        YwPoint::getUnitId,
                        Collectors.mapping(
                                YwPoint::getSerialNumber,
                                Collectors.toList()
                        )
                ));
        Map<String, Integer> onlineStatusMap = new HashMap<>();
        //查mongo获取设备在线情况
        Date date = DateUtils.getDay(2024, 7, 13);
        //车辆、人脸
        Query query = new Query();
        query.addCriteria(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(date)).lt(DateUtils.getDayEnd(date)));
        List<SnapshotDataMonitorResult> results = mongoTemplate.find(query, SnapshotDataMonitorResult.class);
        for (SnapshotDataMonitorResult result : results) {
            if (ApiConstants.HK_SnapCount_ResultType_Null != result.getResultType()) {
                onlineStatusMap.put(result.getExternalIndexCode(), Online);
            } else {
                onlineStatusMap.put(result.getExternalIndexCode(), Offline);
            }
        }
        //视频
        Query videoQuery = new Query(Criteria
                .where("mongoCreateTime").gte(DateUtils.getDayStart(date)).lt(DateUtils.getDayEnd(date)));
        List<VideoOnlineResult> videoOnlineResults = mongoTemplate.find(videoQuery, VideoOnlineResult.class);
        for (VideoOnlineResult videoOnlineResult : videoOnlineResults) {
            onlineStatusMap.put(videoOnlineResult.getDeviceId(), videoOnlineResult.getStatus());
        }
        //查询报备列表
        List<String> reportNumbers = reportMapper.selectNumberList(AuditStatus_Pass, DateUtils.getDate());
        //计算每个公司的点位在线率
        List<ContractRuleRecord> ruleRecordList = new ArrayList<>();
        unitMap.forEach((unitId, serialNumberList) -> {
            int totalSite = 0;
            int onlineSite = 0;
            for (String number : serialNumberList) {
                //报备过不纳入计算
                if (!CollectionUtils.isEmpty(reportNumbers) && reportNumbers.contains(number)) continue;
                Integer status = onlineStatusMap.get(number);
                totalSite++;
                if (Online.equals(status)) {
                    onlineSite++;
                }
            }
            BigDecimal online = new BigDecimal(onlineSite).divide(new BigDecimal(totalSite), 2, RoundingMode.DOWN);
            ContractRuleRecord contractRuleRecord = new ContractRuleRecord();
            contractRuleRecord.setSiteOnline(online);
            contractRuleRecord.setCreateTime(new Date());
            contractRuleRecord.setUnitId(unitId);
            ruleRecordList.add(contractRuleRecord);
        });
        //存储结果
        recordMapper.insertBatch(ruleRecordList);
        log.info("结束计算合同点位在线率");
    }

    //月底计算在线率分数
    public void calculateOnlineScore() {
        log.info("开始计算合同点位在线率分数");
        //如果是月底，需要统计平均在线率然后进行积分扣除
//        String now = DateUtils.getDate();
        String mouthStart = DateUtils.getMouthStart(new Date());
        String mouthEnd = DateUtils.getMouthEnd(new Date());
//        if (now.equals(mouthEnd)) {
        //查一个月的记录
        List<ContractRuleRecord> ruleMonthRecords = recordMapper.selectMonth(mouthStart, mouthEnd);
        //通过unitId分单位
        Map<Long, List<ContractRuleRecord>> unitMap = ruleMonthRecords.stream().collect(Collectors.groupingBy(ContractRuleRecord::getUnitId));
        //查在线率规则 获取key为合同id，value为在线率规则的map
        Map<Integer, List<CalculateRuleVO>> contractMap = contractMapper.getCalculateRule(new Date()).stream()
                .filter(calculateRuleVO -> ContractRule.CONTRACT_RULE_Online.getName().equals(calculateRuleVO.getRuleName()))
                .collect(Collectors.groupingBy(CalculateRuleVO::getContractId));

        //准备批量打分的集合
        List<ContractScore> contractScoreList = new ArrayList<>();
        contractMap.forEach((contractId, ruleList) -> {
            //一个合同对应一个单位，因此unitId都相同
            CalculateRuleVO calculateRuleVO = ruleList.get(0);
            Integer unitId = calculateRuleVO.getUnitId();
            List<ContractRuleRecord> ruleRecordList = unitMap.get(Long.parseLong(unitId + ""));
            if (!CollectionUtils.isEmpty(ruleMonthRecords)) {
                BigDecimal siteOnlineTotal = ruleRecordList.stream().map(ContractRuleRecord::getSiteOnline).reduce(BigDecimal.ZERO, BigDecimal::add);
                BigDecimal siteOnline = siteOnlineTotal.divide(new BigDecimal(ruleRecordList.size()), 2, RoundingMode.DOWN);
                for (CalculateRuleVO ruleVO : ruleList) {
                    Double max = ruleVO.getMax();
                    Double min = ruleVO.getMin();
                    //判断范围在哪个区间
                    if (checkRange(min, max, siteOnline.multiply(new BigDecimal(100)))) {
                        //需要扣除的分数
                        Double deductScore = ruleVO.getCalcFraction();
                        ContractScore contractScore = new ContractScore();
                        contractScore.setContractId(Long.parseLong(contractId + ""));
                        contractScore.setAuditingStatus(AuditingStatus.PASS);
                        contractScore.setAuditingTime(new Date());
                        contractScore.setAuditingUser(Remark);
                        contractScore.setUnitId(Long.parseLong(unitId + ""));
                        contractScore.setRuleId(Long.parseLong(ruleVO.getId() + ""));
                        contractScore.setRuleIds("0," + ruleVO.getId());
                        contractScore.setNum(siteOnline + "");
                        contractScore.setDeductCategory(ruleVO.getDeductCategory().getDesc());
                        contractScore.setScore(new BigDecimal(deductScore));
                        contractScore.setRuleName(ruleVO.getRuleName() + "/" + ruleVO.getRuleCondition());
                        contractScore.setCreateTime(new Date());
                        contractScore.setUpdateTime(new Date());
                        contractScore.setRemark(Remark);
                        contractScoreList.add(contractScore);
                    }
                }
            }
        });
//        }
        contractScoreService.saveBatch(contractScoreList);
        log.info("结束计算合同点位在线率分数");
    }

    private boolean checkRange(Double min, Double max, BigDecimal siteOnline) {
        if (siteOnline == null) {
            return false;
        }
        if (max != null && siteOnline.compareTo(new BigDecimal(max)) > 0) {
            return false;
        }
        if (min != null && siteOnline.compareTo(new BigDecimal(min)) < 0) {
            return false;
        }
        return true;
    }

    /**
     *   检测工单表 进行合同积分扣除
     *   查出工单需要扣分的所有规则
     *   查出未扣分且已经审核完成了的工单组成map<unitId,List<WorkOrder>> 工单需要连工单故障表查出多个故障类型
     *   循环工单map，每个工单故障类型查对应的规则，根据规则和工单创建时间和审核通过时间进行扣分
     *   插入合同积分表，修改工单状态为已扣分
     */
    public void workOrderDeduct() {
        //查询生效合同对应所有的规则
        List<CalculateRuleVO> calculateRules = contractMapper.getCalculateRule(new Date());
        Map<String, Map<Integer, List<CalculateRuleVO>>> ruleMap = calculateRules.stream()
                .collect(Collectors.groupingBy(
                        CalculateRuleVO::getRuleName,  // 按规则名称分组
                        Collectors.groupingBy(
                                CalculateRuleVO::getContractId // 每个规则名称内部再按合同ID分组,value为规则集合
                        )
                ));
        //前端感知源治理工作（时钟同步规则、OSD规则、一机一档规则） 获取key为合同id，value为规则的map
        Map<Integer, List<CalculateRuleVO>> monitorRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Monitor.getName());
        //存储故障（24小时以内，48小时以内） 获取key为合同id，value为规则的map
        Map<Integer, List<CalculateRuleVO>> storeRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Store.getName());
        //点位异常情况处理 获取key为合同id，value为规则的map
        Map<Integer, List<CalculateRuleVO>> siteRuleMap = ruleMap.get(ContractRule.CONTRACT_RULE_Site.getName());

    }
    /**
     *  不定期检查数据 扣除积分
     */
    public void randomDeduct() {

    }

}