//package com.njcn.csharmonic.offline.mincfg.vo;
//
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
//import com.njcn.csharmonic.offline.log.vo.TagComtradeCfg;
//import com.njcn.csharmonic.offline.mincfg.*;
//import com.njcn.influx.pojo.po.cs.PqdData;
//
//import java.io.*;
//import java.nio.charset.StandardCharsets;
//import java.text.ParseException;
//import java.text.SimpleDateFormat;
//import java.util.*;
//
///**
// * Description:
// * Date: 2024/7/15  15:42【需求编号】
// *
// * @author clam
// * @version V1.0.0
// */
//public class AnalyseComtradeCfg1 {
//
//    private static Date minStarttime = new Date(0);
//    private static Date minEndtime = new Date(0); //分钟数据的时间范围
//
//    private static Date minHh_starttime =  new Date(0);
//    private static Date minHh_endtime = new Date(0);
//
//    //解析分钟数据和分钟数据下的高频谐波
//    public static void processDirectory(String minPath) throws IOException {
//        HashMap<Date, MinDataHh> minDataHhHashMap = new HashMap<>();
//        HashMap<Date, MinData> minDataHashMap = new HashMap<>();
//        File minDir = new File(minPath);
//        if (minDir.exists() && minDir.isDirectory() && minDir.listFiles().length != 0) { // 分钟数据文件夹存在且不为空
//            File[] dirs = minDir.listFiles(File::isDirectory); // 获取所有子目录
//            for (File dir : dirs) {
//                // 获取文件夹下所有.bin文件
//                File[] files = dir.listFiles((dir1, name) -> name.endsWith(".bin"));
//
//                if (files != null) { // 确保files不为null
//                    for (File file : files) {
//                        if (file.getName().toUpperCase().indexOf("HH") >= 0) { // 读取分钟秒下的高频谐波数据
//                            convertMinHh(file.getAbsolutePath(),minDataHhHashMap);
//                        } else { // 读取分钟数据
//                             convertMin(file.getAbsolutePath(),minDataHashMap);
//                        }
//                    }
//                }
//            }
//        }
//
//        System.out.println(minDataHhHashMap);
//        System.out.println(minDataHashMap);
//        convertMinData(minDataHashMap);
//
//
//    }
//
//    private static List<PqdData> convertMinData(HashMap<Date, MinData> minDataHashMap) {
//        List<PqdData> result = new ArrayList<>();
//        minDataHashMap.forEach((dateTime,data)->{
//
//            List<PqdData> pqdDataA = convertDataByValueType(data.getMin(), "min",dateTime);
//            List<PqdData> pqdDataB = convertDataByValueType(data.getMax(), "max",dateTime);
//            List<PqdData> pqdDataC = convertDataByValueType(data.getAvg(), "avg",dateTime);
//            List<PqdData> pqdDataT = convertDataByValueType(data.getCp95(), "cp95",dateTime);
//            result.addAll(pqdDataA);
//            result.addAll(pqdDataB);
//            result.addAll(pqdDataC);
//            result.addAll(pqdDataT);
//        });
//
//        return result;
//
//    }
//
//    private static List<PqdData> convertDataByValueType(tagPQDataCmn min, String valueType,Date dateTime) {
//
//        List<PqdData> pqdData = new ArrayList<>();
//
//        HashMap hashMapA = new HashMap<>();
//        hashMapA.put("phaseType","A");
//        hashMapA.put("valueType",valueType);
//        hashMapA.put("time",dateTime.toInstant());
//
//        HashMap hashMapB = new HashMap<>();
//        hashMapB.put("phaseType","B");
//        hashMapB.put("valueType",valueType);
//        hashMapB.put("time",dateTime.toInstant());
//
//        HashMap hashMapC = new HashMap<>();
//        hashMapC.put("phaseType","C");
//        hashMapC.put("valueType",valueType);
//        hashMapC.put("time",dateTime.toInstant());
//
//        HashMap hashMapM = new HashMap<>();
//        hashMapM.put("phaseType","M");
//        hashMapM.put("valueType",valueType);
//        hashMapM.put("time",dateTime.toInstant());
//
//
//        HashMap hashMapAB = new HashMap<>();
//        hashMapAB.put("phaseType","AB");
//        hashMapAB.put("valueType",valueType);
//        hashMapAB.put("time",dateTime.toInstant());
//
//        HashMap hashMapBC = new HashMap<>();
//        hashMapBC.put("phaseType","BC");
//        hashMapBC.put("valueType",valueType);
//        hashMapBC.put("time",dateTime.toInstant());
//
//        HashMap hashMapCA = new HashMap<>();
//        hashMapCA.put("phaseType","CA");
//        hashMapCA.put("valueType",valueType);
//        hashMapCA.put("time",dateTime.toInstant());
//
//
//        //RMS电压A B C  电流A B C  线电压AB BC CA
//        Float[] rms = min.getRms();
//        hashMapA.put("pq_RmsU",rms[0]);
//        hashMapB.put("pq_RmsU",rms[1]);
//        hashMapC.put("pq_RmsU",rms[2]);
//        hashMapA.put("pq_RmsU",rms[3]);
//        hashMapB.put("pq_RmsI",rms[4]);
//        hashMapC.put("pq_RmsI",rms[5]);
//        hashMapA.put("pq_RmsLU",rms[6]);
//        hashMapB.put("pq_RmsLU",rms[7]);
//        hashMapC.put("pq_RmsLU",rms[8]);
//
//
////        pqdDataA.setpq_RmsU(rms[0]);
////        pqdDataB.setpq_RmsU(rms[1]);
////        pqdDataC.setpq_RmsU(rms[2]);
////        pqdDataA.setpq_RmsI(rms[3]);
////        pqdDataB.setpq_RmsI(rms[4]);
////        pqdDataC.setpq_RmsI(rms[5]);
////        pqdDataA.setpq_RmsLU(rms[6]);
////        pqdDataB.setpq_RmsLU(rms[7]);
////        pqdDataC.setpq_RmsLU(rms[8]);
//        //电压上偏差相电压abc，线电压AB BC CA
//        Float[] uuDeviation = min.getUU_Deviation();
//        Float[] ulDeviation = min.getUL_Deviation();
//        //电能质量只有电压偏差,上偏差正，下偏差负，判断上偏差是否为0如果为0取下偏差负数，反正取上偏差
//        hashMapA.put("pq_UDev", AnalyseComtradeCfg.isZero(uuDeviation[0])?(-ulDeviation[0]):uuDeviation[0]);
//        hashMapB.put("pq_UDev",AnalyseComtradeCfg.isZero(uuDeviation[1])?(-ulDeviation[1]):uuDeviation[1]);
//        hashMapC.put("pq_RmsU",AnalyseComtradeCfg.isZero(uuDeviation[2])?(-ulDeviation[2]):uuDeviation[2]);
//        hashMapAB.put("pq_LUDev",AnalyseComtradeCfg.isZero(uuDeviation[3])?(-ulDeviation[3]):uuDeviation[3]);
//        hashMapBC.put("pq_LUDev",AnalyseComtradeCfg.isZero(uuDeviation[4])?(-ulDeviation[4]):uuDeviation[4]);
//        hashMapCA.put("pq_LUDev",AnalyseComtradeCfg.isZero(uuDeviation[5])?(-ulDeviation[5]):uuDeviation[5]);
//
////        pqdDataA.setpq_RmsU(AnalyseComtradeCfg.isZero(uuDeviation[0])?(-ulDeviation[0]):uuDeviation[0]);
////        pqdDataB.setpq_RmsU(AnalyseComtradeCfg.isZero(uuDeviation[1])?(-ulDeviation[1]):uuDeviation[1]);
////        pqdDataC.setpq_RmsU(AnalyseComtradeCfg.isZero(uuDeviation[2])?(-ulDeviation[2]):uuDeviation[2]);
////        pqdDataA.setpq_RmsI(AnalyseComtradeCfg.isZero(uuDeviation[3])?(-ulDeviation[3]):uuDeviation[3]);
////        pqdDataB.setpq_RmsI(AnalyseComtradeCfg.isZero(uuDeviation[4])?(-ulDeviation[4]):uuDeviation[4]);
////        pqdDataC.setpq_RmsI(AnalyseComtradeCfg.isZero(uuDeviation[5])?(-ulDeviation[5]):uuDeviation[5]);
//        ///频率偏差 ,频率存M相
//        Float[] fDeviation = min.getF_Deviation();
//
//        hashMapM.put("pq_FreqDev",fDeviation[0]);
//        hashMapM.put("pq_Freq",fDeviation[1]);
//
///*        pqdDataT.setpq_FreqDev(fDeviation[0]);
//        pqdDataT.setpq_Freq(fDeviation[1]);*/
//
//        //电压电流零、正、负序、不平衡度32 第一个[]电压，电流；第二个[]零、正、负序、不平衡度
//        Float[][] uiSeq = min.getUI_Seq();
//
//        hashMapM.put("pq_SeqZeroU",uiSeq[0][0]);
//        hashMapM.put("pq_SeqNegU",uiSeq[0][1]);
//        hashMapM.put("pq_SeqPosU",uiSeq[0][2]);
//        hashMapM.put("pq_UnbalNegU",uiSeq[0][3]);
//
//        hashMapM.put("pq_SeqZeroI",uiSeq[1][0]);
//        hashMapM.put("pq_SeqNegI",uiSeq[1][1]);
//        hashMapM.put("pq_SeqPosI",uiSeq[1][2]);
//        hashMapM.put("pq_UnbalNegI",uiSeq[1][3]);
//
////        pqdDataT.setpq_SeqZeroU(uiSeq[0][0]);
////        pqdDataT.setpq_SeqNegU(uiSeq[0][1]);
////        pqdDataT.setpq_SeqPosU(uiSeq[0][2]);
////        pqdDataT.setpq_UnbalNegU(uiSeq[0][3]);
//
////        pqdDataT.setpq_SeqZeroI(uiSeq[1][0]);
////        pqdDataT.setpq_SeqNegI(uiSeq[1][1]);
////        pqdDataT.setpq_SeqPosI(uiSeq[1][2]);
////        pqdDataT.setpq_UnbalNegI(uiSeq[1][3]);
//        //电压存含有率，电流存幅值
//        //整次谐波 电压A B C N 电流A B C N 1200
//        //幅值
//        Float[][] fuHarm = min.getFuHarm();
//        //谐波相角-送一半数据 600
//        Float[][] fuHarmPhase = min.getFuHarmPhase();
//
//
//
//        //含有率
//        Float[][] harmContain = min.getHarm_Contain();
//        //谐波功率
//        Float[][][] harmPower = min.getHarm_Power();
//        for (int i = 0; i < 49; i++) {
//            //电压含有率
//            hashMapA.put("pq_HarmU_"+(i+2),harmContain[0][i]);
//            hashMapB.put("pq_HarmU_"+(i+2),harmContain[1][i]);
//            hashMapC.put("pq_HarmU_"+(i+2),harmContain[2][i]);
//
//            //谐波相角
//            hashMapA.put("pq_HarmUAng_"+(i+2),fuHarmPhase[0][i]);
//            hashMapB.put("pq_HarmUAng_"+(i+2),fuHarmPhase[1][i]);
//            hashMapC.put("pq_HarmUAng_"+(i+2),fuHarmPhase[2][i]);
//
//            hashMapA.put("pq_HarmIAng_"+(i+2),fuHarmPhase[3][i]);
//            hashMapB.put("pq_HarmIAng_"+(i+2),fuHarmPhase[4][i]);
//            hashMapC.put("pq_HarmIAng_"+(i+2),fuHarmPhase[5][i]);
//
//            //电流幅值
//            hashMapA.put("pq_HarmI_"+(i+2),fuHarm[3][i]);
//            hashMapB.put("pq_HarmI_"+(i+2),fuHarm[4][i]);
//            hashMapC.put("pq_HarmI_"+(i+2),fuHarm[5][i]);
//
//
//            //谐波功率
//            hashMapA.put("pq_HarmP_"+(i+2),harmPower[0][i][0]);
//            hashMapA.put("pq_HarmQ_"+(i+2),harmPower[0][i][1]);
//            hashMapA.put("pq_HarmS_"+(i+2),harmPower[0][i][2]);
//
//            hashMapB.put("pq_HarmP_"+(i+2),harmPower[1][i][0]);
//            hashMapB.put("pq_HarmQ_"+(i+2),harmPower[1][i][1]);
//            hashMapB.put("pq_HarmS_"+(i+2),harmPower[1][i][2]);
//
//            hashMapC.put("pq_HarmP_"+(i+2),harmPower[2][i][0]);
//            hashMapC.put("pq_HarmQ_"+(i+2),harmPower[2][i][1]);
//            hashMapC.put("pq_HarmS_"+(i+2),harmPower[2][i][2]);
//            //M相目前没有
////            hashMapT.put("pq_HarmP_"+(i+2),harmPower[3][i][0]);
////            hashMapT.put("pq_HarmQ_"+(i+2),harmPower[3][i][1]);
////            hashMapT.put("pq_HarmS_"+(i+2),harmPower[3][i][2]);
//        }
//        //间谐波-送一半数据
//        Float[][] inHarm = min.getInHarm();
//
//
//        for (int i = 0; i < 50; i++) {
//            //间谐波幅值
//            hashMapA.put("pq_InHarmIAmp_"+(i+1),inHarm[3][i]);
//            hashMapB.put("pq_InHarmIAmp_"+(i+1),inHarm[4][i]);
//            hashMapC.put("pq_InHarmIAmp_"+(i+1),inHarm[5][i]);
//
//
//
//        }
//        //a,b,c,total 总功率(P.Q.S)
//        Float[][] totalPower = min.getTotal_Power();
//        hashMapA.put("pq_P",totalPower[0][0]);
//        hashMapB.put("pq_P",totalPower[1][0]);
//        hashMapC.put("pq_P",totalPower[2][0]);
//
//        hashMapA.put("pq_Q",totalPower[0][1]);
//        hashMapB.put("pq_Q",totalPower[1][1]);
//        hashMapC.put("pq_Q",totalPower[2][1]);
//
//        hashMapA.put("pq_S",totalPower[0][2]);
//        hashMapB.put("pq_S",totalPower[1][2]);
//        hashMapC.put("pq_S",totalPower[2][2]);
//
//        hashMapM.put("pq_TotHarmP",totalPower[3][0]);
//        hashMapM.put("pq_TotHarmQ",totalPower[3][1]);
//        hashMapM.put("pq_TotHarmS",totalPower[3][2]);
//
//        /*todo 谐波畸变率,电压波动,电压闪变，电压长闪变会根据监测点接线方式是星型存A,B,C相，角型或者V型存AB，BC,CA相，目前全存在A，B,C相*/
//        //谐波畸变率
//        Float[] harmAberrance = min.getHarm_Aberrance();
//        hashMapA.put("pq_ThdU",harmAberrance[0]);
//        hashMapB.put("pq_ThdU",harmAberrance[1]);
//        hashMapC.put("pq_ThdU",harmAberrance[2]);
//
//        hashMapA.put("pq_ThdI",harmAberrance[3]);
//        hashMapB.put("pq_ThdI",harmAberrance[4]);
//        hashMapC.put("pq_ThdI",harmAberrance[5]);
//
//        //视在功率因数
//        Float[] cosPf = min.getCos_PF();
//        hashMapA.put("pq_PF",cosPf[0]);
//        hashMapB.put("pq_PF",cosPf[1]);
//        hashMapC.put("pq_PF",cosPf[2]);
//        hashMapM.put("pq_TotPF",cosPf[3]);
//        //位移功率因数=
//        Float[] cosDf = min.getCos_DF();
//        hashMapA.put("pq_DF",cosDf[0]);
//        hashMapB.put("pq_DF",cosDf[1]);
//        hashMapC.put("pq_DF",cosDf[2]);
//        hashMapM.put("pq_TotDF",cosDf[3]);
//        //电压波动
//        Float[] uFluctuation = min.getU_Fluctuation();
//        hashMapA.put("pq_Fluct",uFluctuation[0]);
//        hashMapB.put("pq_Fluct",uFluctuation[1]);
//        hashMapC.put("pq_Fluct",uFluctuation[2]);
//        //电压闪变
//        Float[] uFlicker = min.getU_Flicker();
//        hashMapA.put("pq_Plt",uFlicker[0]);
//        hashMapB.put("pq_Plt",uFlicker[1]);
//        hashMapC.put("pq_Plt",uFlicker[2]);
//        //电压长闪变
//        Float[] ulFlicker = min.getUL_Flicker();
//        hashMapA.put("pq_Plt",ulFlicker[0]);
//        hashMapB.put("pq_Plt",ulFlicker[1]);
//        hashMapC.put("pq_Plt",ulFlicker[2]);
//
//        ObjectMapper mapper = new ObjectMapper();
//        mapper.registerModule(new JavaTimeModule());
//        PqdData pqdDataA = mapper.convertValue(hashMapA, PqdData.class);
//        PqdData pqdDataB = mapper.convertValue(hashMapB, PqdData.class);
//        PqdData pqdDataC = mapper.convertValue(hashMapC, PqdData.class);
//        PqdData pqdDataM = mapper.convertValue(hashMapM, PqdData.class);
//        PqdData pqdDataAB = mapper.convertValue(hashMapAB, PqdData.class);
//        PqdData pqdDataBC = mapper.convertValue(hashMapBC, PqdData.class);
//        PqdData pqdDataCA = mapper.convertValue(hashMapCA, PqdData.class);
//
//
//
//        pqdData.add(pqdDataA);
//        pqdData.add(pqdDataB);
//        pqdData.add(pqdDataC);
//        pqdData.add(pqdDataM);
//        pqdData.add(pqdDataAB);
//        pqdData.add(pqdDataBC);
//        pqdData.add(pqdDataCA);
//
//        return pqdData;
//
//
//    }
//
//    public static boolean isZero(float value) {
//        return Math.abs(value) < 1e-6; // 判断value是否在精度范围内近似等于0
//    }
//
//    // 实现转换高频谐波数据的逻辑
//    private static HashMap<Date, MinDataHh> convertMinHh(String strFile,HashMap<Date, MinDataHh> minDataHhDic) throws IOException {
//
//
//        // 实现转换高频谐波数据的逻辑
//        System.out.println("Converting HH data from: " + strFile);
//        FileInputStream binFile = null;
//        try{
//            try {
//                binFile = new FileInputStream(strFile);
//            } catch (FileNotFoundException e) {
//                binFile.close();
//                System.out.println(String.format("文件%1$s 长度为0字节，程序将跳过本文件的转换", strFile));
//            }
//
//            long nBufSize = binFile.available(); //计算需要解析的文件总长
//            int n1BufLen = tagPQDataCmnHh.GetSize(); //计算单个统计结构大小
//            int nSecNum = (int)(nBufSize / n1BufLen); //确认共多少事件数据结构
//
//            int nStep = 0; //读取偏移量
//            for (int i = 0; i < nSecNum; i++) {
//                byte[] bBuf = new byte[n1BufLen]; //单个统计结构
//                int nReadLen = 0;
//                try {
//                    //java流不需要跳
////                    binFile.skip(nStep);
//                    nReadLen = binFile.read(bBuf, 0, bBuf.length);
//                } catch (IOException e) {
//                    System.out.println(String.format("文件%1$s 读取时发生错误，代码为%2$s", strFile, e.getClass().getName()));
//                    binFile.close();
//                }
//
//                tagPQDataCmnHh tagPqData = new tagPQDataCmnHh();
//                tagPqData.SetStructBuf(bBuf, 0);
//                nStep += n1BufLen;
//
//                RTC_Timer_MS Devtime = tagPqData.time;
//                Date time = new Date(Devtime.year - 1900, Devtime.month - 1, Devtime.day, Devtime.hour, Devtime.minute, Devtime.second);
//                if (!minHh_starttime.equals(new Date(0))) { //存在启动时间
//                    if (time.compareTo(minHh_starttime) <= 0) {
//                        minHh_starttime = time;
//                    }
//                } else { //不存在启动时间 填入当前时间
//                    minHh_starttime = time;
//                }
//                if (!minHh_endtime.equals(new Date(0))) {
//                    if (time.compareTo(minHh_endtime) >= 0) {
//                        minHh_endtime = time;
//                    }
//                } else { //不存在结束时间 填入当前时间
//                    minHh_endtime = time;
//                }
//
//                if (strFile.toUpperCase().indexOf("AVG") >= 0) {
//                    if (minDataHhDic.containsKey(time)) {
//                        minDataHhDic.get(time).avg = tagPqData;
//                    } else {
//                        MinDataHh minData = new MinDataHh();
//                        minData.avg = tagPqData;
//                        minDataHhDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("CP95") >= 0) {
//                    if (minDataHhDic.containsKey(time)) {
//                        minDataHhDic.get(time).cp95 = tagPqData;
//                    } else {
//                        MinDataHh minData = new MinDataHh();
//                        minData.cp95 = tagPqData;
//                        minDataHhDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("MAX") >= 0) {
//                    if (minDataHhDic.containsKey(time)) {
//                        minDataHhDic.get(time).max = tagPqData;
//                    } else {
//                        MinDataHh minData = new MinDataHh();
//                        minData.max = tagPqData;
//                        minDataHhDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("MIN") >= 0) {
//                    if (minDataHhDic.containsKey(time)) {
//                        minDataHhDic.get(time).min = tagPqData;
//                    } else {
//                        MinDataHh minData = new MinDataHh();
//                        minData.min = tagPqData;
//                        minDataHhDic.put(time, minData);
//                    }
//                }
//            }
//        } catch (FileNotFoundException e) {
//            binFile.close();
//            System.out.println(String.format("文件%1$s 长度为0字节，程序将跳过本文件的转换", strFile));
//        }
//
//        return minDataHhDic;
//    }
//    // 实现转换分钟数据的逻辑
//    private static void convertMin(String strFile, HashMap<Date, MinData> minDataDic) {
//
//        FileInputStream binFile = null;
//
//        try {
//
//            // 实现转换分钟数据的逻辑
//            System.out.println("Converting minute data from: " + strFile);
//
//            binFile = new FileInputStream(strFile);
//
//
//            long nBufSize = 0;
//
//            nBufSize = binFile.available(); //计算需要解析的文件总长
//
//
//            int n1BufLen = tagPQDataCmn.GetSize(); //计算单个统计结构大小
//            int nMinNum = (int) (nBufSize / n1BufLen); //确认共多少分钟数据结构
//
//            int nStep = 0; //读取偏移量
//            for (int i = 0; i < nMinNum; i++) {
//                byte[] bBuf = new byte[n1BufLen]; //单个统计结构
//                int nReadLen = 0;
//                try {
//                    //java流不需要跳
////                    binFile.skip(nStep);
//                    nReadLen = binFile.read(bBuf, 0, bBuf.length);
//                } catch (IOException e) {
//                    System.out.println("文件读取时发生错误，代码为" + e.getClass().getName());
//                    binFile.close();
//                }
//
//                tagPQDataCmn tagPqData = new tagPQDataCmn();
//                tagPqData.SetStructBuf(bBuf, 0);
//                nStep += n1BufLen;
//
//                RTC_Timer_MS Devtime = tagPqData.time;
//                Date time = new Date(Devtime.year - 1900, Devtime.month - 1, Devtime.day, Devtime.hour, Devtime.minute, Devtime.second);
//                if (!minStarttime.equals(new Date(0))) { //存在启动时间
//                    if (time.compareTo(minStarttime) <= 0) {
//                        minStarttime = time;
//                    }
//                } else { //不存在启动时间 填入当前时间
//                    minStarttime = time;
//                }
//                if (!minEndtime.equals(new Date(0))) {
//                    if (time.compareTo(minEndtime) >= 0) {
//                        minEndtime = time;
//                    }
//                } else { //不存在结束时间 填入当前时间
//                    minEndtime = time;
//                }
//
//                if (strFile.toUpperCase().indexOf("AVG") >= 0) {
//                    if (minDataDic.containsKey(time)) {
//                        minDataDic.get(time).avg = tagPqData;
//                    } else {
//                        MinData minData = new MinData();
//                        minData.avg = tagPqData;
//                        minDataDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("CP95") >= 0) {
//                    if (minDataDic.containsKey(time)) {
//                        minDataDic.get(time).cp95 = tagPqData;
//                    } else {
//                        MinData minData = new MinData();
//                        minData.cp95 = tagPqData;
//                        minDataDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("MAX") >= 0) {
//                    if (minDataDic.containsKey(time)) {
//                        minDataDic.get(time).max = tagPqData;
//                    } else {
//                        MinData minData = new MinData();
//                        minData.max = tagPqData;
//                        minDataDic.put(time, minData);
//                    }
//                } else if (strFile.toUpperCase().indexOf("MIN") >= 0) {
//                    if (minDataDic.containsKey(time)) {
//                        minDataDic.get(time).min = tagPqData;
//                    } else {
//                        MinData minData = new MinData();
//                        minData.min = tagPqData;
//                        minDataDic.put(time, minData);
//                    }
//                }
//            }
//        } catch (IOException e) {
//            System.out.println("处理文件时发生错误： " + strFile);
//        } finally {
//            if (binFile != null) {
//                try {
//                    binFile.close();
//                } catch (IOException e) {
//                    System.out.println("关闭文件时发生错误： " + strFile);
//                }
//            }
//        }
//
//    }
//    public static List<TagComtradeCfg> convertCfgFile(String strFilePath) { //解析cfg录波文件
//        List<TagComtradeCfg> tagComtradeCfgList = new ArrayList<>();
//        File folder = new File(strFilePath);
//        File[] files = folder.listFiles((dir, name) -> name.endsWith(".cfg")); //获取文件夹下所有cfg文件
//        Arrays.stream(files).forEach(file -> {
//            TagComtradeCfg tagComtradeCfg = analyseComtradeCfg(file.getAbsolutePath());
//            tagComtradeCfgList.add(tagComtradeCfg);
//        });
//        return tagComtradeCfgList;
//    }
//    /**
//    * @Description: analyseComtradeCfg 读取、分析cfg录波文件!!!
//    * @Param:
//    * @return: com.njcn.user.utils.test.tagComtradeCfg
//    * @Author: clam
//    * @Date: 2024/7/15
//    */
//    public static TagComtradeCfg analyseComtradeCfg(String strFilePath) {
//        TagComtradeCfg comtradeCfg = new TagComtradeCfg();
//
//        if (strFilePath.equals("")) {
//            return comtradeCfg;
//        }
//
//        int i = 0; //用于遍历 字符串转换的字段数组
//        String strFileLine;//临时存放 cfg每行读取的字符串
//        String[] strTempArray; //临时存放 字符串转换的字段数组
//
//        tagRates ratesCfg = new tagRates();
//        try {
//            FileInputStream readFile = new FileInputStream(strFilePath);
//            InputStreamReader isr = new InputStreamReader(readFile, StandardCharsets.UTF_8);
//            BufferedReader sr = new BufferedReader(isr);
//            comtradeCfg = new TagComtradeCfg();//配置文件总类对象初始化
//            ratesCfg = new tagRates();//多段采样类对象初始化
//            long nFreq = 0; //临时存放 采样频率  例：50Hz
//            //第一行不关心仅仅是一些描述类的信息
//            strFileLine = sr.readLine(); // ①
//            //第二行需要关心第二个：模拟通道编号(模拟量的个数)和第三个：状态通道参数(开关量的个数)
//            strFileLine = sr.readLine(); // ②
//            strTempArray = strFileLine.split(",");
//            for (i = 0; i < strTempArray.length; i++) {
//                switch (i) {
//                    case 0: //通道总个数
//                        comtradeCfg.nChannelNum = Integer.parseInt(strTempArray[i]);
//                        break;
//                    case 1: //模拟量的个数
//                        String str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
//                        comtradeCfg.nAnalogNum = Integer.parseInt(str);
//                        break;
//                    case 2://开关量的个数
//                        str = strTempArray[i].substring(0, strTempArray[i].length() - 1);
//                        comtradeCfg.nDigitalNum = Integer.parseInt(str);
//                        break;
//                }
//            }
//            //从第三行到第ComtradeCfg.nChannelNum+3行是模拟量通道和数字量通道
//            List<tagOneChannleCfg> OneChannleCfgList =new ArrayList<>();
//            for (i = 0; i < comtradeCfg.nChannelNum; i++) {
//                tagOneChannleCfg oneChannlecfg = new tagOneChannleCfg();
//
//                strFileLine = sr.readLine(); // ③ or ④ or ⑤
//                strTempArray = strFileLine.split(",");
//                for (int j = 0; j < strTempArray.length; j++) {
//                    switch (j) {
//                        case 0://通道序号
//                            oneChannlecfg.nIndex = Integer.parseInt(strTempArray[j]);
//                            break;
//                        case 1://通道名称
//                            oneChannlecfg.szChannleName = strTempArray[j];
//                            break;
//                        case 2://监视的通道名称
//                            oneChannlecfg.szPhasicName = strTempArray[j];
//                            break;
//                        case 3://监视的通道名称
//                            oneChannlecfg.szMonitoredChannleName = strTempArray[j];
//                            break;
//                        case 4://通道的单位
//                            oneChannlecfg.szUnitName = strTempArray[j];
//                            break;
//                        case 5://通道的系数
//                            oneChannlecfg.fCoefficent = Float.parseFloat(strTempArray[j]);
//                            break;
//                        case 6://通道的偏移量
//                            oneChannlecfg.fOffset = Float.parseFloat(strTempArray[j]);
//                            break;
//                        case 7://起始采样时间的偏移量
//                            oneChannlecfg.fTimeOffset = Float.parseFloat(strTempArray[j]);
//                            break;
//                        case 8://采样值的最小值
//                            oneChannlecfg.nMin = Integer.parseInt(strTempArray[j]);
//                            break;
//                        case 9://采样值的最大值
//                            oneChannlecfg.nMax = Integer.parseInt(strTempArray[j]);
//                            break;
//                        case 10://一次变比
//                            oneChannlecfg.fPrimary = Float.parseFloat(strTempArray[j]);
//                            break;
//                        case 11://二次变比
//                            oneChannlecfg.fSecondary = Float.parseFloat(strTempArray[j]);
//                            break;
//                        case 12://一次值还是二次值标志
//                            oneChannlecfg.szValueType = strTempArray[j];
//                            break;
//                    }
//                }
//                OneChannleCfgList.add(oneChannlecfg);
//
//            }
//            comtradeCfg.setOneChannleCfg(OneChannleCfgList);
//            //采样频率：在交变电流电路中一秒钟内交流电所允许而必须变化的周期数，即：在单位时间内振动的次数
//            strFileLine = sr.readLine(); // ⑥
//            float fFreq = Float.parseFloat(strFileLine);
//            nFreq = (long) fFreq;
//
//            strFileLine = sr.readLine(); // ⑦
//            int nRates = Integer.parseInt(strFileLine);
//            ratesCfg.nRates = nRates;
//
//            long nOffset = 0;//上一段单周波采样点数
//            long nMSTotal = 0;//录波总毫秒数
//            for (i = 0; i < nRates; i++) {
//                strFileLine = sr.readLine(); //⑧例：3200,22400 ——> 理解为：1到22400这22400个数据的采样率是3200
//                strTempArray = strFileLine.split(",");
//
//                tagOneRate oneRate = new tagOneRate();//1段采样类对象
//                ratesCfg.getOneRate().add(oneRate);
//                for (int j = 0; j < strTempArray.length; j++) {
//                    switch (j) {
//                        case 0://采样率：1秒钟内的采样点数
//                            oneRate.nOneSample = (long) (Float.parseFloat(strTempArray[j]) / nFreq);
//                            break;
//                        case 1: //总采样点数
//                            oneRate.nSampleNum = (long) (Float.parseFloat(strTempArray[j]) - nOffset);
//                            nOffset += oneRate.nSampleNum;
//                            break;
//                    }
//                    nMSTotal += oneRate.nSampleNum / oneRate.nOneSample;
//                }
//            }
//
//            nMSTotal *= 20; //录波总毫秒数  注：一个周波20ms，所以此处要乘以20
//            if (nMSTotal > 60000) {//如果事件长度超过1分钟，则结束处理，不调用录波高级算法qvvr_fun
//
//                sr.close();
//                readFile.close();
//                return comtradeCfg;
//            }
//            //波形起始时间
//            strFileLine = sr.readLine(); // ⑨
//            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy,HH:mm:ss.SSSSSS");
//            comtradeCfg.setTimeTrigger(sdf.parse(strFileLine));
//
//            strFileLine = sr.readLine(); // ⑩
//            comtradeCfg.setTimeStart(sdf.parse(strFileLine));
//            comtradeCfg.setTimeEnd(new Date(comtradeCfg.getTimeStart().getTime() + nMSTotal));;
//            comtradeCfg.setPath(new File(strFilePath).getName());
//
//            sr.close();
//            readFile.close();
//        } catch (IOException | ParseException e) {
//            System.out.println("Error opening file: " + strFilePath + " " + e.getMessage());
//            return comtradeCfg;
//        }
//
//        return comtradeCfg;
//    }
//
//    public static void main(String[] args) throws IOException {
//        TagComtradeCfg tagComtradeCfg = AnalyseComtradeCfg1.analyseComtradeCfg("C:\\Users\\Administrator\\Desktop\\浙江无线\\离线数据上传\\09\\comtrade\\line1_20240704_143908_213.cfg");
//        System.out.println(tagComtradeCfg);
//        AnalyseComtradeCfg1.processDirectory("C:\\Users\\Administrator\\Desktop\\浙江无线\\离线数据上传\\09\\min");
//        PqdData pqdData = new PqdData();
//    }
//}
