package com.ruoyi.web.controller;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.ucp.entity.PointData;
import com.ruoyi.ucp.entity.PointInfo;
import com.ruoyi.ucp.entity.TurbineInfoDay;
import com.ruoyi.ucp.feign.AdapterApi;
import com.ruoyi.ucp.util.CalcCache;
import com.ruoyi.web.runner.ServiceGroup;
import lombok.Delegate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

//@Service
@Service
public class JavaFunctionJobHandler2 {

    public static final Logger logger = LoggerFactory.getLogger(JavaFunctionJobHandler.class);

    @Resource
    private AdapterApi adapter;
    @Resource
    private ServiceGroup serviceGroup;
    @Delegate
    @Resource
    private JavaFunctionJobHandler handler;

    //场站上网购网厂用综合场用日发电量累加推送
    public void calcStationSwGwCyZhcyRfdlLjTs(DateTime begin, DateTime end) {
        if (end.equals(DateUtil.beginOfDay(end))) return;
        List<PointInfo> entity = getEntity("AI121", "turbine");
        List<PointInfo> swdlEt = getEntity("Z-ZXYG-CX", "meter");
        List<PointInfo> gwdlEt = getEntity("Z-FXYG-CX", "meter");
        List<PointInfo> cydlEt = getEntity("B-ZXYG-ZDB1", "meter");
        getRawDataByEntity(entity, goldenUri(), begin, end);
        Map<String, Map<String, List<PointInfo>>> stationLineMap = entity.stream().collect(Collectors.groupingBy(PointInfo::getStationId, Collectors.groupingBy(PointInfo::getLineId)));
        Map<String, PointInfo> swdlMap = getRawDataByEntity(swdlEt, goldenUri(), begin, end, PointInfo::getStationId);
        Map<String, PointInfo> gwdlMap = getRawDataByEntity(gwdlEt, goldenUri(), begin, end, PointInfo::getStationId);
        Map<String, PointInfo> cydlMap = getRawDataByEntity(cydlEt, goldenUri(), begin, end, PointInfo::getStationId);

        swdlMap.forEach((stId, info) -> {
            Map<String, List<PointInfo>> lineMap = stationLineMap.get(stId);
            lineMap.forEach((lineId, pis) -> {
                double rfdl = out2Zero(pis.stream().mapToDouble(pi -> calcHaDl(pi)).sum(), 0, 6000000);
                getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日风机发电量"), rfdl, 0.001);
            });
            double rfdl = out2Zero(entity.stream().mapToDouble(pi -> calcHaDl(pi)).sum(), 0, 6000000) / 1000;
            double swdl = out2Zero(calcHaDl2w(info), 0, 6000000) / 1000;
            double gwdl = out2Zero(calcHaDl(gwdlMap.get(stId)), 0, 6000000) / 1000;
            double cydl = out2Zero(calcHaDl(cydlMap.get(stId)), 0, 6000000) / 1000;
            getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日发电量", rfdl);
            getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日上网电量", swdl);
            getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日购网电量", gwdl);
            getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日场用电量", cydl);
            double zhcydl = rfdl + gwdl - swdl;
            getDataForZb(end, "区域集控.惠安风场.光耀计算.日综合场用电量", zhcydl);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.月综合场用电量", tsSub(tsAdd("月发电量", "月购网电量"), "月上网电量"));
            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电量", tsSub(tsAdd("年发电量", "年购网电量"), "年上网电量"));

            getDataForZb(end, "区域集控.惠安风场.光耀计算.日场用电率", cydl / rfdl * 100);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.日综合场用电率", zhcydl / rfdl * 100);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.月场用电率", tsDiv("月场用电量", "月发电量") * 100);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.月综合场用电率", tsDiv("月综合场用电量", "月发电量") * 100);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.年场用电率", tsDiv("年场用电量", "年发电量") * 100);
            getDataForZb(end, "区域集控.惠安风场.光耀计算.年综合场用电率", tsDiv("年综合场用电量", "年发电量") * 100);
        });
    }

    //场站五项损失累加推送，依赖calcStationSwGwCyZhcyRfdlLjTs计算的日发电量
    public void calcStation5sLjTs(DateTime begin, DateTime end, double ssxs) {
        if (end.equals(DateUtil.beginOfDay(end))) return;
        List<PointInfo> isFubing = getIsFubing(begin, end);
        Map<String, List<PointData>> isFubingMap = isFubing.stream().collect(Collectors.toMap(PointInfo::getTurbineId, PointInfo::getPointDatas));
        //风速
        List<PointInfo> entityFs = CalcCache.pointInfosMap.get("推送-turbine-风速-snap15s");
        Map<String, Map<String, List<PointData>>> fsMapMap = pointInfos2MapMap(entityFs);
        //功率
        List<PointInfo> entityGl = CalcCache.pointInfosMap.get("推送-turbine-功率-snap15s");
        Map<String, Map<String, List<PointData>>> glMapMap = pointInfos2MapMap(entityGl);
        //状态
        List<PointInfo> ztMapMap = CalcCache.pointInfosMap.get("推送-turbine-状态-snap15s");
        Map<String, Map<String, PointInfo>> ztMapMapInfos = pointInfos2MapMap2(ztMapMap);
        Map<String, TurbineInfoDay> dayMap = getTurbineinfoMap(begin, entityFs);
        ztMapMapInfos.forEach((stId, ztMapInfo) -> ztMapInfo.forEach((wtId, ztInfo) -> {
            //0 待机，1 手动停机，2 正常发电，3 发电降出力，4 故障，5 故障受累，6 检修，7 检修受累，8 限电降出力，
            // 9 限电停机，10 电网受累，11 环境受累，12 通讯中断，13 设备离线
            TurbineInfoDay infoDay = dayMap.get(wtId);
            Map<String, Double> loss = getTurbinePowerLoss2(isFubingMap.get(wtId), ztInfo, fsMapMap.get(stId).get(wtId), glMapMap.get(stId).get(wtId));
            infoDay.setJhjxss(loss.get("jxss") * ssxs);
            infoDay.setFjhjxss(loss.get("gzss") * ssxs + loss.get("fdjcl") * ssxs + loss.get("sdtj") * ssxs);
            infoDay.setXdss(loss.get("xdjcl") * ssxs + loss.get("xdtj") * ssxs);
            infoDay.setSlss(loss.get("slss") * ssxs);
            infoDay.setDjss(loss.get("xdtj") * ssxs);
            infoDay.setGzss(loss.get("gzss") * ssxs);
            infoDay.setXnss(loss.get("xnss") * ssxs + loss.get("djss") * ssxs);
            //infoDay.setLlfdl(infoDay.getRfdl() + infoDay.getJhjxss() + infoDay.getFjhjxss() + infoDay.getXdss() + infoDay.getSlss() + infoDay.getXnss());
        }));

        //AGC
        List<PointInfo> entityAgc = CalcCache.pointInfosMap.get("推送-booster-AGC-snap15s");
        //出线
        List<PointInfo> entityCx = CalcCache.pointInfosMap.get("推送-booster-出线-snap15s");
        //可用功率
        List<PointData> kyglpds = CalcCache.pointDatasMap.get("推送-booster-可用功率-snap15s");
        PointInfo cxPi = entityCx.get(0);
        List<PointData> cxPds = cxPi.getPointDatas();
        List<PointData> czxd = calcStationXd2(entityAgc.get(0), cxPds, kyglpds, 0.01);
        List<Double> xdl = new ArrayList<>();
        //总损失电量
        List<Double> zssdl = new ArrayList<>();
        int min = findMin(cxPds, kyglpds, czxd);
        for (int i = 0; i < min; i++) {
            double v = kyglpds.get(i).getValue() * 1000 - cxPds.get(i).getValue() * cxPi.getCoef();
            if (v < 0) v = 0;
            if (czxd.get(i).isBooleanValue()) {
                xdl.add(v);
            } else {
                xdl.add(0d);
                zssdl.add(v);
            }
        }
        //可用功率算的限电量
        double sumxdl = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400 / 1000;
        //adapter.writeHistoryBatch(mqttUri(), getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl));
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电量", sumxdl);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", sumxdl / tsAdd(sumxdl, "日发电量") * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", tsDiv("月限电量", tsAdd("月限电量", "月发电量")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", tsDiv("年限电量", tsAdd("年限电量", "年发电量")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.日限电率").getValue());
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.月限电率").getValue());
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年限电率", CalcCache.pointDataMap.get("区域集控.惠安风场.光耀计算.年限电率").getValue());
        Collection<TurbineInfoDay> values = dayMap.values();
        //可用功率算的总损失电量(除限电)
        double sumZssdl = zssdl.stream().mapToDouble(Double::doubleValue).sum() / 2400 / 1000;
        //理论功率算的总损失电量(除限电) xd + fjh + jh + xn + sl
        double zsssum = values.stream().mapToDouble(tid -> tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss() + tid.getSlss()).sum();
        double xdsum = values.stream().mapToDouble(TurbineInfoDay::getXdss).sum();
        //可用功率算的限电
        double sum = xdl.stream().mapToDouble(Double::doubleValue).sum() / 2400;
        double xdxs = xdsum == 0d ? 0d : sum / xdsum;
        double zssXs = zsssum == 0d ? 0d : sumZssdl / zsssum;

        double jhjxss = 0, fjhjxss = 0, xnss = 0, djss = 0, gzss = 0, slss = 0;
        for (TurbineInfoDay tid : values) {
            tid.setXdss((tid.getXdss() - tid.getDjss()) * xdxs);
            //
            tid.setJhjxss(tid.getJhjxss() * zssXs);
            tid.setFjhjxss(tid.getFjhjxss() * zssXs);
            tid.setXnss(tid.getXnss() * zssXs);
            tid.setDjss(tid.getDjss() * zssXs);
            tid.setGzss(tid.getGzss() * zssXs);
            tid.setSlss(tid.getSlss() * zssXs);
            tid.setLlfdl(tid.getRfdl() + tid.getXdss() + tid.getFjhjxss() + tid.getJhjxss() + tid.getXnss());

            jhjxss += tid.getJhjxss();
            fjhjxss += tid.getFjhjxss();
            xnss += tid.getXnss();
            djss += tid.getDjss();
            gzss += tid.getGzss();
            slss += tid.getSlss();
        }
        IService<TurbineInfoDay> service = serviceGroup.getService(TurbineInfoDay.class);
        //service.saveOrUpdateBatch(values);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日故障损失电量", gzss * zssXs);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日计划检修损失电量", jhjxss * zssXs);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日受累损失电量", (djss + slss) * zssXs);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日损失电量", sumZssdl);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日限电损失电量", sumxdl);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日性能损失电量", xnss * zssXs);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日性能损失率", (xnss * zssXs) / tsAdd("日性能损失电量", "日发电量") * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月性能损失率", tsDiv("月限电量", tsAdd("月限电量", "月发电量")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年性能损失率", tsDiv("年限电量", tsAdd("年限电量", "年发电量")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月损失电量", tsAdd("月限电量", "月计划检修损失电量", "月故障损失电量", "月性能损失电量", "月受累损失电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年损失电量", tsAdd("年限电量", "年计划检修损失电量", "年故障损失电量", "年性能损失电量", "年受累损失电量"));

        getDataForZb(end, "区域集控.惠安风场.光耀计算.日理论发电量", tsAdd("日发电量", "日损失电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月理论发电量", tsAdd("月发电量", "月损失电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年理论发电量", tsAdd("年发电量", "年损失电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日风能利用率", tsDiv("日发电量", "日理论发电量") * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月风能利用率", tsDiv("月发电量", "月理论发电量") * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年风能利用率", tsDiv("年发电量", "年理论发电量") * 100);
    }
    //线路发电量耗电量主变发电量累加推送
    public void calcXlZbFdlLjTs(DateTime begin, DateTime end) {
        if (end.equals(DateUtil.beginOfDay(end))) return;
        DateTime begin0 = DateUtil.offsetDay(begin, -1);
        List<PointInfo> entity0 = getEntity("Z-ZXYG-JX", "meter");
        filterList(entity0, pi -> "".equals(pi.getProjectId()));
        getRawDataByEntity(entity0, goldenUri(), begin0, begin);
        List<PointInfo> entity = getEntity("Z-ZXYG-JX", "meter");
        filterList(entity, pi -> "".equals(pi.getProjectId()));
        getRawDataByEntity(entity, goldenUri(), begin, end);
        //线路耗电量
        List<PointInfo> entityHdl = getEntity("Z-FXYG-JX", "meter");
        filterList(entityHdl, pi -> "".equals(pi.getProjectId()));
        getRawDataByEntity(entityHdl, goldenUri(), begin, end);

        Map<String, PointInfo> fdlMap0 = list2Map(entity0, PointInfo::getLineId);
        Map<String, PointInfo> fdlMap = list2Map(entity, PointInfo::getLineId);
        Map<String, PointInfo> hdlMap = list2Map(entityHdl, PointInfo::getLineId);

        for (PointInfo day : entity) {
            String lineId = day.getLineId();
            double fdl = 0;
            try {
                double pdsfdl0 = fdlMap0.get(lineId).getPointDatas().stream().mapToDouble(PointData::getValue).max().orElse(0);
                double pdsfdl = day.getPointDatas().stream().mapToDouble(PointData::getValue).max().orElse(0);
                fdl = out2Zero(NumberUtil.round((pdsfdl - pdsfdl0), 2).doubleValue() * day.getCoef(), 0, 90000);
            } catch (Exception e) {
                e.printStackTrace();
            }
            double hdl = out2Zero(calcHaDl(hdlMap.get(lineId)), 0, 90000);
            getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日发电量"), fdl * 0.001);
            getDataForZbs2(end, CalcCache.oneMap.get(lineId + "-日耗电量"), hdl * 0.001);
        }
        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线日发电量", tsAdd("集电一线日发电量", "集电二线日发电量", "集电三线日发电量", "集电四线日发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线月发电量", tsAdd("集电一线月发电量", "集电二线月发电量", "集电三线月发电量", "集电四线月发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.集电线年发电量", tsAdd("集电一线年发电量", "集电二线年发电量", "集电三线年发电量", "集电四线年发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日线路损耗", tsSub("日发电量", "集电线日发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月线路损耗", tsSub("月发电量", "集电线月发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年线路损耗", tsSub("年发电量", "集电线年发电量"));
        System.out.println();
    }

    //风机平均风速累加推送
    public void calcStationPjfsLjTs(DateTime begin, DateTime end) {
        if (end.equals(DateUtil.beginOfDay(end))) return;

        List<PointInfo> fsEntity = getEntity("AI066", "turbine");
        getRawDataByEntity(fsEntity, goldenUri(), begin, end);
        double yf = fsEntity.stream().mapToLong(e -> calcMatchDuration(e.getPointDatas(), pd -> pd.getValue() > 3 && pd.getValue() < 18)).average().orElse(0.0);
        yf = yf / (1000 * 60 * 60d);

        double fs = fsEntity.stream().mapToDouble(e -> averagePd(e.getPointDatas())).average().orElse(0);

        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日平均风速", fs);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日有效风时数", yf);
    }

    //场站利用小时累加推送
    public void calcStationLyxsLjTs(DateTime begin, DateTime end) {
        //装机容量
        List<PointInfo> entityAiZt = getEntity("AI422", "state");
        double zjrl = entityAiZt.stream().mapToDouble(pi -> pi.getSpare2() * pi.getCoef()).sum() / 1000;
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日利用小时", tsDiv("日发电量", zjrl));
    }

    //场站运行小时累加推送
    public void calcStationYxxsLjTs(DateTime begin, DateTime end) {
        //状态测点
        List<PointInfo> entityMxzt = getEntity("MXZT", "turbine");
        getRawDataByEntity(entityMxzt, taosUri(), begin, end);
        double yxxs = 0, gzxs = 0, jxxs = 0, djxs = 0, tjxs = 0, gzcs = 0;
        double klyl = 0;
        for (PointInfo info : entityMxzt) {
            //统计
            Map<String, Map<Double, Long>> dlmm = calcStateDurationFrequency(info.getPointDatas());
            Map<Double, Long> durations = dlmm.get("duration");
            Map<Double, Long> frequency = dlmm.get("frequency");
            yxxs += durations.getOrDefault(2.0, 0L);
            Long gzt = durations.getOrDefault(4.0, 0L);
            gzxs += gzt;
            jxxs += durations.getOrDefault(6.0, 0L);
            djxs += durations.getOrDefault(0.0, 0L);
            tjxs += durations.getOrDefault(1.0, 0L);
            gzcs += frequency.getOrDefault(4.0, 0L);
            klyl += (24 - gzt / (1000 * 60 * 60d)) / 24;
        }
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日运行小时", yxxs / (1000 * 60 * 60d) / entityMxzt.size());
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日风电机组故障停运时长", gzxs / (1000 * 60 * 60d) / entityMxzt.size());
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日计划停机时长", jxxs / (1000 * 60 * 60d) / entityMxzt.size());
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日技术待机时长", djxs / (1000 * 60 * 60d) / entityMxzt.size());
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日平均停机时长", tjxs / (1000 * 60 * 60d) / entityMxzt.size());
        getDataForZb(end, "区域集控.惠安风场.光耀计算.日自然因素停运时长", 0);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月自然因素停运时长", 0);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年日自然因素停运时长", 0);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.日风电机组故障停运次数", gzcs);
        getDataForZbs5(end, "区域集控.惠安风场.光耀计算.日风电机组设备可利用率", klyl / entityMxzt.size() * 100);

        getDataForZb(end, "区域集控.惠安风场.光耀计算.日运行暴露率", tsDiv("日运行小时", 24d - tsAdd("日风电机组故障停运时长", "日计划停机时长")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.月运行暴露率", tsDiv("月运行小时", 24d * end.dayOfMonth() - tsAdd("月风电机组故障停运时长", "月计划停机时长")) * 100);
        getDataForZb(end, "区域集控.惠安风场.光耀计算.年运行暴露率", tsDiv("年运行小时", 24d * end.dayOfYear() - tsAdd("年风电机组故障停运时长", "年计划停机时长")) * 100);
    }

    //场站空气密度平均气温累加推送
    public void calcStationKqmdLjTs(DateTime begin, DateTime end) {
        //环境温度
        List<PointInfo> entityHjwd = getEntity("AI072", "turbine");
        getRawDataByEntity(entityHjwd, goldenUri(), begin, end);
        Map<String, List<PointInfo>> hjwdsMap = entityHjwd.stream().collect(Collectors.groupingBy(PointInfo::getStationId));
        //测风塔温度
        List<PointInfo> wdEt = getEntity("FCCFTWD", "station");
        List<PointInfo> yqEt = getEntity("FCCFTYQ", "station");
        Map<String, PointInfo> rawWd = getRawDataByEntity(wdEt, goldenUri(), begin, end, PointInfo::getStationId);
        Map<String, PointInfo> secYq = getRawDataByEntity(yqEt, goldenUri(), begin, end, PointInfo::getStationId);

        hjwdsMap.forEach((stId, pis) -> {
            //环境温度
            List<PointInfo> hjwdInfos = hjwdsMap.get(stId);
            List<Double> hjwds = new ArrayList<>();
            for (PointInfo wd : hjwdInfos) {
                double v = wd.getPointDatas().stream().filter(p -> p.getValue() != 0.0).mapToDouble(PointData::getValue).average().orElse(0.0);
                if (v > 0 && v < 83) hjwds.add(v);
            }
            double hjwd = hjwds.stream().mapToDouble(Double::doubleValue).average().orElse(0.0);
            //测风塔温度
            List<PointData> wdData = rawWd.get(stId).getPointDatas();
            List<PointData> yqData = secYq.get(stId).getPointDatas();
            double wd = wdData.stream().mapToDouble(PointData::getValue).average().orElse(0d);
            double yq = yqData.stream().mapToDouble(PointData::getValue).average().orElse(0d);
            double kqmd = 1.293 * (yq * 100 / 101325) * (273.15 / (wd + 273.15));
            getDataForZbs4(end, "区域集控.惠安风场.光耀计算.日平均气温", hjwd);
            getDataForZbs4(end, "区域集控.惠安风场.光耀计算.日平均空气密度", kqmd);
        });
    }

    //主变耗电量累加推送
    public void calcMeterDlHdlLjTs(DateTime begin, DateTime end) {
        //1号SVG B-ZXYG-SVG1 B-FXYG-SVG1
        double svg1Hdl = calcMeterSimple("B-ZXYG-SVG1", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号SVG日耗电量", svg1Hdl);
        //2号SVG B-ZXYG-SVG2 B-FXYG-SVG2
        double svg2Hdl = calcMeterSimple("B-ZXYG-SVG2", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号SVG日耗电量", svg2Hdl);
        //1号接地变兼站用变 B-ZXYG-ZDB1 B-FXYG-ZDB1
        double zyb1Hdl = calcMeterSimple("B-ZXYG-ZDB1", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号站用变日耗电量", zyb1Hdl);
        //2号接地变 B-ZXYG-ZDB1 B-FXYG-ZDB1
        double jdb2Hdl = calcMeterSimple("B-ZXYG-ZDB2", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号接地变日耗电量", jdb2Hdl);
        //1号主变低压侧正向有功
        double zbdyc1Hdl = calcMeterSimple("B-ZXYG-ZBDYC1", begin, end);
        double zbdyc1Fdl = calcMeterSimple("B-FXYG-ZBDYC1", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变低压侧日发电量", zbdyc1Fdl);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变低压侧日耗电量", zbdyc1Hdl);
        //1号主变高压侧正向有功 B-ZXYG-ZBGYC1
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变高压侧日发电量", 0);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.1号主变高压侧日耗电量", 0);
        //2号主变低压侧正向有功
        double zbdyc2Hdl = calcMeterSimple("B-ZXYG-ZBDYC2", begin, end);
        double zbdyc2Fdl = calcMeterSimple("B-FXYG-ZBDYC2", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变低压侧日发电量", zbdyc2Hdl*10);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变低压侧日耗电量", zbdyc2Hdl/10,10);
        //2号主变高压侧正向有功
        double zbgyc2Hdl = calcMeterSimple("B-ZXYG-ZBGYC2", begin, end);
        double zbgyc2Fdl = calcMeterSimple("B-FXYG-ZBGYC2", begin, end);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变高压侧日发电量", zbgyc2Fdl);
        getDataForZbs2(end, "区域集控.惠安风场.光耀计算.2号主变高压侧日耗电量", zbgyc2Hdl);

        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变日损耗电量", tsSub("1号主变低压侧日发电量", "1号主变高压侧日发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变日损耗电量", tsSub("2号主变低压侧日耗电量", "2号主变高压侧日发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变日损耗合计", tsAdd("1号主变日损耗电量", "2号主变日损耗电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变月损耗电量", tsSub("1号主变低压侧月发电量", "1号主变高压侧月发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变月损耗电量", tsSub("2号主变低压侧月耗电量", "2号主变高压侧月发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变月损耗合计", tsAdd("1号主变月损耗电量", "2号主变月损耗电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.1号主变年损耗电量", tsSub("1号主变低压侧年发电量", "1号主变高压侧年发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.2号主变年损耗电量", tsSub("2号主变低压侧年耗电量", "2号主变高压侧年发电量"));
        getDataForZb(end, "区域集控.惠安风场.光耀计算.主变年损耗合计", tsAdd("1号主变年损耗电量", "2号主变年损耗电量"));
    }


    //风机平均风速实时推送
    public void calcStationPjfsSsTs() {

        List<PointInfo> fsEntity = getEntity("AI066", "turbine");
        getLatestByEntity(fsEntity, goldenUri());

        double fs = fsEntity.stream().mapToDouble(e -> e.getPointDatas().get(0).getValue()).average().orElse(0);

        PointData zb = getDataForZb(DateUtil.date(), "区域集控.惠安风场.光耀计算.平均风速", fs);
        adapter.writeHistoryBatch(mqttUri(), Collections.singletonList(zb));
    }

    public void setDatas(DateTime begin, DateTime end) {
        List<PointData> dataList = CalcCache.pointDataMap.values().stream().filter(pd -> pd.getTagName().startsWith("区域集控.惠安风场.光耀计算.")).collect(Collectors.toList());
        adapter.writeHistoryBatch(mqttUri(), dataList);
        System.out.println();
    }

}