package com.estate.expert.admin.service.impl;

import com.alibaba.excel.util.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.estate.expert.admin.domain.business.client.Client;
import com.estate.expert.admin.domain.business.client.ClientRepository;
import com.estate.expert.admin.domain.business.device.Device;
import com.estate.expert.admin.domain.business.device.DeviceRepository;
import com.estate.expert.admin.domain.business.device.DeviceType;
import com.estate.expert.admin.domain.business.sign.project.ProjectSignRecord;
import com.estate.expert.admin.domain.business.sign.project.ProjectSignRecordRepository;
import com.estate.expert.admin.domain.common.request.PageReq;
import com.estate.expert.admin.domain.common.request.ScreenRangeRequest;
import com.estate.expert.admin.domain.common.request.ScreenRequest;
import com.estate.expert.admin.domain.exam.eval.fuzzy.EvalFuzzyResult;
import com.estate.expert.admin.domain.exam.eval.fuzzy.EvalFuzzyResultRepository;
import com.estate.expert.admin.domain.exam.eval.fuzzy.FuzzyResult;
import com.estate.expert.admin.domain.exam.eval.fuzzy.FuzzyValue;
import com.estate.expert.admin.domain.exam.record.error.ErrorLevel;
import com.estate.expert.admin.domain.exam.record.error.ErrorRecord;
import com.estate.expert.admin.domain.exam.record.error.ErrorRecordDto;
import com.estate.expert.admin.domain.exam.record.error.ErrorRecordRepository;
import com.estate.expert.admin.domain.exam.task.check.CheckTask;
import com.estate.expert.admin.domain.plan.Plan;
import com.estate.expert.admin.domain.plan.PlanType;
import com.estate.expert.admin.domain.project.Project;
import com.estate.expert.admin.domain.project.ProjectDto;
import com.estate.expert.admin.domain.project.detail.AddressInfo;
import com.estate.expert.admin.domain.project.enums.ProjectType;
import com.estate.expert.admin.domain.standard.hierachy.Hierarchy;
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
import com.estate.expert.admin.domain.standard.problem.Problem;
import com.estate.expert.admin.domain.user.User;
import com.estate.expert.admin.domain.user.UserRepository;
import com.estate.expert.admin.service.*;
import com.estate.expert.admin.service.screen.ScreenService;
import com.estate.expert.admin.utils.tree.TreeNode;
import com.estate.expert.admin.utils.tree.helper.TreeHelper;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 大屏服务实现
 */
@Slf4j
@Service
public class ScreenServiceImpl implements ScreenService {
    @Resource
    private ErrorRecordRepository errorRecordRepository;

    @Resource
    private EvalFuzzyResultRepository evalFuzzyResultRepository;

    @Resource
    private DeviceRepository deviceRepository;

    @Resource
    private HierarchyService hierarchyService;

    @Resource
    private ProjectSignRecordRepository projectSignRecordRepository;

    @Resource
    private ClientRepository clientRepository;

    @Resource
    private UserRepository userRepository;

    @Resource
    private UserService userService;

    @Resource
    private ClientService clientService;

    @Resource
    private ProjectService projectService;

    @Resource
    private ErrorRecordService errorRecordService;


    @Override
    public Map<String, Object> dataIntegration(ScreenRangeRequest screenRangeRequest) {
        //什么都不传递就是当天
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        Map<String, Object> stringObjectHashMap = new HashMap<>();
        List<ProjectSignRecord> projectSignRecords = projectSignRecordRepository.listSignRecord(startTime, endTime);
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
        Set<Integer> ids = new HashSet<>();
        //设备检查项次
        int equipmentInspectionItems = 0;
        for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
            Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
            if(null!=deviceResMap){
                Set<Integer> integers = deviceResMap.keySet();
                for (Integer integer : integers) {
                    ids.add(integer);
                }
                for (Integer ignored : deviceResMap.keySet()) {
                    equipmentInspectionItems++;
                }
            }
        }
        List<Device> deviceByIds = deviceRepository.findDeviceByIds(ids.stream().toList());
        Map<String, List<Device>> deviceGroupBy = deviceByIds.stream().collect(Collectors.groupingBy(res -> res.getProperties().get("工程起重机械租赁单位")));
        int hiddenDangers = 0;
        HashMap<String, Integer> deviceStatistics = new HashMap<>();
        for (DeviceType value : DeviceType.values()) {
            deviceStatistics.put(value.getDesc(),0);
        }
        Map<String, Integer> safetyHazards = new HashMap<>();
        ErrorLevel[] values = ErrorLevel.values();
        for (ErrorLevel value : values) {
            safetyHazards.put(value.getDesc(),0);
        }
        for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
            FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
            int[] totalErrorCounts = systemRes.getContent().getData().getTotalErrorCounts();
            hiddenDangers += Arrays.stream(totalErrorCounts).sum();
            for (int i = 0; i < values.length; i++) {
                Integer count = safetyHazards.get(values[i].getDesc());
                count += totalErrorCounts[i];
                safetyHazards.put(values[i].getDesc(),count);
            }
            Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
            for (Integer i : deviceResMap.keySet()) {
                FuzzyResult fuzzyResult = deviceResMap.get(i);
                hiddenDangers += Arrays.stream(fuzzyResult.getContent().getData().getTotalErrorCounts()).sum();
                List<Device> collect = deviceByIds.stream().filter(res -> res.getId() == i).collect(Collectors.toList());
                if(collect.size()>0){
                    Device device = collect.get(0);
                    Integer typeCount = deviceStatistics.get(device.getType().getDesc());
                    typeCount ++;
                    deviceStatistics.put(device.getType().getDesc(),typeCount);
                }
            }
        }
        List<Project> projectList = evalFuzzyResults.stream().map(EvalFuzzyResult::getProject).collect(Collectors.toList());
        List<Integer> projectListById = projectList.stream().collect(Collectors.groupingBy(Project::getId)).keySet().stream().toList();
        Map<ProjectType, List<Project>> collect = projectList.stream().collect(Collectors.groupingBy(res -> res.getType()));
        stringObjectHashMap.put("patrolItems",projectListById.size());//巡查项目
        stringObjectHashMap.put("patrolTeam",projectList.size());//巡查组
        stringObjectHashMap.put("hiddenDangers",hiddenDangers);//隐患问题
        Map<String, Object> projectStatistics = new HashMap<>();
        for (ProjectType projectType : collect.keySet()) {
            projectStatistics.put(projectType.getDesc(),collect.get(projectType).size());
        }
        int plannedAttendance = 0;
        int actualAttendance = 0;
        Map<Integer, List<ProjectSignRecord>> projectSignRecordById = projectSignRecords.stream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
        for (Integer id : projectSignRecordById.keySet()) {
            Map<Integer, List<ProjectSignRecord>> process = projectSignRecordById.get(id).stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
            //计划考勤
            List<EvalFuzzyResult> collectProcess = evalFuzzyResults.stream().filter(res -> process.keySet().contains(res.getProject().getId())).collect(Collectors.toList());
            //这个就是实际考勤
            if(collectProcess.size()>0){
                actualAttendance++;
            }
            plannedAttendance++;
        }
        HashMap<String, Integer> achievement = new HashMap<>();
        achievement.put("project",projectListById.size());
        achievement.put("record",evalFuzzyResults.size());
        achievement.put("hiddenDangers",hiddenDangers);
        HashMap<String, Integer> personnelAttendance = new HashMap<>();
        personnelAttendance.put("plannedAttendance",plannedAttendance);
        personnelAttendance.put("actualAttendance",actualAttendance);
        stringObjectHashMap.put("personnelAttendance",personnelAttendance);
        stringObjectHashMap.put("projectStatistics",projectStatistics);
        stringObjectHashMap.put("deviceStatistics",deviceStatistics);
        stringObjectHashMap.put("safetyHazards",safetyHazards);
        stringObjectHashMap.put("achievement",achievement);
        HashMap<String, Integer> device = new HashMap<>();
        device.put("lessor",deviceGroupBy.keySet().size());
        device.put("equipmentInspectionItems",equipmentInspectionItems);
        stringObjectHashMap.put("device",device);
        return stringObjectHashMap;
    }

    @Override
    public List<Map<String, Object>> attendance(ScreenRangeRequest screenRangeRequest) {
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        //获取到当前的时间的考勤
        List<ProjectSignRecord> projectSignRecords = projectSignRecordRepository.listSignRecord(startTime, endTime);
        List<Integer> projectIds = projectSignRecords.stream().map(res -> res.getProject().getId()).collect(Collectors.toList());
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.getEvalFuzzyResultProjectIds(projectIds,startTime,endTime);
        List<Map<String, Object>> maps = new ArrayList<>();
        Map<Integer, List<ProjectSignRecord>> projectSignRecordById = projectSignRecords.stream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
        for (Integer id : projectSignRecordById.keySet()) {
            Map<Integer, List<ProjectSignRecord>> process = projectSignRecordById.get(id).stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
            //计划考勤
            List<EvalFuzzyResult> collectProcess = evalFuzzyResults.stream().filter(res -> process.keySet().contains(res.getProject().getId())).collect(Collectors.toList());
            //这个就是实际考勤
            ProjectSignRecord projectSignRecord = projectSignRecordById.get(id).get(0);
            Map<String, Object> stringObjectHashMap = new HashMap<>();
            stringObjectHashMap.put("clientName",projectSignRecord.getProject().getClient().getName());
            stringObjectHashMap.put("name",projectSignRecord.getCreator().getName());
            stringObjectHashMap.put("phone",projectSignRecord.getCreator().getMobile());
            stringObjectHashMap.put("checkTime",projectSignRecord.getCreateTime());
            if(collectProcess.size()>0){
                stringObjectHashMap.put("inspectionTime",collectProcess.get(0).getCreateTime());
            }else{
                stringObjectHashMap.put("inspectionTime","未打卡");
            }
            stringObjectHashMap.put("creatorId",projectSignRecord.getCreator().getId());
            maps.add(stringObjectHashMap);
        }
        return maps;
    }

    @Override
    public List<Map<String, Object>> basedInspectionResults(String name, Integer creatorId,ScreenRangeRequest screenRangeRequest) {
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        //如果没有传入姓名或者id 那就查询所有人 然后时间是到今日
        List<Map<String, Object>> maps = new ArrayList<>();
        List<User> userList = new ArrayList<>();
        if(null== name && null == creatorId){
            List<User> userLists = userRepository.findNoDeleted();
            userList = userLists;
        }else{
            if(StringUtils.isEmpty(name)){
                Optional<User> users = userRepository.findById(creatorId);
                userList.add(users.get());
            }else{
                userList = userRepository.findByNameLike(name);
            }
        }
        List<Integer> userIds = userList.stream().map(User::getId).collect(Collectors.toList());
        List<ErrorRecord> errorRecords = errorRecordRepository.inspectionResultsBasedOnPersonnel(userIds, startTime, endTime);
        Map<Integer, List<ErrorRecord>> collect = errorRecords.parallelStream().collect(Collectors.groupingBy(res -> res.getCreator().getId()));
        for (User user : userList) {
            Map<String, Object> stringObjectHashMap = new HashMap<>();
            List<ErrorRecord> errorRecordLists = collect.get(user.getId());
            Map<String, List<ErrorRecord>> collected = null;
            if(null!=errorRecordLists){
                collected = errorRecordLists.stream().collect(Collectors.groupingBy(res -> res.getLevel().getDesc()));
            }
            ErrorLevel[] values = ErrorLevel.values();
            for (ErrorLevel value : values) {
                String desc = value.getDesc();
                if(null == collected){
                    stringObjectHashMap.put(desc,0);
                }else{
                    List<ErrorRecord> errorRecordsLists = collected.get(desc);
                    if(null!=errorRecordsLists){
                        stringObjectHashMap.put(desc,errorRecordsLists.size());
                    }else{
                        stringObjectHashMap.put(desc,0);
                    }
                }
            }
            stringObjectHashMap.put("userId",user.getId());
            stringObjectHashMap.put("name",user.getName());
            maps.add(stringObjectHashMap);
        }
        return maps;
    }

    @Override
    public Map<String,Object> rentalManufacturerMalfunction(ScreenRangeRequest screenRangeRequest){
        HashMap<String, Object> dataMap = new HashMap<>();
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        List<Device> devices = deviceRepository.findDevices();
        Map<String, List<Device>> deviceByProperties = devices.stream().filter(res -> {
            Map<String, String> properties = res.getProperties();
            if (null != properties) {
                if (null != properties.get("工程起重机械租赁单位")) {
                    return true;
                }
            }
            return false;
        }).collect(Collectors.groupingBy(res -> res.getProperties().get("工程起重机械租赁单位")));
        //根据时间获取这些数据
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDateByContainDeviceRes(null,startTime, endTime);
        List<Map<Integer, FuzzyResult>> devicesMaps = evalFuzzyResults.stream().map(EvalFuzzyResult::getDeviceResMap).collect(Collectors.toList());
        ArrayList<HashMap<String, Object>> hashMaps = new ArrayList<>();
        for (String renting : deviceByProperties.keySet()) {
            HashMap<String, Object> stringObjectHashMap = new HashMap<>();
            //renting 租聘厂商
            int dangerLevelByOne = 0;
            int failureRate = 0;
            int total = 0;
            HashMap<String, Integer> statistics = new HashMap<>();
            HashMap<String, Integer> statisticsFailureRate = new HashMap<>();
            HashMap<String, Integer> statisticsDangerLevelByOne = new HashMap<>();
            for (DeviceType value : DeviceType.values()) {
                statistics.put(value.getDesc(),0);
                statisticsFailureRate.put(value.getDesc(),0);
                statisticsDangerLevelByOne.put(value.getDesc(),0);
            }
            List<Device> deviceList = deviceByProperties.get(renting);
            for (Map<Integer, FuzzyResult> devicesMap : devicesMaps) {
                for (Device device : deviceList) {
                    FuzzyResult fuzzyResult = devicesMap.get(device.getId());
                    if(null != fuzzyResult){
                        int[] totalErrorCounts = fuzzyResult.getContent().getData().getTotalErrorCounts();
                        if(totalErrorCounts[0]>0){
                            //说明有一级故障率
                            dangerLevelByOne++;
                            Integer count = statisticsDangerLevelByOne.get(device.getType().getDesc());
                            if(null!=count){
                                count++;
                                statisticsDangerLevelByOne.put(device.getType().getDesc(),count);
                            }
                        }
                        if(Arrays.stream(totalErrorCounts).sum()>0){
                            failureRate++;
                            Integer count = statisticsFailureRate.get(device.getType().getDesc());
                            if(null!=count){
                                count++;
                                statisticsFailureRate.put(device.getType().getDesc(),count);
                            }
                        }
                        total++;
                        Integer count = statistics.get(device.getType().getDesc());
                        if(null!=count){
                            count++;
                            statistics.put(device.getType().getDesc(),count);
                        }
                    }
                }
            }
            if(failureRate !=0 && total != 0 && dangerLevelByOne!=0){
                double failurePercentage = (failureRate / total) * 100;
                double dangerLevelByOnePercentage = (dangerLevelByOne / total) * 100;
                stringObjectHashMap.put("failurePercentage",new BigDecimal(failurePercentage).setScale(2,BigDecimal.ROUND_HALF_UP)+"%");
                stringObjectHashMap.put("dangerLevelByOnePercentage",new BigDecimal(dangerLevelByOnePercentage).setScale(2,BigDecimal.ROUND_HALF_UP)+"%");
            }else{
                stringObjectHashMap.put("failurePercentage","0%");
                stringObjectHashMap.put("dangerLevelByOnePercentage","0%");
            }
            ArrayList<HashMap<String, Object>> equipmentStatistics = new ArrayList<>();
            Integer totalCount = 0;
            Integer totalNormal = 0;
            Integer totalFailure = 0;
            for (DeviceType value : DeviceType.values()) {
                HashMap<String, Object> equipmentStatistic = new HashMap<>();
                Integer count = statistics.get(value.getDesc());
                Integer failureRateCount = statisticsFailureRate.get(value.getDesc());
                Integer normal = count - failureRateCount;
                equipmentStatistic.put("renting",value.getDesc());
                equipmentStatistic.put("inspectionFrequency",count);
                equipmentStatistic.put("failure",failureRateCount);
                equipmentStatistic.put("normal",normal);
                equipmentStatistics.add(equipmentStatistic);
                totalFailure+=failureRateCount;
                totalNormal+=normal;
                totalCount+=count;
            }
            stringObjectHashMap.put("equipmentStatistics",equipmentStatistics);
            stringObjectHashMap.put("renting",renting);
            stringObjectHashMap.put("total",totalCount);
            stringObjectHashMap.put("totalNormal",totalNormal);
            stringObjectHashMap.put("totalFailure",totalFailure);
            hashMaps.add(stringObjectHashMap);
        }
        List<ArrayList<Map<String, Object>>> equipmentStatistics = hashMaps.stream().map(res -> (ArrayList<Map<String, Object>>) res.get("equipmentStatistics")).collect(Collectors.toList());
        Map<String, List<Map<String, Object>>> rentingMaps = equipmentStatistics.stream()
                .flatMap(subList -> subList.stream())
                .collect(Collectors.groupingBy(
                        map -> (String) map.get("renting")));
        ArrayList<HashMap<String, Object>> totalEquipmentStatisticsMaps = new ArrayList<>();
        for (String deviceTypeDesc : rentingMaps.keySet()) {
            HashMap<String, Object> totalEquipmentStatistics = new HashMap<>();
            List<Map<String, Object>> mapsProcess = rentingMaps.get(deviceTypeDesc);
            int inspectionFrequency = mapsProcess.stream().mapToInt(res -> (Integer) res.get("inspectionFrequency")).sum();
            int failure = mapsProcess.stream().mapToInt(res -> (Integer) res.get("failure")).sum();
            int normal = mapsProcess.stream().mapToInt(res -> (Integer) res.get("normal")).sum();
            totalEquipmentStatistics.put("renting",deviceTypeDesc);
            totalEquipmentStatistics.put("inspectionFrequency",inspectionFrequency);
            totalEquipmentStatistics.put("failure",failure);
            totalEquipmentStatistics.put("normal",normal);
            totalEquipmentStatisticsMaps.add(totalEquipmentStatistics);
        }
        dataMap.put("total",hashMaps.stream().mapToInt(res->(Integer) res.get("total")).sum());
        dataMap.put("totalNormal",hashMaps.stream().mapToInt(res->(Integer) res.get("totalNormal")).sum());
        dataMap.put("totalFailure",hashMaps.stream().mapToInt(res->(Integer) res.get("totalFailure")).sum());
        dataMap.put("totalEquipmentStatistics",totalEquipmentStatisticsMaps);
        dataMap.put("result",hashMaps);
        return dataMap;
//        Map<String, Device> stringDeviceHashMap = new HashMap<>();
//        for (Device device : devices) {
//            Map<String, String> properties = device.getProperties();
//            if(null!=properties){
//                String rental = properties.get("工程起重机械租赁单位");
//                if(null!=rental && !rental.equals("null")){
//                    stringDeviceHashMap.put(rental,device);
//                }
//            }
//        }
//        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
//        HashMap<String, Map<String,Double>> statisticsProcess = new HashMap<>();
//        HashMap<String, Object> stringObjectHashMap = new HashMap<>();
//        int totalAll = 0;
//        int faultTotal = 0;
//        if(evalFuzzyResults.size()>0){
//            DeviceType[] values = DeviceType.values();
//            HashMap<String, Map<String,Double>> statistics = new HashMap<>();
//            for (String rentalVendors : stringDeviceHashMap.keySet()) {
//                HashMap<String, Object> rate = new HashMap<>();
//                Device device = stringDeviceHashMap.get(rentalVendors);
//                double total = 0;
//                double fault = 0;
//                double danger = 0;
//                for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
//                    Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
//                    //获取到当前的
//                    FuzzyResult fuzzyResult = deviceResMap.get(device.getId());
//                    if(null!=fuzzyResult){
//                        int[] totalErrorCounts = fuzzyResult.getContent().getData().getTotalErrorCounts();
//                        int sum = Arrays.stream(totalErrorCounts).sum();
//                        if(sum>0){
//                            //就代表有隐患有隐患就故障了
//                            fault++;
//                            faultTotal++;
//                        }
//                        if(totalErrorCounts[0] >0 ){
//                            danger++;
//                        }
//                    }
//                    total++;
//                    totalAll++;
//                }
//                double equipmentFailureRate =  (fault / total) * 100;
//                double gradeHazardRate =  (danger / total) * 100;
//                rate.put("equipmentFailureRate",equipmentFailureRate);
//                rate.put("gradeHazardRate",gradeHazardRate);
//                stringObjectHashMap.put(rentalVendors,rate);
//                Map<String, Double> stringObjectMap = statistics.get(device.getType().getDesc());
//                if(null == stringObjectMap){
//                    HashMap<String, Double> deviceStatistics = new HashMap<>();
//                    deviceStatistics.put("normal",(total - fault));
//                    deviceStatistics.put("total",total);
//                    deviceStatistics.put("fault",fault);
//                    statistics.put(device.getType().getDesc(),deviceStatistics);
//                }else{
//                    Double normal = stringObjectMap.get("normal");
//                    Double totalProcess = stringObjectMap.get("total");
//                    Double faultProcess = stringObjectMap.get("fault");
//                    normal += (total - fault);
//                    totalProcess += total;
//                    faultProcess += fault;
//                    stringObjectMap.put("normal",normal);
//                    stringObjectMap.put("total",totalProcess);
//                    stringObjectMap.put("fault",faultProcess);
//                    statistics.put(device.getType().getDesc(),stringObjectMap);
//                }
//            }
//
//            for (DeviceType value : values) {
//                Map<String, Double> stringDoubleMap = statistics.get(value.getDesc());
//                if(null==stringDoubleMap){
//                    HashMap<String, Double> deviceStatistics = new HashMap<>();
//                    deviceStatistics.put("normal",0.0);
//                    deviceStatistics.put("total",0.0);
//                    deviceStatistics.put("fault",0.0);
//                    statisticsProcess.put(value.getDesc(),deviceStatistics);
//                }else{
//                    statisticsProcess.put(value.getDesc(),stringDoubleMap);
//                }
//            }
//        }
//        HashMap<String, Object> resultMap = new HashMap<>();
//        resultMap.put("devices",stringObjectHashMap);
//        resultMap.put("equipmentStatistics",statisticsProcess);
//        resultMap.put("normal",(totalAll-faultTotal));
//        resultMap.put("fault",faultTotal);
//        return resultMap;
    }

    public Map<String,Object> inspectionSituation(ScreenRangeRequest screenRangeRequest){
        Map<String, Object> mapData = new HashMap<>();
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituation(startTime, endTime);
        //获取所有的user和teamLeader
        Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Integer i : collect.keySet()) {
            Map<String, Object> stringObjectHashMap = new HashMap<>();
            //获取这个对象 目前不管多个只需1
            EvalFuzzyResult evalFuzzyResult = collect.get(i).get(0);
            PlanType type = evalFuzzyResult.getPlan().getType();
            FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
            Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
            int p1 = 0;
            int p2 = 0;
            int p3 = 0;
            int p4 = 0;
            int equipmentHazards = 0;
            for (Integer integer : deviceResMap.keySet()) {
                int[] totalErrorCounts = deviceResMap.get(integer).getContent().getData().getTotalErrorCounts();
                equipmentHazards += Arrays.stream(totalErrorCounts).sum();
                p1 += totalErrorCounts[0];
                p2 += totalErrorCounts[1];
                p3 += totalErrorCounts[2];
                p4 += totalErrorCounts[3];
            }
            int[] totalErrorCountsSys = systemRes.getContent().getData().getTotalErrorCounts();
            p1 += totalErrorCountsSys[0];
            p2 += totalErrorCountsSys[1];
            p3 += totalErrorCountsSys[2];
            p4 += totalErrorCountsSys[3];
            int []totalErrorCounts = {p1,p2,p3,p4};
            equipmentHazards+= Arrays.stream(systemRes.getContent().getData().getTotalErrorCounts()).sum();
            String groupName = "";
            if(type == PlanType.SECURITY_CHECK){
                groupName = "安全小组";
            }else if(type == PlanType.QUALITY_CHECK){
                groupName = "质量小组";
            }else if(type == PlanType.EQUIPMENT_CHECK){
                groupName = "设备小组";
            }
            Project project = evalFuzzyResult.getProject();
            //获取检查任务
            CheckTask task = evalFuzzyResult.getTask();
            var groupLeaders = task.getGroupLeaders();
            var groupMembers = task.getGroupMembers();
            String name = project.getName();
            stringObjectHashMap.put("projectName",name);
            stringObjectHashMap.put("groupLeaders",groupLeaders.stream().map(res->res.getName()).collect(Collectors.toList()));
            stringObjectHashMap.put("groupMembers",groupMembers.stream().map(res->res.getName()).collect(Collectors.toList()));
            stringObjectHashMap.put("groupName",groupName);
            stringObjectHashMap.put("totalDanger",equipmentHazards);
            stringObjectHashMap.put("totalErrorCounts",totalErrorCounts);
            maps.add(stringObjectHashMap);
        }
        int p1 = 0;
        int p2 = 0;
        int p3 = 0;
        int p4 = 0;
        for (Map<String, Object> map : maps) {
            Object obj = map.get("totalErrorCounts");
            if(null!=obj){
                int [] totalErrorCounts = (int []) obj;
                p1 += totalErrorCounts[0];
                p2 += totalErrorCounts[1];
                p3 += totalErrorCounts[2];
                p4 += totalErrorCounts[3];
            }
        }
        int []totalErrorCounts = {p1,p2,p3,p4};
        mapData.put("result",maps);
        mapData.put("totalErrorCounts",totalErrorCounts);
        return mapData;
    }

    public Map<String, Object> inspectionStatisticsByClient(ScreenRangeRequest screenRangeRequest){
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        Map<String, Object> stringObjectHashMap = new HashMap<>();
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime,endTime);
        //检查项目统计
        ProjectType[] projectTypes = ProjectType.values();
        PlanType[] planTypes = PlanType.values();
        HashMap<String, Integer> projectStatistics = new HashMap<>();
        for (ProjectType projectType : projectTypes) {
            projectStatistics.put(projectType.getDesc(),0);
        }
        HashMap<String, Integer> reportStatistics = new HashMap<>();
        for (PlanType planType : planTypes) {
            reportStatistics.put(planType.getDesc(),0);
        }
        HashMap<String, int[]> stringHashMap = new HashMap<>();
        for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
            Integer planCount = reportStatistics.get(evalFuzzyResult.getPlan().getType().getDesc());
            Integer projectCount = projectStatistics.get(evalFuzzyResult.getProject().getType().getDesc());
            planCount++;
            projectCount++;
            reportStatistics.put(evalFuzzyResult.getPlan().getType().getDesc(),planCount);
            projectStatistics.put(evalFuzzyResult.getProject().getType().getDesc(),projectCount);
            FuzzyResult systemRes = evalFuzzyResult.getSystemRes();
            TreeHelper.bfsTravel(systemRes.root(), (node) -> {
                if(node.getDepth() == 4) {
                    //获取4级节点
                    int[] integers = stringHashMap.get(node.getName());
                    if(null == integers){
                        stringHashMap.put(node.getName(),node.getData().getTotalErrorCounts());
                    }else{
                        int[] totalErrorCounts = node.getData().getTotalErrorCounts();
                        for (int i = 0; i < totalErrorCounts.length; i++) {
                            integers[i] += totalErrorCounts[i];
                        }
                        stringHashMap.put(node.getName(),integers);
                    }
                }
            });
        }
        stringObjectHashMap.put("reportStatistics",reportStatistics);
        stringObjectHashMap.put("projectStatistics",projectStatistics);
        stringObjectHashMap.put("dangerData",stringHashMap);
        return stringObjectHashMap;
    }

    public List<HashMap<String, Object>> dangerTrendWheel(Integer clientId, ScreenRangeRequest screenRangeRequest){
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(clientId,startTime,endTime);
        Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().sorted(Comparator.comparing(vl -> vl.getPlan().getId())).collect(Collectors.groupingBy(vl -> vl.getPlan().getId()));
        List<HashMap<String, Object>> hashMaps = new ArrayList<>();
        for (Integer i : collect.keySet()) {
            List<EvalFuzzyResult> evalFuzzyResultsList = collect.get(i);
            HashMap<String, int[]> parent = new HashMap<>();
            HashMap<String, Map<String,int[]>> children = new HashMap<>();
            for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsList) {
                TreeHelper.bfsTravel(evalFuzzyResult.getSystemRes().root(), (node) -> {
                    if(node.getDepth() == 4) {
                        int[] integers = parent.get(node.getName());
                        if(null == integers){
                            parent.put(node.getName(),node.getData().getTotalErrorCounts());
                        }else{
                            int[] totalErrorCounts = node.getData().getTotalErrorCounts();
                            for (int j = 0; j < totalErrorCounts.length; j++) {
                                integers[j] += totalErrorCounts[j];
                            }
                            parent.put(node.getName(),integers);
                        }
                    }
                });
            }
            for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsList) {
                TreeHelper.bfsTravel(evalFuzzyResult.getSystemRes().root(), (node) -> {
                    if(node.getDepth() == 6) {
                        //获取四级的
                        TreeNode<FuzzyValue> parentNode = node.getParent().getParent();
                        Map<String, int[]> stringIntegerMap = children.get(parentNode.getName());
                        HashMap<String, int[]> stringHashMap = new HashMap<>();
                        if(null == stringIntegerMap){
                            stringHashMap.put(node.getName(),node.getData().getTotalErrorCounts());
                            children.put(parentNode.getName(),stringHashMap);
                        }else{
                            int[] integers = stringIntegerMap.get(node.getName());
                            if(null == integers){
                                stringIntegerMap.put(node.getName(),node.getData().getTotalErrorCounts());
                                children.put(parentNode.getName(),stringIntegerMap);
                            }else{
                                int[] totalErrorCounts = node.getData().getTotalErrorCounts();
                                for (int j = 0; j < totalErrorCounts.length; j++) {
                                    integers[j] += totalErrorCounts[j];
                                }
                                stringHashMap.put(node.getName(),integers);
                                children.put(parentNode.getName(),stringHashMap);
                            }
                        }
                    }
                });
            }
            ArrayList<Map<String, Object>> maps = new ArrayList<>();
            for (String value : parent.keySet()) {
                //获取子集的数据
                Map<String, int[]> stringMap = children.get(value);
                //父
                int[] ints = parent.get(value);
                HashMap<String, Object> dataMap = new HashMap<>();
                dataMap.put("name",value);
                dataMap.put("danger",ints);
                dataMap.put("children",stringMap);
                maps.add(dataMap);
            }
            HashMap<String, Object> planMaps = new HashMap<>();
            planMaps.put("round",i);
            planMaps.put("data",maps);
            hashMaps.add(planMaps);
        }
        return hashMaps;
    }
    //工程概述
    @Override
    public List<HashMap<String, Object>> engineeringOverview(){
        //这个就是一个evalFuzzy就对应一个task 一个task就是一次检查
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,null, null);
        //根据项目进行分组
        Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
        List<HashMap<String, Object>> maps = new ArrayList<>();
        for (Integer i : collect.keySet()) {
            HashMap<String, Object> stringObjectHashMap = new HashMap<>();
            //然后根据这个项目里面plan来分组 看看有几轮一个plan就代表一轮
            List<EvalFuzzyResult> evalFuzzyResultsProcess = collect.get(i);
            Map<Integer, List<EvalFuzzyResult>> planSize = evalFuzzyResultsProcess.stream().collect(Collectors.groupingBy(res -> res.getPlan().getId()));
            int p1 = 0;
            int p2 = 0;
            int p3 = 0;
            int p4 = 0;
            int dangers = 0;
            Project project = new Project();
            for (EvalFuzzyResult fuzzyResultsProcess : evalFuzzyResultsProcess) {
                project = fuzzyResultsProcess.getProject();
                Map<Integer, FuzzyResult> deviceResMap = fuzzyResultsProcess.getDeviceResMap();
                FuzzyResult systemRes = fuzzyResultsProcess.getSystemRes();
                for (Integer integer : deviceResMap.keySet()) {
                    int[] totalErrorCounts = deviceResMap.get(integer).getContent().getData().getTotalErrorCounts();
                    p1 += totalErrorCounts[0];
                    p2 += totalErrorCounts[1];
                    p3 += totalErrorCounts[2];
                    p4 += totalErrorCounts[3];
                    dangers += Arrays.stream(totalErrorCounts).sum();
                }
                int[] totalErrorCountsSys = systemRes.getContent().getData().getTotalErrorCounts();
                p1 += totalErrorCountsSys[0];
                p2 += totalErrorCountsSys[1];
                p3 += totalErrorCountsSys[2];
                p4 += totalErrorCountsSys[3];
                dangers+= Arrays.stream(systemRes.getContent().getData().getTotalErrorCounts()).sum();
            }
            int []totalErrorCounts = {p1,p2,p3,p4};
            AddressInfo addressInfo = project.getAddressInfo();
            stringObjectHashMap.put("name",project.getName());
            stringObjectHashMap.put("type",project.getType().getDesc());
            stringObjectHashMap.put("address",addressInfo.getProvince()+addressInfo.getCity()+addressInfo.getDistrict()+addressInfo.getDetail());
            stringObjectHashMap.put("projectCost",project.getProjectCost());
            stringObjectHashMap.put("checkRound",planSize.keySet().size());
            stringObjectHashMap.put("dangersCount",dangers);
            stringObjectHashMap.put("totalErrorCounts",totalErrorCounts);
            stringObjectHashMap.put("constructionCompanyInfo",project.getConstructionCompanyInfo());
            stringObjectHashMap.put("supervisorCompanyInfo",project.getSupervisorCompanyInfo());
            stringObjectHashMap.put("developmentCompanyInfo",project.getDevelopmentCompanyInfo());
            maps.add(stringObjectHashMap);
        }
        return maps;
    }

    //弹出委托方检查统计
    public List<HashMap<String, Object>> clientInspectionStatistics(Integer clientIdP, ScreenRequest screenRequest, PageReq pageReq){
        String string = screenRequest.toString();
        ScreenRangeRequest screenRangeRequest = JSONObject.parseObject(string, ScreenRangeRequest.class);
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        Page<Client> clients = clientRepository.listClientsById(clientIdP,pageReq.toPageRequest());
        List<Client> content = clients.getContent();
        List<Integer> clientIds = content.stream().map(Client::getId).collect(Collectors.toList());
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationHaveClient(clientIds,startTime, endTime);
        Map<Integer, List<EvalFuzzyResult>> collect = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getClient().getId()));
        Set<Integer> ids = new HashSet<>();
        for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResults) {
            Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
            Set<Integer> integers = deviceResMap.keySet();
            for (Integer integer : integers) {
                ids.add(integer);
            }
        }
        List<Device> deviceByIds = deviceRepository.findDeviceByIds(ids.stream().toList());
        List<HashMap<String, Object>> hashMaps = new ArrayList<>();
        for (Integer clientId : clientIds) {
            HashMap<String, Object> stringObjectHashMap = new HashMap<>();
            List<EvalFuzzyResult> evalFuzzyResultsByClientId = collect.get(clientId);
            int comprehensiveSafetyInspection = 0;
            int specialSafetyInspection = 0;
            int specialEquipmentInspection = 0;
            //获取委托方公司
            Client client = content.stream().filter(res->res.getId() == clientId).collect(Collectors.toList()).get(0);
            HashMap<String, Integer> deviceTypeMap = new HashMap<>();
            //说明没有
            if(null != evalFuzzyResultsByClientId){
                //然后根据计划类型来分组
                Map<Plan, List<EvalFuzzyResult>> planListMap = evalFuzzyResultsByClientId.stream().collect(Collectors.groupingBy(EvalFuzzyResult::getPlan));
                for (Plan plan : planListMap.keySet()) {
                    List<EvalFuzzyResult> evalFuzzyResults1 = planListMap.get(plan);
                    if(plan.getType() == PlanType.COMPREHENSIVE_CHECK){
                        comprehensiveSafetyInspection += evalFuzzyResults1.size();
                    }
                    if(plan.getType() == PlanType.SECURITY_CHECK){
                        specialSafetyInspection += evalFuzzyResults1.size();
                    }
                    if(plan.getType() == PlanType.EQUIPMENT_CHECK){
                        specialEquipmentInspection += evalFuzzyResults1.size();
                    }
                }

                DeviceType[] values = DeviceType.values();
                for (DeviceType value : values) {
                    deviceTypeMap.put(value.getDesc(),0);
                }
                for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultsByClientId) {
                    Map<Integer, FuzzyResult> deviceResMap = evalFuzzyResult.getDeviceResMap();
                    for (Integer deviceId : deviceResMap.keySet()) {
                        List<Device> hasDevice = deviceByIds.stream().filter(res -> res.getId() == deviceId).collect(Collectors.toList());
                        Device device = null;
                        if(hasDevice.size()>0){
                            device = hasDevice.get(0);
                        }
                        if(null!=device){
                            Integer count = deviceTypeMap.get(device.getType().getDesc());
                            count++;
                            deviceTypeMap.put(device.getType().getDesc(),count);
                        }
                    }
                }
            }
            stringObjectHashMap.put("clientName",client.getName());
            stringObjectHashMap.put("clientId",client.getId());
            stringObjectHashMap.put("comprehensiveSafetyInspection",comprehensiveSafetyInspection);
            stringObjectHashMap.put("specialSafetyInspection",specialSafetyInspection);
            stringObjectHashMap.put("specialEquipmentInspection",specialEquipmentInspection);
            stringObjectHashMap.put("deviceMap",deviceTypeMap);
            hashMaps.add(stringObjectHashMap);
        }
        return hashMaps;
    }
    //项目得分
    public HashMap<String, Object> projectScore(ScreenRangeRequest screenRangeRequest){
        List<LocalDateTime> startTimeAndEndTime = getStartTimeAndEndTime(screenRangeRequest);
        LocalDateTime startTime = startTimeAndEndTime.get(0);
        LocalDateTime endTime = startTimeAndEndTime.get(1);
        List<EvalFuzzyResult> evalFuzzyResults = evalFuzzyResultRepository.todayInspectionSituationByDate(null,startTime, endTime);
        Map<Integer, List<EvalFuzzyResult>> planGroupBy = evalFuzzyResults.stream().collect(Collectors.groupingBy(res -> res.getPlan().getId()));
        HashMap<Integer, Object> stringObjectHashMap = new HashMap<>();
        for (Integer planId : planGroupBy.keySet()) {
            //获取每一轮的项目得分
            List<EvalFuzzyResult> evalFuzzyResultsByPlanId = planGroupBy.get(planId);
            Map<Integer, List<EvalFuzzyResult>> projectGroupBy = evalFuzzyResultsByPlanId.stream().collect(Collectors.groupingBy(res -> res.getProject().getId()));
            HashMap<Project, Double> projectDoubleHashMap = new HashMap<>();
            for (Integer projectId : projectGroupBy.keySet()) {
                List<EvalFuzzyResult> evalFuzzyResultList = projectGroupBy.get(projectId);
                Project project = evalFuzzyResultList.get(0).getProject();
                double score = 0;
                for (EvalFuzzyResult evalFuzzyResult : evalFuzzyResultList) {
                    score += evalFuzzyResult.getScore();
                }
                projectDoubleHashMap.put(project,score);
            }
            //Comparator.reverseOrder() 加这个就是倒叙
            Map<Project, Double> sortedMap = projectDoubleHashMap.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue())
                    .collect(Collectors.toMap(
                            Map.Entry::getKey,
                            Map.Entry::getValue,
                            (oldValue, newValue) -> oldValue,
                            LinkedHashMap::new
                    ));
            stringObjectHashMap.put(planId,sortedMap);
        }
        List<Map<String, Object>> maps = new ArrayList<>();
        for (Integer i : stringObjectHashMap.keySet()) {
            Object obj = stringObjectHashMap.get(i);
            Map<Project, Double> projectDoubleHashMap =  (Map<Project, Double>)obj;
            int j = 0;
            for (Project project : projectDoubleHashMap.keySet()) {
                j++;
                Map<String, Object> scoreMap = new HashMap<>();
                scoreMap.put("turn",i);
                scoreMap.put("turnDes","第"+i+"轮");
                scoreMap.put("project",projectService.toDto(project));
                scoreMap.put("score",projectDoubleHashMap.get(project));
                scoreMap.put("ranking",j);
                maps.add(scoreMap);
            }
        }
        //得分趋势 根据项目进行分组
        Map<String, List<Map<String, Object>>> projectMap = maps.stream().collect(Collectors.groupingBy(vl->{
            ProjectDto project = (ProjectDto) vl.get("project");
            return project.getName();
        }));
        HashMap<String, Object> map = new HashMap<>();
        //排名趋势
        map.put("scoringTrend",projectMap);
        map.put("rankingTrend",projectMap);
        map.put("datas",maps);
        return map;
    }

    //隐患列表
    @Override
    public Map<String, Object> dangerList(){
        //查询所有错误的数据
        List<ErrorRecord> errorRecordAndProblem = errorRecordRepository.getErrorRecordByNotDevice();
        Set<Integer> integers = errorRecordAndProblem.stream().collect(Collectors.groupingBy(res -> res.getProblem().getHierarchyId())).keySet();
        HashMap<Integer, Hierarchy> integerHierarchyHashMap = new HashMap<>();
        for (Integer hierarchyId : integers) {
            Hierarchy hierarchy = hierarchyService.get(hierarchyId);
            integerHierarchyHashMap.put(hierarchyId,hierarchy);
        }
        HashMap<String, List<ErrorRecord>> stringObjectHashMap = new HashMap<>();
        for (ErrorRecord errorRecord : errorRecordAndProblem) {
            Problem problem = errorRecord.getProblem();
            Hierarchy hierarchy = integerHierarchyHashMap.get(problem.getHierarchyId());
            TreeNode<HierarchyData> hierarchyDataTreeNode = hierarchy.getContent().get(problem.getHierarchyPath());
            int depth = hierarchyDataTreeNode.getDepth();
            for (int i = 0; i < depth -4 ; i++) {
                hierarchyDataTreeNode = hierarchyDataTreeNode.getParent();
            }
            String name = hierarchyDataTreeNode.getName();
            List<ErrorRecord> errorRecords = stringObjectHashMap.get(name);
            if(null == errorRecords){
                errorRecords = new ArrayList<>();
            }
            errorRecords.add(errorRecord);
            stringObjectHashMap.put(name,errorRecords);
        }
        List<Map<String, Object>> maps = new ArrayList<>();
        for (String danger : stringObjectHashMap.keySet()) {
            List<ErrorRecord> errorRecords = stringObjectHashMap.get(danger);
            Map<Integer, List<ErrorRecord>> collect = errorRecords.stream().collect(Collectors.groupingBy(vl -> vl.getCheckTask().getProject().getId()));
            for (Integer project : collect.keySet()) {
                List<ErrorRecord> errorRecordsByProject = collect.get(project);
                Map<Integer, List<ErrorRecord>> collectByPlan = errorRecordsByProject.stream().collect(Collectors.groupingBy(vl -> vl.getCheckTask().getPlan().getId()));
                for (Integer planId : collectByPlan.keySet()) {
                    List<ErrorRecord> errorRecordsByPlan = collectByPlan.get(planId);
                    Map<ErrorLevel, List<ErrorRecord>> collectByLevel = errorRecordsByPlan.stream().collect(Collectors.groupingBy(vl -> vl.getLevel()));
                    for (ErrorLevel errorLevel : collectByLevel.keySet()) {
                        Map<Boolean, List<ErrorRecord>> collectByReformed = collectByLevel.get(errorLevel).stream().collect(Collectors.groupingBy(vl -> vl.isReformed()));
                        for (Boolean b : collectByReformed.keySet()) {
                            HashMap<String, Object> stringObjectHashMapProcess = new HashMap<>();
                            stringObjectHashMapProcess.put("count",collectByReformed.get(b).size());
                            stringObjectHashMapProcess.put("project",errorRecordService.toDto(collect.get(project).get(0)));
                            stringObjectHashMapProcess.put("projectId",collect.get(project).get(0).getCheckTask().getProject().getId());
                            stringObjectHashMapProcess.put("plan",collectByPlan.get(planId).get(0).getCheckTask().getPlan().getId());
                            stringObjectHashMapProcess.put("danger",danger);
                            stringObjectHashMapProcess.put("level",errorLevel.getDesc());
                            if(b){
                                stringObjectHashMapProcess.put("reformed","已整改");
                            }else{
                                stringObjectHashMapProcess.put("reformed","未整改");
                            }
                            stringObjectHashMapProcess.put("value",collectByReformed.get(b).stream().map(res->errorRecordService.toDto(res)).collect(Collectors.toList()));
                            maps.add(stringObjectHashMapProcess);
                        }
                    }
                }
            }
        }
        List<HashMap<String, Object>> dangerMaps = new ArrayList<>();
        Map<String, List<Map<String, Object>>> dangerGroupBy = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("danger"))));
        Map<String, List<Map<String, Object>>> levelMaps = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("level"))));
        HashMap<String, Double> proportion = new HashMap<>();
        int total = 0;
        for (String level : levelMaps.keySet()) {
            int count = 0;
            for (Map<String, Object> stringObjectMap : levelMaps.get(level)) {
                count += Integer.parseInt(String.valueOf(stringObjectMap.get("count")));
            }
            total += count;
            proportion.put(level,Double.valueOf(count));
        }
        for (String level : proportion.keySet()) {
            double value = (proportion.get(level) / total) * 100;
            proportion.put(level,value);
        }
        for (String dangerName : dangerGroupBy.keySet()) {
            HashMap<String, Object> dangerMap = new HashMap<>();
            dangerMap.put("danger",dangerName);
            List<Map<String, Object>> dangerNames = dangerGroupBy.get(dangerName);
            //根据隐患等级获取到对于的数据
            Map<String, List<Map<String, Object>>> level = dangerNames.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("level"))));

            for (String levelValue : level.keySet()) {
                //隐患等级
                int count = 0;
                List<Map<String, Object>> mapsProcess = level.get(levelValue);
                for (Map<String, Object> process : mapsProcess) {
                    count += Integer.parseInt(String.valueOf(process.get("count")));
                }
                dangerMap.put(levelValue,count);
            }
            dangerMaps.add(dangerMap);
        }
        Map<String, List<Map<String, Object>>> planGroupBy = maps.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("plan"))));
        HashMap<String, Object> dangerByPlan = new HashMap<>();
        for (String planId : planGroupBy.keySet()) {
            List<Map<String, Object>> mapsByPlan = planGroupBy.get(planId);
            Map<String, List<Map<String, Object>>> dangerByName = mapsByPlan.stream().collect(Collectors.groupingBy(res -> String.valueOf(res.get("danger"))));
            List<HashMap<String, Object>> dangerMapsByPlan = new ArrayList<>();
            for (String danger : dangerByName.keySet()) {
                HashMap<String, Object> dangerByNameMap= new HashMap<>();
                int count = 0;
                List<Map<String, Object>> mapsByDanger = dangerByName.get(danger);
                for (Map<String, Object> stringObjectMap : mapsByDanger) {
                    count += Integer.parseInt(String.valueOf(stringObjectMap.get("count")));
                }
                dangerByNameMap.put(danger,count);
                dangerMapsByPlan.add(dangerByNameMap);
            }
            dangerByPlan.put(planId,dangerMapsByPlan);
        }
        Map<String, Object> resultMap = new HashMap<>();
        resultMap.put("list",maps);
        resultMap.put("dangerTrend",dangerByPlan);
        resultMap.put("dangerCount",dangerMaps);
        resultMap.put("proportion",proportion);
        return resultMap;
    }

    public static List<LocalDateTime> getStartTimeAndEndTime(ScreenRangeRequest screenRangeRequest){
        ArrayList<LocalDateTime> localDateTimes = new ArrayList<>();
        LocalDateTime startTime = null;
        LocalDateTime endTime = null;
        //都为空的时候
        if(StringUtils.isBlank(screenRangeRequest.getStartTime()) && StringUtils.isBlank(screenRangeRequest.getStartTimeStamp()) && StringUtils.isEmpty(screenRangeRequest.getStartTime()) && StringUtils.isEmpty(screenRangeRequest.getStartTimeStamp())){
            startTime =  LocalDateTime.now().with(LocalTime.MIN);
        }
        //都为空的时候
        if(StringUtils.isBlank(screenRangeRequest.getEndTime()) && StringUtils.isBlank(screenRangeRequest.getEndTimeStamp()) && StringUtils.isEmpty(screenRangeRequest.getEndTime()) && StringUtils.isEmpty(screenRangeRequest.getEndTimeStamp())){
            endTime =  startTime.withHour(23).withMinute(59).withSecond(59);
        }
        //就是都传递的时候
        if(StringUtils.isNotBlank(screenRangeRequest.getStartTime()) && StringUtils.isNotBlank(screenRangeRequest.getStartTimeStamp()) && !StringUtils.isEmpty(screenRangeRequest.getStartTime()) && !StringUtils.isEmpty(screenRangeRequest.getStartTimeStamp())){
            try {
                startTime =  LocalDateTime.parse(screenRangeRequest.getStartTime() +" "+screenRangeRequest.getStartTimeStamp(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            }catch (Exception e){
                startTime = LocalDateTime.now().with(LocalTime.MIN);
            }
        }
        //就是都传递的时候
        if(StringUtils.isNotBlank(screenRangeRequest.getEndTime()) && StringUtils.isNotBlank(screenRangeRequest.getEndTimeStamp()) && !StringUtils.isEmpty(screenRangeRequest.getEndTime()) && !StringUtils.isEmpty(screenRangeRequest.getEndTimeStamp())){
            try {
                endTime =  LocalDateTime.parse(screenRangeRequest.getEndTime() +" "+screenRangeRequest.getEndTimeStamp(), DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            }catch (Exception e){
                endTime = startTime.withHour(23).withMinute(59).withSecond(59);
            }
        }
        localDateTimes.add(startTime);
        localDateTimes.add(endTime);
        return localDateTimes;
    }
}