//package com.njcn.csharmonic.service.impl;
//
//import cn.hutool.core.collection.CollUtil;
//import cn.hutool.core.date.DateUtil;
//import cn.hutool.core.util.StrUtil;
//import com.baomidou.dynamic.datasource.annotation.DS;
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
//import com.njcn.csharmonic.mapper.report.*;
//import com.njcn.csharmonic.pojo.dto.report.OverLimitInfo;
//import com.njcn.csharmonic.pojo.param.report.ReportQueryParam;
//import com.njcn.csharmonic.pojo.po.day.RStatDataHarmrateVDPO;
//import com.njcn.csharmonic.pojo.po.day.RStatDataIDPO;
//import com.njcn.csharmonic.pojo.po.day.RStatDataInharmVDPO;
//import com.njcn.csharmonic.pojo.po.day.RStatDataVDPO;
//import com.njcn.csharmonic.pojo.vo.report.ReportValue;
//import com.njcn.csharmonic.service.ReportService;
//import com.njcn.csharmonic.util.RegroupData;
//import lombok.RequiredArgsConstructor;
//import org.springframework.stereotype.Service;
//
//import java.lang.reflect.Field;
//import java.math.BigDecimal;
//import java.util.*;
//import java.util.stream.Collectors;
//
///**
// * @author wr
// */
//@Service
//@RequiredArgsConstructor
//@DS("sjzx")
//public class ReportServiceImpl implements ReportService {
//
//    private final ReportMapper reportMapper;
//    private final RStatDataVDPOMapper rStatDataVDMapper;
//    private final RStatDataHarmRateVDMapper rStatDataHarmRateVDMapper;
//    private final RStatDataIDMapper rStatDataIDMapper;
//    private final RStatDataInharmVDMapper rStatDataInharmVDMapper;
//
//    @Override
//    public OverLimitInfo getOverLimitData(ReportQueryParam param) {
//
//
//        OverLimitInfo overLimitInfo = new OverLimitInfo();
//
//        //查询时间段内共有多少条记录，并*0.95取整处理，用来计算CP95值 降序*0.05进一位计算
//        double count = 0;
//        double pstCount = 0;
//        double pltCount = 0;
//        if (param.getB()) {
//            count = Math.ceil(1);
//            pltCount = Math.ceil(1);
//            pstCount = Math.ceil(1);
//        } else {
//            count = Math.ceil(reportMapper.getTotalCP95Day(param).intValue() * 0.05);
//            pltCount = Math.ceil(reportMapper.getTotalPltCP95Day(param).intValue() * 0.05);
//            pstCount = Math.ceil(reportMapper.getTotalPstCP95Day(param).intValue() * 0.05);
//        }
//        overLimitInfo.setCount(count);
//        overLimitInfo.setPltCount(pltCount);
//        overLimitInfo.setPstCount(pstCount);
//        return overLimitInfo;
//    }
//
//    @Override
//    public List<ReportValue> getVirtualData(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        // 获取电流有效值
//        List<ReportValue> listI = reportMapper.getVirtualDataI(param);
//        //获取电压有效值
//        List<ReportValue> listV = reportMapper.getVirtualDataV(param);
//        //获取线电压有效值
//        List<ReportValue> listVV = reportMapper.getVVirtualData(param);
//
//        RegroupData.regroupData(listV, true);
//        RegroupData.regroupData(listI, true);
//        RegroupData.regroupData(listVV, true);
//        list.addAll(listV);
//        list.addAll(listI);
//        list.addAll(listVV);
//
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getPowerData(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//        //获取有功功率
//        List<ReportValue> listP = reportMapper.getPowerP(param);
//        //获取无功功率
//        List<ReportValue> listQ = reportMapper.getPowerQ(param);
//        //获取视在功率
//        List<ReportValue> listS = reportMapper.getPowerS(param);
//        //获取功率因数
//        List<ReportValue> listF = reportMapper.getPF(param);
//
//        RegroupData.regroupData(listP, true, false);
//        RegroupData.regroupData(listQ, true, false);
//        RegroupData.regroupData(listS, true, false);
//        RegroupData.regroupData(listF, true, false);
//        list.addAll(listP);
//        list.addAll(listQ);
//        list.addAll(listS);
//        list.addAll(listF);
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getFlickerData(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        //短时闪变
//        List<ReportValue> listFlicker = reportMapper.getFlickerData(param);
//        //长时闪变
//        List<ReportValue> listLFlicker = reportMapper.getLFlickerData(param);
//
//        RegroupData.regroupData(listFlicker, true);
//        RegroupData.regroupData(listLFlicker, true);
//        list.addAll(listFlicker);
//        list.addAll(listLFlicker);
//
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getVdeviation(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        //获取电压偏差
//        List<ReportValue> listU = reportMapper.getUVdeviationData(param);
//        List<ReportValue> listL = reportMapper.getLVdeviationData(param);
//
//        RegroupData.regroupData(listU, true);
//        RegroupData.regroupData(listL, true);
//        list.addAll(listU);
//        list.addAll(listL);
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getDistortionData(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//        //获取电压畸变率
//        List<ReportValue> listU = reportMapper.getDistortionDataV(param);
//        //获取电流畸变率
//        List<ReportValue> listI = reportMapper.getDistortionDataI(param);
//
//        //添加之前判断数据库是否有数据，如果没有数据模拟数据添加到集合中
//        RegroupData.regroupData(listU, true);
//        RegroupData.regroupData(listI, true);
//        list.addAll(listU);
//        list.addAll(listI);
//
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getFrequencyData(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        List<ReportValue> listFre = reportMapper.getFrequencyData(param);
//        List<ReportValue> listFreDEV = reportMapper.getDEVFrequencyData(param);
//
//
//        RegroupData.regroupData(listFre, true);
//        RegroupData.regroupData(listFreDEV, true);
//        list.addAll(listFre);
//        list.addAll(listFreDEV);
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getThreephase(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//        //电压三相不平衡度
//        List<ReportValue> listV = dataV(param, Arrays.asList("T"), 1, 5, true, 0);
//        //电流三相不平衡度
//        List<ReportValue> listI = dataI(param, Arrays.asList("T"), 1, 5, true, 0);
//
//        if (CollUtil.isNotEmpty(listV)) {
//            list.addAll(listV);
//        } else {
//            regroupData(list);
//        }
//
//        if (CollUtil.isNotEmpty(listI)) {
//            list.addAll(listI);
//        } else {
//            regroupData(list);
//        }
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getICurrent(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        //获取电流幅值，包含基波
//        List<ReportValue> listI = dataI(param, Arrays.asList("A", "B", "C"), 1, 51, false, 0);
//        if (CollUtil.isEmpty(listI)) {
//            for (int i = 0; i < 50; i++) {
//                RegroupData.regroupData(list, true, true);
//            }
//        } else {
//            list.addAll(listI);
//        }
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getVoltageRate(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//
//        //获取基波电压幅值，单位kV
//        List<ReportValue> listV = dataV(param, Arrays.asList("A", "B", "C"), 0, 1, true, 5);
//
//        if (CollUtil.isEmpty(listV)) {
//            RegroupData.regroupData(list, true, true);
//        } else {
//            list.addAll(listV);
//        }
//
//        //获取电压含有率，不包含基波
////        List<ReportValue> listRate = dataV(param, Arrays.asList("A", "B", "C"), 2, 51, false, 1);
//        List<ReportValue> listRate = dataHarmRateV(param, Arrays.asList("A", "B", "C"), 2, 51, false, 1);
//
//        if (CollUtil.isEmpty(listRate)) {
//            for (int i = 0; i < 49; i++) {
//                RegroupData.regroupData(list, true, true);
//            }
//        } else {
//            list.addAll(listRate);
//        }
//
//        //获取电压畸变率
//        List<ReportValue> listU = reportMapper.getDistortionDataV(param);
//        RegroupData.regroupData(listU, true);
//        list.addAll(listU);
//        return list;
//    }
//
//    @Override
//    public List<ReportValue> getInharmVeRate(ReportQueryParam param) {
//        List<RStatDataInharmVDPO> inharm = rStatDataInharmVDMapper.selectList(new LambdaQueryWrapper<RStatDataInharmVDPO>()
//                .eq(RStatDataInharmVDPO::getLineId, param.getLineId())
//                .in(RStatDataInharmVDPO::getPhaseType, Arrays.asList("A", "B", "C"))
//                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatDataInharmVDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(param.getStartTime())))
//                .le(StrUtil.isNotBlank(param.getEndTime()), RStatDataInharmVDPO::getTime, DateUtil.endOfDay(DateUtil.parse(param.getEndTime())))
//        );
//        String max = "MAX";
//        String avg = "AVG";
//        String min = "MIN";
//        String cp95 = "CP95";
//        List<ReportValue> a = new ArrayList<>();
//        Map<String, List<RStatDataInharmVDPO>> collect = inharm.stream().collect(Collectors.groupingBy(RStatDataInharmVDPO::getPhaseType));
//        collect.forEach((key, value) -> {
//            Map<String, List<RStatDataInharmVDPO>> valueTypeMap = value.stream().collect(Collectors.groupingBy(RStatDataInharmVDPO::getValueType));
//
//            for (int i = 1; i < 17; i++) {
//                ReportValue reportValue = new ReportValue();
//                String attribute = "v" + i;
//
//                if (valueTypeMap.containsKey(max)) {
//                    List<Float> aa = reflectDataInV(valueTypeMap.get(max), max, attribute);
//                    reportValue.setPhaseType(key);
//                    Float maxNum = aa.stream().distinct().max(Float::compareTo).get();
//                    reportValue.setFmaxValue(maxNum);
//                }
//                if (valueTypeMap.containsKey(avg)) {
//                    List<Float> aa = reflectDataInV(valueTypeMap.get(avg), avg, attribute);
//                    reportValue.setPhaseType(key);
//                    Double avgNum = aa.stream().distinct().collect(Collectors.averagingDouble(Float::doubleValue));
//                    reportValue.setMeanValue(avgNum.floatValue());
//                }
//                if (valueTypeMap.containsKey(min)) {
//                    List<Float> aa = reflectDataInV(valueTypeMap.get(min), min, attribute);
//                    reportValue.setPhaseType(key);
//                    double minNum = aa.stream().distinct().min(Float::compareTo).get();
//                    reportValue.setMinValue((float) minNum);
//                }
//                if (valueTypeMap.containsKey(cp95)) {
//                    List<Float> aa = reflectDataInV(valueTypeMap.get(cp95), cp95, attribute);
//                    reportValue.setPhaseType(key);
//                    List<Float> cp95Num = aa.stream().distinct().sorted(Comparator.comparing(Float::doubleValue).reversed()).collect(Collectors.toList());
//                    reportValue.setCp95Value(cp95Num.get(0).floatValue());
//                }
//                a.add(reportValue);
//            }
//        });
//        if (CollUtil.isEmpty(a)) {
//            for (int i = 1; i < 17; i++) {
//                RegroupData.regroupData(a, true, true);
//            }
//        }
//        return a;
//    }
//
//    @Override
//    public List<ReportValue> getINegDataRate(ReportQueryParam param) {
//        List<ReportValue> list = new ArrayList<>();
//        //负序电流
//        List<ReportValue> iNegData = reportMapper.getINegData(param);
//        RegroupData.regroupData(iNegData, true);
//        list.addAll(iNegData);
//        return list;
//    }
//
//    //赋值默认值
//    private void regroupData(List<ReportValue> list) {
//        for (int i = 0; i < 4; i++) {
//            List<ReportValue> list1 = new ArrayList<>();
//            RegroupData.regroupData(list1, false);
//            list.addAll(list1);
//        }
//    }
//
//    /**
//     * 电压信息
//     *
//     * @param param      查询条件
//     * @param valueTypes 区分类别 例如"A","B","C"
//     * @param num        循环开始
//     * @param size       循环结束
//     * @param fly        否是启用获取属性电压
//     * @param index      获取属性位置名称
//     * @return
//     */
//    private List<ReportValue> dataV(ReportQueryParam param, List<String> valueTypes, Integer num, Integer size, Boolean fly, Integer index) {
//        List<RStatDataVDPO> rStatDataVDS = rStatDataVDMapper.selectList(new LambdaQueryWrapper<RStatDataVDPO>()
//                .eq(RStatDataVDPO::getLineId, param.getLineId())
//                .in(CollUtil.isNotEmpty(valueTypes), RStatDataVDPO::getPhaseType, valueTypes)
//                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatDataVDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(param.getStartTime())))
//                .le(StrUtil.isNotBlank(param.getEndTime()), RStatDataVDPO::getTime, DateUtil.endOfDay(DateUtil.parse(param.getEndTime())))
//        );
//        String max = "MAX";
//        String avg = "AVG";
//        String min = "MIN";
//        String cp95 = "CP95";
//        List<ReportValue> a = new ArrayList<>();
//        Map<String, List<RStatDataVDPO>> collect = rStatDataVDS.stream().collect(Collectors.groupingBy(RStatDataVDPO::getPhaseType));
//        collect.forEach((key, value) -> {
//            Map<String, List<RStatDataVDPO>> valueTypeMap = value.stream().collect(Collectors.groupingBy(RStatDataVDPO::getValueType));
//
//            for (int i = num; i < size; i++) {
//                ReportValue reportValue = new ReportValue();
//                String attribute = "";
//                if (fly) {
//                    if (index == 0) {
//                        attribute = attributeV(i);
//                    } else {
//                        attribute = attributeV(index);
//                    }
//                } else {
//                    attribute = "v" + i;
//                }
//
//                if (valueTypeMap.containsKey(max)) {
//                    List<Float> aa = reflectDataV(valueTypeMap.get(max), max, attribute);
//                    reportValue.setPhaseType(key);
//                    Float maxNum = aa.stream().distinct().max(Float::compareTo).get();
//                    reportValue.setFmaxValue(maxNum);
//                }
//                if (valueTypeMap.containsKey(avg)) {
//                    List<Float> aa = reflectDataV(valueTypeMap.get(avg), avg, attribute);
//                    reportValue.setPhaseType(key);
//                    Double avgNum = aa.stream().distinct().collect(Collectors.averagingDouble(Float::doubleValue));
//                    reportValue.setMeanValue(avgNum.floatValue());
//                }
//                if (valueTypeMap.containsKey(min)) {
//                    List<Float> aa = reflectDataV(valueTypeMap.get(min), min, attribute);
//                    reportValue.setPhaseType(key);
//                    double minNum = aa.stream().distinct().min(Float::compareTo).get();
//                    reportValue.setMinValue((float) minNum);
//                }
//                if (valueTypeMap.containsKey(cp95)) {
//                    List<Float> aa = reflectDataV(valueTypeMap.get(cp95), cp95, attribute);
//                    reportValue.setPhaseType(key);
//                    List<Float> cp95Num = aa.stream().distinct().sorted(Comparator.comparing(Float::doubleValue).reversed()).collect(Collectors.toList());
//                    reportValue.setCp95Value(cp95Num.get(0).floatValue());
//                }
//                a.add(reportValue);
//            }
//        });
//        return a;
//    }
//
//    //获取电压含有率应该取dataHarmRateV，不是dataV
//    private List<ReportValue> dataHarmRateV(ReportQueryParam param, List<String> valueTypes, Integer num, Integer size, Boolean fly, Integer index) {
//        List<RStatDataHarmrateVDPO> rStatDataVDS = rStatDataHarmRateVDMapper.selectList(new LambdaQueryWrapper<RStatDataHarmrateVDPO>()
//                .eq(RStatDataHarmrateVDPO::getLineId, param.getLineId())
//                .in(CollUtil.isNotEmpty(valueTypes), RStatDataHarmrateVDPO::getPhaseType, valueTypes)
//                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatDataHarmrateVDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(param.getStartTime())))
//                .le(StrUtil.isNotBlank(param.getEndTime()), RStatDataHarmrateVDPO::getTime, DateUtil.endOfDay(DateUtil.parse(param.getEndTime())))
//        );
//        String max = "MAX";
//        String avg = "AVG";
//        String min = "MIN";
//        String cp95 = "CP95";
//        List<ReportValue> a = new ArrayList<>();
//        Map<String, List<RStatDataHarmrateVDPO>> collect = rStatDataVDS.stream().collect(Collectors.groupingBy(RStatDataHarmrateVDPO::getPhaseType));
//        collect.forEach((key, value) -> {
//            Map<String, List<RStatDataHarmrateVDPO>> valueTypeMap = value.stream().collect(Collectors.groupingBy(RStatDataHarmrateVDPO::getValueType));
//
//            for (int i = num; i < size; i++) {
//                ReportValue reportValue = new ReportValue();
//                String attribute = "";
//                if (fly) {
//                    if (index == 0) {
//                        attribute = attributeV(i);
//                    } else {
//                        attribute = attributeV(index);
//                    }
//                } else {
//                    attribute = "v" + i;
//                }
//
//                if (valueTypeMap.containsKey(max)) {
//                    List<Float> aa = reflectDataHarmRateV(valueTypeMap.get(max), max, attribute);
//                    reportValue.setPhaseType(key);
//                    Float maxNum = aa.stream().distinct().max(Float::compareTo).get();
//                    reportValue.setFmaxValue(maxNum);
//                }
//                if (valueTypeMap.containsKey(avg)) {
//                    List<Float> aa = reflectDataHarmRateV(valueTypeMap.get(avg), avg, attribute);
//                    reportValue.setPhaseType(key);
//                    Double avgNum = aa.stream().distinct().collect(Collectors.averagingDouble(Float::doubleValue));
//                    reportValue.setMeanValue(avgNum.floatValue());
//                }
//                if (valueTypeMap.containsKey(min)) {
//                    List<Float> aa = reflectDataHarmRateV(valueTypeMap.get(min), min, attribute);
//                    reportValue.setPhaseType(key);
//                    double minNum = aa.stream().distinct().min(Float::compareTo).get();
//                    reportValue.setMinValue((float) minNum);
//                }
//                if (valueTypeMap.containsKey(cp95)) {
//                    List<Float> aa = reflectDataHarmRateV(valueTypeMap.get(cp95), cp95, attribute);
//                    reportValue.setPhaseType(key);
//                    List<Float> cp95Num = aa.stream().distinct().sorted(Comparator.comparing(Float::doubleValue).reversed()).collect(Collectors.toList());
//                    reportValue.setCp95Value(cp95Num.get(0).floatValue());
//                }
//                a.add(reportValue);
//            }
//        });
//        return a;
//    }
//
//    /**
//     * 电压反射取属性值
//     *
//     * @param value
//     * @param name
//     * @return
//     */
//    private List<Float> reflectDataV(List<RStatDataVDPO> value, String name, String attribute) {
//        Field field = null;
//        try {
//            field = RStatDataVDPO.class.getDeclaredField(attribute);
//        } catch (NoSuchFieldException e) {
//            throw new RuntimeException(e);
//        }
//        field.setAccessible(true);
//
//        Field finalField = field;
//        return value.stream().filter(x -> x.getValueType().equals(name)).map(temp -> {
//            BigDecimal o = null;
//            try {
//                o =  BigDecimal.valueOf((Double) finalField.get(temp));
//            } catch (IllegalAccessException e) {
//                throw new RuntimeException(e);
//            }
//
//            return o.floatValue();
//        }).collect(Collectors.toList());
//    }
//
//    private List<Float> reflectDataHarmRateV(List<RStatDataHarmrateVDPO> value, String name, String attribute) {
//        Field field = null;
//        try {
//            field = RStatDataHarmrateVDPO.class.getDeclaredField(attribute);
//        } catch (NoSuchFieldException e) {
//            throw new RuntimeException(e);
//        }
//        field.setAccessible(true);
//
//        Field finalField = field;
//        return value.stream().filter(x -> x.getValueType().equals(name)).map(temp -> {
//            BigDecimal o = null;
//            try {
//                o =  BigDecimal.valueOf((Double) finalField.get(temp));
//            } catch (IllegalAccessException e) {
//                throw new RuntimeException(e);
//            }
//
//            return o.floatValue();
//        }).collect(Collectors.toList());
//    }
//
//    /**
//     * 电压反射取属性值
//     *
//     * @param value
//     * @param name
//     * @return
//     */
//    private List<Float> reflectDataInV(List<RStatDataInharmVDPO> value, String name, String attribute) {
//        Field field;
//        try {
//            field = RStatDataInharmVDPO.class.getDeclaredField(attribute);
//        } catch (NoSuchFieldException e) {
//            throw new RuntimeException(e);
//        }
//        field.setAccessible(true);
//
//        Field finalField = field;
//        return value.stream().filter(x -> x.getValueType().equals(name)).map(temp -> {
//            Double o;
//            try {
//                o = (Double) finalField.get(temp);
//            } catch (IllegalAccessException e) {
//                throw new RuntimeException(e);
//            }
//
//            return o.floatValue();
//        }).collect(Collectors.toList());
//    }
//
//    /**
//     * 电流信息
//     *
//     * @param param
//     * @return
//     */
//    private List<ReportValue> dataI(ReportQueryParam param, List<String> valueTypes, Integer num, Integer size, Boolean fly, Integer index) {
//        List<RStatDataIDPO> rStatDataVDS = rStatDataIDMapper.selectList(new LambdaQueryWrapper<RStatDataIDPO>()
//                .eq(RStatDataIDPO::getLineId, param.getLineId())
//                .in(CollUtil.isNotEmpty(valueTypes), RStatDataIDPO::getPhaseType, valueTypes)
//                .ge(StrUtil.isNotBlank(param.getStartTime()), RStatDataIDPO::getTime, DateUtil.beginOfDay(DateUtil.parse(param.getStartTime())))
//                .le(StrUtil.isNotBlank(param.getEndTime()), RStatDataIDPO::getTime, DateUtil.endOfDay(DateUtil.parse(param.getEndTime())))
//        );
//        String max = "MAX";
//        String avg = "AVG";
//        String min = "MIN";
//        String cp95 = "CP95";
//        List<ReportValue> a = new ArrayList<>();
//        Map<String, List<RStatDataIDPO>> collect = rStatDataVDS.stream().collect(Collectors.groupingBy(RStatDataIDPO::getPhaseType));
//        collect.forEach((key, value) -> {
//            Map<String, List<RStatDataIDPO>> valueTypeMap = value.stream().collect(Collectors.groupingBy(RStatDataIDPO::getValueType));
//
//            for (int i = num; i < size; i++) {
//                ReportValue reportValue = new ReportValue();
//                String attribute = "";
//                if (fly) {
//                    if (index == 0) {
//                        attribute = attributeI(i);
//                    } else {
//                        attribute = attributeI(index);
//                    }
//                } else {
//                    attribute = "i" + i;
//                }
//                if (valueTypeMap.containsKey(max)) {
//                    List<Float> aa = reflectDataI(valueTypeMap.get(max), max, attribute);
//                    reportValue.setPhaseType(key);
//                    Float maxNum = aa.stream().distinct().max(Float::compareTo).get();
//                    reportValue.setFmaxValue(maxNum);
//                }
//                if (valueTypeMap.containsKey(avg)) {
//                    List<Float> aa = reflectDataI(valueTypeMap.get(avg), avg, attribute);
//                    reportValue.setPhaseType(key);
//                    Double avgNum = aa.stream().distinct().collect(Collectors.averagingDouble(Float::doubleValue));
//                    reportValue.setMeanValue(avgNum.floatValue());
//                }
//                if (valueTypeMap.containsKey(min)) {
//                    List<Float> aa = reflectDataI(valueTypeMap.get(min), min, attribute);
//                    reportValue.setPhaseType(key);
//                    double minNum = aa.stream().distinct().min(Float::compareTo).get();
//                    reportValue.setMinValue((float) minNum);
//                }
//                if (valueTypeMap.containsKey(cp95)) {
//                    List<Float> aa = reflectDataI(valueTypeMap.get(cp95), cp95, attribute);
//                    reportValue.setPhaseType(key);
//                    List<Float> cp95Num = aa.stream().distinct().sorted(Comparator.comparing(Float::doubleValue).reversed()).collect(Collectors.toList());
//                    reportValue.setCp95Value(cp95Num.get(0).floatValue());
//                }
//                a.add(reportValue);
//            }
//        });
//        return a;
//    }
//
//    /**
//     * 电流反射取属性值
//     *
//     * @param value
//     * @param name
//     * @return
//     */
//    private List<Float> reflectDataI(List<RStatDataIDPO> value, String name, String attribute) {
//        Field field = null;
//        try {
//            field = RStatDataIDPO.class.getDeclaredField(attribute);
//        } catch (NoSuchFieldException e) {
//            throw new RuntimeException(e);
//        }
//        field.setAccessible(true);
//        Field finalField = field;
//        return value.stream().filter(x -> x.getValueType().equals(name)).map(temp -> {
//            Double o = null;
//            try {
//                o = (Double) finalField.get(temp);
//            } catch (IllegalAccessException e) {
//                throw new RuntimeException(e);
//            }
//
//            return o.floatValue();
//        }).collect(Collectors.toList());
//    }
//
//    /**
//     * 获取属性电压
//     *
//     * @param i
//     * @return
//     */
//    private String attributeV(Integer i) {
//        String str = null;
//        switch (i) {
//            case 1:
//                str = "vUnbalance";
//                break;
//            case 2:
//                str = "vPos";
//                break;
//            case 3:
//                str = "vNeg";
//                break;
//            case 4:
//                str = "vZero";
//                break;
//            case 5:
//                str = "v1";
//                break;
//            default:
//                break;
//        }
//        return str;
//    }
//
//    /**
//     * 获取属性电流
//     *
//     * @param i
//     * @return
//     */
//    private String attributeI(Integer i) {
//        String str = null;
//        switch (i) {
//            case 1:
//                str = "iUnbalance";
//                break;
//            case 2:
//                str = "iPos";
//                break;
//            case 3:
//                str = "iNeg";
//                break;
//            case 4:
//                str = "iZero";
//                break;
//            default:
//                break;
//        }
//        return str;
//    }
//}
