package com.gyee.runeconomy.init;

import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.gyee.common.model.StringUtils;
import com.gyee.runeconomy.config.GyeeConfig;
import com.gyee.runeconomy.controller.agc.AgcDeviateConfig;
import com.gyee.runeconomy.controller.agc.FileService;
import com.gyee.runeconomy.model.TemperatureComponentInfo;
import com.gyee.runeconomy.model.TemperatureInfo;
import com.gyee.runeconomy.model.auto.*;
import com.gyee.runeconomy.service.auto.*;
import com.gyee.runeconomy.service.realtimelibrary.TheoreticalPowerService;
import com.gyee.runeconomy.util.redis.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

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

/**
 * @ClassName : CacheContext
 * @Author : xieshengjie
 * @Date: 2021/5/18 9:35
 * @Description : 缓存
 */
@Component
public class CacheContext implements CommandLineRunner {
    Logger logger = LoggerFactory.getLogger(CacheContext.class);

    private final String QS = "0";

    @Resource
    private IProBasicEquipmentService proBasicEquipmentService;
    @Resource
    private IProBasicLineService proBasicLineService;
    @Resource
    private IProBasicProjectService proBasicProjectService;

    @Resource
    private IProBasicPowerstationService proBasicWindpowerstationService;
    @Resource
    private IProBasicMeterPointService proBasicMeterPointService;
    @Resource
    private IProEconEquipmentmodelService proEconEquipmentmodelService;

    @Resource
    private IProBasicWindturbinePowerService proBasicWindturbinePowerService;
    @Resource
    private RedisService redisService;
    @Resource
    private IProBasicModelPowerService proBasicModelPowerService;
    @Resource
    private IProBasicSubStationService proBasicSubStationService;
    @Resource
    private IProBasicWeatherStationService proBasicWeatherStationService;
    @Resource
    private IProBasicSquareService proBasicSquareService;
    @Resource
    private IProBasicCompanyService proBasicCompanyService;
    @Resource
    private IProBasicRegionService proBasicRegionService;
    @Resource
    private IProBasicEnergyGroupService proBasicEnergyGroupService;
    @Resource
    private IProBasicBranchService proBasicBranchService;
    @Resource
    private TheoreticalPowerService theoreticalPowerService;

    @Resource
    private IProBasicModelPowerRdService proBasicModelPowerRdService;

    @Resource
    private IProBasicPowerstationPointService proBasicPowerstationPointService;

    @Resource
    private IProBasicEquipmentPointService proBasicEquipmentPointService;
    @Resource
    private IProBasicMeterPointService meterpoint2Service;

    @Resource
    private IProBasicPowerstationService windpowerstationService;

    @Resource
    private ITemperatureinfoService iTemperatureinfoService;
    @Resource
    private FileService fileService;

    @Resource
    GyeeConfig config;

    /**
     * 温度矩阵信息
     */
    public static List<TemperatureInfo> temperatureInfos;


    //    public static List<ProBasicBranch> bnls = new ArrayList<>();
    public static List<ProBasicEquipment> wtls = new ArrayList<>();
    public static List<ProBasicProject> pjls = new ArrayList<>();
    public static List<ProBasicLine> lnls = new ArrayList<>();
    public static List<ProBasicSubStation> subwpls = new ArrayList<>();
    public static List<ProBasicWeatherStation> weawpls = new ArrayList<>();
    public static List<ProBasicSquare> sqls = new ArrayList<>();
    public static List<ProBasicPowerstation> wpls = new ArrayList<>();
    public static List<ProBasicPowerstation> wplsf = new ArrayList<>();
    public static List<ProBasicPowerstation> wplsG = new ArrayList<>(); //光电集合
    public static List<ProBasicPowerstation> zwpls = new ArrayList<>();
    public static List<ProBasicCompany> cpls = new ArrayList<>();
    public static List<ProBasicCompany> cpls1 = new ArrayList<>();
    public static List<ProBasicRegion> rgls = new ArrayList<>();
    public static List<ProBasicEnergyGroup> gpls = new ArrayList<>();
    public static List<ProBasicPowerstationPoint> powerpointls = new ArrayList<>();
    public static List<ProBasicEquipmentPoint> Equipmentpointls = new ArrayList<>();
    public static Map<String, ProBasicProject> pjmap = new HashMap<>();
    public static Map<String, ProBasicLine> lnmap = new HashMap<>();
    public static Map<String, ProBasicRegion> rgmap = new HashMap<>();
    public static Map<String, ProBasicCompany> cpmap = new HashMap<>();
    public static Map<String, ProBasicEnergyGroup> gpmap = new HashMap<>();

    public static Map<String, List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
    public static Map<String, List<ProBasicPowerstation>> wpmapls = new HashMap<>();
    public static Map<String, List<ProBasicPowerstation>> stationls = new HashMap<>();
    //    public static Map<String, List<ProBasicBranch>> wtbnmap = new HashMap<>();
    public static Map<String, List<ProBasicCompany>> rgcpmap = new HashMap<>();
    public static Map<String, ProBasicSquare> sqmap = new HashMap<>();
    public static Map<String, ProBasicPowerstation> wpmap = new HashMap<>();
    public static List<ProBasicMeterPoint> meterpoints = new ArrayList<>();
    public static Map<String, ProBasicMeterPoint> meterpointMap = new HashMap<>();
    public static Map<String, List<ProBasicProject>> wppromap = new HashMap<>();
    public static Map<String, List<ProBasicProject>> projmap = new HashMap<>();
    public static Map<String, List<ProBasicLine>> prolinemap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> wpwtmap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> pjwtmap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> lnwtmap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> cmwtlsmap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> rgwtlsmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicEquipment>> cmwtmap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> sqwtmap = new HashMap<>();
    //    public static Map<String, Map<String, ProBasicEquipmentPoint>> bnAimap = new HashMap<>();
    public static Map<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = new HashMap<>();// 风电机测点AI表
    public static Map<String, Map<String, ProBasicEquipmentPoint>> wtpointmap = new HashMap<>();//风机测点
    public static Map<String, Map<String, ProBasicPowerstationPoint>> linepointmap = new HashMap<>();
    //    public static Map<String,Map<String, ProBasicPowerstationPoint>> lnPointmap =new HashMap<>();//线路测点
    public static Map<String, Map<String, ProBasicPowerstationPoint>> propointmap = new HashMap<>();
    //    public static Map<String,Map<String, ProBasicPowerstationPoint>> pjPointmap =new HashMap<>(); //期次测点
    public static Map<String, Map<String, ProBasicPowerstationPoint>> wppointmap = new HashMap<>();
    //    public static Map<String,Map<String, ProBasicPowerstationPoint>> pointwpmap =new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> subwppointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> weatherwppointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> companypointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> regionpointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> grouppointmap = new HashMap<>();

    public static Map<String, Map<Double, Double>> zbzglMap = new HashMap<>();
    public static Map<String, ProEconEquipmentmodel> modelMap = new HashMap<>();
    public static Map<String, Map<Double, Double>> zzsglMap = new HashMap<>();
    public static Map<String, Double> modelpower = new HashMap<>();

    public static Map<String, String> wtstandardmap = new HashMap<>();
    public static Map<String, ProBasicEquipment> wtmap = new HashMap<>();

    public static Map<String, Map<Double, ProBasicModelPower>> modelpowermap = new TreeMap<>();

    public static List<ProBasicModelPower> mpls = new ArrayList<>();

    public static List<ProEconEquipmentmodel> equipmentmodels = new ArrayList<>();

    public static Map<String, List<ProBasicEquipment>> subWtsMap = new HashMap<>();
    public static List<ProBasicModelPowerRd> theoreticalPowerList = new ArrayList<>();
    public static Map<String, Map<Double, ProBasicModelPowerRd>> theoreticalPowerMap = new HashMap<>(); //理论，保证功率
    //    public static Map<String, Map<Double, ProEconWtPowerCurveFitting>> curveFittingPowerMap = new HashMap<>(); //自算，最优功率
    public static Map<String, List<ProBasicStatusPoint>> statusMap = new HashMap<>();


    public static List<ProBasicPowerstation> stations = new ArrayList<>();
    public static Map<String, List<ProBasicMeterPoint>> wpmeterMap = new HashMap<>();
    public static Map<String, ProBasicMeterPoint> meterMap = new HashMap<>();
    public static Map<String, ProBasicPowerstation> wpmaps = new HashMap<>();
    public static Map<String, String> wppmap = new HashMap<>();

    public static Map<String, List<ProBasicEquipmentPoint>> pointNewMap = new HashMap<>();

    public static Map<String, List<ProBasicModelPower>> modelPowerDetailNewMap = new HashMap<>();

    /**
     * AGC信息缓存
     */
    public static Map<String, AgcDeviateConfig> agcDeviateConfigMap = new HashMap<>();
    public static Map<String, List<String>> files = new HashMap<>();

    private final List<String> order = Arrays.asList("风机信息", "主轴", "发电机", "齿轮箱", "变桨", "液压", "其他");

    @Override
    public void run(String... args) throws Exception {
        logger.info("缓存开始------------------------------------------------------------");


        //        bnls = proBasicBranchService.list();
        //        bnls.stream().forEach(bn->{
        //            String bnString = redisService.get(bn.getId());
        //            Map<String, ProBasicEquipmentPoint> stringWindturbinetestingpointnewMap = JSONObject.parseObject(bnString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
        //            });
        //            bnAimap.put(bn.getId(),stringWindturbinetestingpointnewMap);
        //
        //            if (wtbnmap.containsKey(bn.getInteverId())){
        //                wtbnmap.get(bn.getInteverId()).add(bn);
        //            }else {
        //                List<ProBasicBranch> bns = new ArrayList<>();
        //                bns.add(bn);
        //                wtbnmap.put(bn.getInteverId(),bns);
        //            }
        //        });


        equipmentmodels = proEconEquipmentmodelService.list();
        equipmentmodels.stream().forEach(e -> {
            modelMap.put(e.getId(), e);
        });
        mpls = proBasicModelPowerService.list();
        mpls.sort(Comparator.comparing(ProBasicModelPower::getSpeed));
        if (!mpls.isEmpty()) {

            for (ProBasicModelPower mp : mpls) {
                if (modelpowermap.containsKey(mp.getModelId())) {
                    Map<Double, ProBasicModelPower> tempmap = modelpowermap.get(mp.getModelId());
                    tempmap.put(mp.getSpeed(), mp);

                } else {
                    Map<Double, ProBasicModelPower> tempmap = new HashMap<>();
                    tempmap.put(mp.getSpeed(), mp);
                    modelpowermap.put(mp.getModelId(), tempmap);
                }
            }
        }
        sqls = proBasicSquareService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        if (!sqls.isEmpty()) {
            for (ProBasicSquare sq : sqls) {
                sqmap.put(sq.getId(), sq);
            }
        }

        cpls = proBasicCompanyService.list().stream().filter(i -> i.getIsAble().equals(1)).collect(Collectors.toList());

        cpls1 = proBasicCompanyService.list().stream().filter(i -> i.getSpare2().equals("1")).collect(Collectors.toList());
        if (!cpls.isEmpty()) {
            for (ProBasicCompany sq : cpls) {
                cpmap.put(sq.getId(), sq);

                if (redisService.hasKey(sq.getId() + "0")) {
                    String cp0String = redisService.get(sq.getId() + "0");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    companypointmap.put(sq.getId() + "0", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getId() + "-1")) {
                    String cp1String = redisService.get(sq.getId() + "-1");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    companypointmap.put(sq.getId() + "-1", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getId() + "-2")) {
                    String cp2String = redisService.get(sq.getId() + "-2");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    companypointmap.put(sq.getId() + "-2", stringWindpowerstationpointnewMap);
                }


            }

        }


        rgls = proBasicRegionService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());


        if (!rgls.isEmpty()) {
            for (ProBasicRegion sq : rgls) {
                rgmap.put(sq.getId(), sq);

                if (redisService.hasKey(sq.getId() + "0")) {
                    String cp0String = redisService.get(sq.getId() + "0");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    regionpointmap.put(sq.getId() + "0", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getId() + "-1")) {
                    String cp1String = redisService.get(sq.getId() + "-1");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    regionpointmap.put(sq.getId() + "-1", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getId() + "-2")) {
                    String cp2String = redisService.get(sq.getId() + "-2");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    regionpointmap.put(sq.getId() + "-2", stringWindpowerstationpointnewMap);
                }
            }
        }

        List<ProBasicEnergyGroup> energyGroups = proBasicEnergyGroupService.list();
        gpls = energyGroups.stream().filter(e -> e.getIsAble() == 1 && e.getId().endsWith("FGS")).collect(Collectors.toList());

        if (!gpls.isEmpty()) {
            for (ProBasicEnergyGroup gp : gpls) {
                gpmap.put(gp.getId(), gp);

                if (redisService.hasKey(gp.getId() + "0")) {
                    String cp0String = redisService.get(gp.getId() + "0");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.getId() + "0", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(gp.getId() + "-1")) {
                    String cp1String = redisService.get(gp.getId() + "-1");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.getId() + "-1", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(gp.getId() + "-2")) {
                    String cp2String = redisService.get(gp.getId() + "-2");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.getId() + "-2", stringWindpowerstationpointnewMap);
                }
            }
        }


        for (ProBasicCompany cp : cpls) {
            if (rgcpmap.containsKey(cp.getRegionId())) {
                rgcpmap.get(cp.getRegionId()).add(cp);
            } else {
                List<ProBasicCompany> wps = new ArrayList<>();
                wps.add(cp);
                rgcpmap.put(cp.getRegionId(), wps);
            }
        }

        for (ProBasicPowerstation wp : wpls) {
            if (cpwpmap.containsKey(wp.getCompanyId())) {
                cpwpmap.get(wp.getCompanyId()).add(wp);
            } else {
                List<ProBasicPowerstation> wps = new ArrayList<>();
                wps.add(wp);
                cpwpmap.put(wp.getCompanyId(), wps);
            }
        }

        QueryWrapper<ProBasicEquipment> queryWtWrapper = new QueryWrapper<>();
        queryWtWrapper.orderByAsc("order_num");
        wtls = proBasicEquipmentService.list(queryWtWrapper).stream().filter(i -> i.getIsable() == 1).collect(Collectors.toList());
        logger.info(wtls.size() + "");
        wtls.forEach(wt -> {
            if (modelMap.containsKey(wt.getModelId())) {
                ProEconEquipmentmodel equipmentmodel = modelMap.get(wt.getModelId());
                modelpower.put(wt.getId(), equipmentmodel.getPowerProduction().doubleValue());
            }


            wtmap.put(wt.getId(), wt);
            //标杆风机初始化
            wtstandardmap.put(wt.getId(), wt.getId());
            String wtString = redisService.get(wt.getId());
            Map<String, ProBasicEquipmentPoint> stringWindturbinetestingpointnewMap = JSONObject.parseObject(wtString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
            });
            wtpAimap.put(wt.getId(), stringWindturbinetestingpointnewMap);


            if (wpwtmap.containsKey(wt.getWindpowerstationId())) {
                wpwtmap.get(wt.getWindpowerstationId()).add(wt);
            } else {
                List<ProBasicEquipment> wps = new ArrayList<>();
                wps.add(wt);
                wpwtmap.put(wt.getWindpowerstationId(), wps);
            }

            if (pjwtmap.containsKey(wt.getProjectId())) {
                pjwtmap.get(wt.getProjectId()).add(wt);
            } else {
                List<ProBasicEquipment> pjs = new ArrayList<>();
                pjs.add(wt);
                pjwtmap.put(wt.getProjectId(), pjs);
            }
            if (lnwtmap.containsKey(wt.getLineId())) {
                lnwtmap.get(wt.getLineId()).add(wt);
            } else {
                List<ProBasicEquipment> lnls = new ArrayList<>();
                lnls.add(wt);
                lnwtmap.put(wt.getLineId(), lnls);
            }
            if (cmwtlsmap.containsKey(wt.getCompanyId())) {
                cmwtlsmap.get(wt.getCompanyId()).add(wt);
            } else {
                List<ProBasicEquipment> cmls = new ArrayList<>();
                cmls.add(wt);
                cmwtlsmap.put(wt.getCompanyId(), cmls);
            }
            if (rgwtlsmap.containsKey(wt.getRegionId())) {
                rgwtlsmap.get(wt.getRegionId()).add(wt);
            } else {
                List<ProBasicEquipment> rgls = new ArrayList<>();
                rgls.add(wt);
                rgwtlsmap.put(wt.getRegionId(), rgls);
            }

            if (sqwtmap.containsKey(wt.getSquareId())) {
                sqwtmap.get(wt.getSquareId()).add(wt);
            } else {
                List<ProBasicEquipment> lnls = new ArrayList<>();
                lnls.add(wt);
                sqwtmap.put(wt.getSquareId(), lnls);
            }

            if (cmwtmap.containsKey(wt.getCompanyId())) {
                cmwtmap.get(wt.getCompanyId()).put(wt.getId(), wt);
            } else {
                Map<String, ProBasicEquipment> map = new HashMap<>();
                map.put(wt.getId(), wt);
                cmwtmap.put(wt.getCompanyId(), map);
            }


            if (subWtsMap.containsKey(wt.getSubstationId())) {
                subWtsMap.get(wt.getSubstationId()).add(wt);
            } else {
                List<ProBasicEquipment> subls = new ArrayList<>();
                subls.add(wt);
                subWtsMap.put(wt.getSubstationId(), subls);
            }

        });

        //初始化标杆风机
        for (ProBasicEquipment wt : wtls) {
            if (wpwtmap.containsKey(wt.getLineId())) {
                List<ProBasicEquipment> wts = wpwtmap.get(wt.getLineId());
                for (ProBasicEquipment w : wts) {
                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
                        wtstandardmap.put(wt.getId(), w.getId());
                        break;
                    }
                }
            }
            if (pjwtmap.containsKey(wt.getLineId())) {
                List<ProBasicEquipment> wts = pjwtmap.get(wt.getLineId());
                for (ProBasicEquipment w : wts) {
                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
                        wtstandardmap.put(wt.getId(), w.getId());
                        break;
                    }
                }
            }
            if (lnwtmap.containsKey(wt.getLineId())) {
                List<ProBasicEquipment> wts = lnwtmap.get(wt.getLineId());
                for (ProBasicEquipment w : wts) {
                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
                        wtstandardmap.put(wt.getId(), w.getId());
                        break;
                    }
                }
            }
        }


        QueryWrapper<ProBasicProject> queryPjWrapper = new QueryWrapper<>();
        queryPjWrapper.orderByAsc("order_num");
        pjls = proBasicProjectService.list(queryPjWrapper).stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        pjls.stream().forEach(p -> {
            pjmap.put(p.getId(), p);
            if (wppromap.containsKey(p.getWindpowerstationId())) {
                wppromap.get(p.getWindpowerstationId()).add(p);
            } else {
                List<ProBasicProject> prolist = new ArrayList<>();
                prolist.add(p);
                wppromap.put(p.getWindpowerstationId(), prolist);
            }
            String pjString = redisService.get(p.getId());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(pjString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            propointmap.put(p.getId(), stringWindpowerstationpointnewMap);

        });
        projmap = pjls.stream().collect(Collectors.groupingBy(ProBasicProject::getWindpowerstationId));
        QueryWrapper<ProBasicSubStation> querySubWrapper = new QueryWrapper<>();
        querySubWrapper.orderByAsc("order_num");
        subwpls = proBasicSubStationService.list(querySubWrapper).stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        subwpls.stream().forEach(sub -> {

            String subString = redisService.get(sub.getId());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            subwppointmap.put(sub.getId(), stringWindpowerstationpointnewMap);

            //            List<ProBasicEquipment> collect = wtls.stream().filter(wt -> wt.getSubstationId().equals(sub.getId())).collect(Collectors.toList());
            //            subWtsMap.put(sub.getId(),collect);

        });

        weawpls = proBasicWeatherStationService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        weawpls.stream().forEach(weather -> {

            String subString = redisService.get(weather.getId());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            weatherwppointmap.put(weather.getId(), stringWindpowerstationpointnewMap);


        });
        //线路
        QueryWrapper<ProBasicLine> queryLnWrapper = new QueryWrapper<>();
        queryLnWrapper.orderByAsc("order_num");
        lnls = proBasicLineService.list(queryLnWrapper).stream().filter(i -> StringUtils.isNotNull(pjmap.get(i.getProjectId())) && i.getIsAble() == 1).collect(Collectors.toList());
        lnls.stream().forEach(l -> {
            lnmap.put(l.getId(), l);
            if (prolinemap.containsKey(l.getProjectId())) {
                prolinemap.get(l.getProjectId()).add(l);
            } else {
                List<ProBasicLine> lineList = new ArrayList<>();
                lineList.add(l);
                prolinemap.put(l.getProjectId(), lineList);
            }
            String lnString = redisService.get(l.getId());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(lnString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            linepointmap.put(l.getId(), stringWindpowerstationpointnewMap);
        });


        zwpls = proBasicWindpowerstationService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        QueryWrapper<ProBasicPowerstation> queryWpWrapper = new QueryWrapper<>();
        queryWpWrapper.orderByAsc("order_num");
        wpls = proBasicWindpowerstationService.list(queryWpWrapper).stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());

        for (ProBasicPowerstation wp : wpls) {
            if (cpwpmap.containsKey(wp.getCompanyId())) {
                cpwpmap.get(wp.getCompanyId()).add(wp);
            } else {
                List<ProBasicPowerstation> wps = new ArrayList<>();
                wps.add(wp);
                cpwpmap.put(wp.getCompanyId(), wps);
            }
        }

        meterpoints = proBasicMeterPointService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        meterpoints.stream().forEach(meterpoint -> {
            meterpointMap.put(meterpoint.getId(), meterpoint);
        });


        wpls.stream().forEach(wp -> {

            wpmap.put(wp.getId(), wp);
            String wpString = redisService.get(wp.getId());
            Map<String, ProBasicPowerstationPoint> stringMapMap = JSONObject.parseObject(wpString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            wppointmap.put(wp.getId(), stringMapMap);
        });

        if (!wpls.isEmpty()) {
            for (ProBasicPowerstation wp : wpls) {
                if (wp.getId().endsWith("FDC_STA")) {
                    wplsf.add(wp);
                }
                //                if (wp.getId().endsWith("GDC_STA")) {
                //                    wplsG.add(wp);
                //                }

                if (wpmapls.containsKey(wp.getId())) {
                    List<ProBasicPowerstation> ls = wpmapls.get(wp.getId());
                    ls.add(wp);
                    wpmapls.put(wp.getId(), ls);
                } else {
                    List<ProBasicPowerstation> ls = new ArrayList<>();
                    ls.add(wp);
                    wpmapls.put(wp.getId(), ls);
                }


                //                if(wp.getWindType().equals(-1) && wp.getWindType().equals(-2)){
                //                    List<ProBasicPowerstation> ls = stationls.get(wp.getWindType());
                //                    stationls.put(wp.getWindType()+QS,ls);
                //                }


                wpmap.put(wp.getId(), wp);
            }
        }


        //        Map<String,ProBasicPowerstationPoint> items=null;
        //        powerpointls = proBasicPowerstationPointService.list().stream().filter(i ->i.getId() != null).collect(Collectors.toList());
        //        if(powerpointls!=null && !powerpointls.isEmpty()){
        //            for(int i=0;i<powerpointls.size();i++){
        //
        //                if(pjmap.containsKey(powerpointls.get(i).getWindpowerstationId()))
        //                {
        //                    ProBasicPowerstationPoint point=powerpointls.get(i);
        //                    if(pjPointmap.containsKey(point.getWindpowerstationId())){
        //                        items=pjPointmap.get(point.getWindpowerstationId());
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                    else{
        //                        items=new HashMap<String,ProBasicPowerstationPoint>();
        //                        pjPointmap.put(point.getWindpowerstationId(), items);
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                }else if(lnmap.containsKey(powerpointls.get(i).getWindpowerstationId()))
        //                {
        //                    ProBasicPowerstationPoint point=powerpointls.get(i);
        //                    if(lnPointmap.containsKey(point.getWindpowerstationId())){
        //                        items=lnPointmap.get(point.getWindpowerstationId());
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                    else{
        //                        items=new HashMap<String,ProBasicPowerstationPoint>();
        //                        lnPointmap.put(point.getWindpowerstationId(), items);
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                }else
        //                {
        //                    ProBasicPowerstationPoint point = powerpointls.get(i);
        //                    if(pointwpmap.containsKey(point.getWindpowerstationId())){
        //                        items=pointwpmap.get(point.getWindpowerstationId());
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                    else{
        //                        items=new HashMap<String,ProBasicPowerstationPoint>();
        //                        pointwpmap.put(point.getWindpowerstationId(), items);
        //                        items.put(point.getUniformCode(), point);
        //                    }
        //                }
        //            }
        //        }

        stations = windpowerstationService.list();
        for (ProBasicPowerstation station : stations) {
            wppmap.put(station.getId(), station.getName());
            wpmaps.put(station.getId(), station);
        }

        for (ProBasicMeterPoint meterpoint2 : meterpoint2Service.list()) {
            if (wpmaps.containsKey(meterpoint2.getWindpowerstationId())) {
                meterMap.put(meterpoint2.getNemCode(), meterpoint2);
                if (wpmeterMap.containsKey(meterpoint2.getWindpowerstationId())) {
                    wpmeterMap.get(meterpoint2.getWindpowerstationId()).add(meterpoint2);
                } else {
                    List<ProBasicMeterPoint> list = new ArrayList<>();
                    list.add(meterpoint2);
                    wpmeterMap.put(meterpoint2.getWindpowerstationId(), list);
                }
            }

        }

        for (ProBasicMeterPoint meterpoint2 : meterpoint2Service.list()) {
            if (wpmaps.containsKey(meterpoint2.getWindpowerstationId())) {
                meterMap.put(meterpoint2.getId(), meterpoint2);
                if (wpmeterMap.containsKey(meterpoint2.getWindpowerstationId())) {
                    wpmeterMap.get(meterpoint2.getWindpowerstationId()).add(meterpoint2);
                } else {
                    List<ProBasicMeterPoint> list = new ArrayList<>();
                    list.add(meterpoint2);
                    wpmeterMap.put(meterpoint2.getWindpowerstationId(), list);
                }
            }

        }

        String llglString = redisService.get("ZLLGL");
        theoreticalPowerMap = JSONObject.parseObject(llglString, new TypeReference<Map<String, Map<Double, ProBasicModelPowerRd>>>() {
        });

        llglString = redisService.get("ZLLGLLS");
        theoreticalPowerList = JSONObject.parseObject(llglString, new TypeReference<List<ProBasicModelPowerRd>>() {
        });

        String sszzt = redisService.get("SSZZT");
        statusMap = JSONObject.parseObject(sszzt, new TypeReference<Map<String, List<ProBasicStatusPoint>>>() {
        });

        cacheNewModelPower();
        cacheNewPoints();
        cacheAGC();
        initTemperatureInfo();

        logger.info("缓存结束------------------------------------------------------------");
    }


    private void cacheNewModelPower() {
        List<ProBasicModelPower> lsMPD = proBasicModelPowerService.list();
        modelPowerDetailNewMap.putAll(lsMPD.stream().collect(Collectors.groupingBy(u -> u.getModelId())));
        System.out.println("保证功率数据缓存完成");
    }

    private void cacheNewPoints() {
        List<ProBasicEquipmentPoint> list = new ArrayList<>();
        wpls.stream().forEach(d -> list.addAll(proBasicEquipmentPointService.selectList(d.getId(), config.getPoints())));
        pointNewMap.putAll(list.stream().collect(Collectors.groupingBy(u -> u.getWindturbineId())));
    }

    private void cacheAGC() {

        AgcDeviateConfig[] adcs = fileService.getFromFile(config.getFilePathPower() + "agc_info_net.json", AgcDeviateConfig[].class);
        initFiles();
        for (AgcDeviateConfig adc : adcs) {
            agcDeviateConfigMap.put(adc.getId(), adc);
        }
    }

    private void initFiles() {
        files = new HashMap<>();
        File f = new File(config.getFilePathPower());
        File[] fs = f.listFiles();
        for (File v : fs) {
            if (v.isDirectory()) {
                continue;
            }
            String[] nm = v.getName().split(",");
            if (nm.length < 1) {
                continue;
            }
            String name = nm[0];
            if (!files.containsKey(name)) {
                files.put(name, new ArrayList<>());
            }
            files.get(name).add(v.getPath());
        }
    }

    private void initTemperatureInfo() {
        Map<String, TemperatureInfo> tis = new HashMap<>();
        try {
            List<Temperatureinfo> ls = iTemperatureinfoService.list();
            for (Temperatureinfo ti : ls) {
                if (ti == null || ti.getWindturbineid() == null || "".equals(ti.getWindturbineid())) {
                    continue;
                }
                if (!tis.containsKey(ti.getWindturbineid())) {
                    TemperatureInfo nti = new TemperatureInfo();
                    if (tis.containsKey(ti.getWindpowerstationid())) {
                        nti.setStationName(tis.get(ti.getWindpowerstationid()).getStationName());
                    }
                    nti.setWindturbineId(ti.getWindturbineid());
                    nti.setStationId(ti.getWindpowerstationid());
                    if (wtmap.containsKey(ti.getWindturbineid())) {
                        nti.setWindturbineInfo(wtmap.get(ti.getWindturbineid()));
                        nti.setCode(wtmap.get(ti.getWindturbineid()).getNemCode());
                    }
                    tis.put(nti.getWindturbineId(), nti);
                }
                tis.get(ti.getWindturbineid()).addTemperaturePoint(ti);
            }
            for (TemperatureInfo ti : tis.values()) {
                List<TemperatureComponentInfo> temperatureComponentInfos = ti.getTemperatureComponentInfos();
                if (temperatureComponentInfos != null) {
                    Comparator<TemperatureComponentInfo> comparator = (info1, info2) -> {
                        int index1 = order.indexOf(info1.getName());
                        int index2 = order.indexOf(info2.getName());
                        return Integer.compare(index1, index2);
                    };
                   temperatureComponentInfos.sort(comparator);
                }

            }
            temperatureInfos = new ArrayList<>(tis.values());
            temperatureInfos.sort((x, y) -> {
                if (x.getStationId().equals(y.getStationId())) {
                    return Integer.parseInt(x.getCode()) - Integer.parseInt(y.getCode());
                }
                return x.getStationId().compareTo(y.getStationId());
            });
        } catch (Exception e) {
            System.out.println("温度矩阵数据初始化失败" + e.toString());
        }
    }

}
