package com.gyee.generation.init;


import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.gyee.generation.model.auto.*;
import com.gyee.generation.service.auto.*;

import com.gyee.generation.util.redis.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

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

/**
 * @description: 初始化类缓存数据
 * @author: shilin
 * @date: 2024/5/29 9:18
 * @param:
 * @return:
 **/
@Component
public class CacheContext implements CommandLineRunner {
    Logger logger = LoggerFactory.getLogger(CacheContext.class);

    @Resource
    private IProBasicEquipmentService proBasicEquipmentService;
    @Resource
    private IProBasicLineService proBasicLineService;
    @Resource
    private IProBasicProjectService proBasicProjectService;
    @Resource
    private IProBasicPowerstationService proBasicWindpowerstationService;
    @Resource
    private IProEconEquipmentmodelService proEconEquipmentmodelService;
    @Resource
    private IProBasicMeterPointService proBasicMeterPointService;
    @Resource
    private RedisService redisService;
    @Resource
    private IProBasicStatusAiService proBasicStatusAiService;
    @Resource
    private IProBasicStatusDiService proBasicStatusDiService;
    @Resource
    private IProBasicSubStationService proBasicSubStationService;
    @Resource
    private IProBasicSquareService proBasicSquareService;
    @Resource
    private IProBasicCompanyService proBasicCompanyService;
    @Resource
    private IProBasicRegionService proBasicRegionService;

    @Resource
    private IProBasicWeatherStationService proBasicWeatherStationService;

    @Resource
    private IProBasicEnergyGroupService proBasicEnergyGroupService;

    @Value("${runWindpowerstation}")
    private String runWindpowerstation;


    public static List<ProBasicEnergyGroup> egls = new ArrayList<>();
    public static List<ProBasicRegion> rgls = new ArrayList<>();
    public static List<ProBasicCompany> cpls = new ArrayList<>();
    public static List<ProBasicPowerstation> wpls = new ArrayList<>();
    public static List<ProBasicSubStation> subwpls = new ArrayList<>();
    public static List<ProBasicWeatherStation> wsls = new ArrayList<>();
    public static List<ProBasicSquare> sqls = new ArrayList<>();
    public static List<ProBasicProject> pjls = new ArrayList<>();
    public static List<ProBasicLine> lnls = new ArrayList<>();


    public static List<ProBasicEquipment> wtls = new ArrayList<>();
    public static List<ProBasicEquipment> wtfdls = new ArrayList<>();
    public static List<ProBasicEquipment> wtgfls = new ArrayList<>();
    public static List<ProBasicEquipment> wt_fjls = new ArrayList<>();
    public static List<ProBasicMeterPoint> meterpoints = new ArrayList<>();

    public static List<ProEconEquipmentmodel> models=new ArrayList<>();
    public static Map<String, ProBasicEnergyGroup> egmap = new HashMap<>();
    public static Map<String, ProBasicRegion> rgmap = new HashMap<>();
    public static Map<String, ProBasicCompany> cpmap = new HashMap<>();
    public static Map<String, ProBasicPowerstation> wpmap = new HashMap<>();
    public static Map<String, ProBasicProject> pjmap = new HashMap<>();
    public static Map<String, ProBasicLine> lnmap = new HashMap<>();
    public static Map<String, ProBasicSquare> sqmap = new HashMap<>();

    public static Map<String, ProBasicEquipment> eqmap = new HashMap<>();
    public static Map<String, ProBasicMeterPoint> meterMap = new HashMap<>();
    public static Map<String, ProEconEquipmentmodel> modelMap = new HashMap<>();
    public static Map<String, String> wtstandardmap = new HashMap<>();
    public static Map<String, List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
    public static Map<String, List<ProBasicCompany>> rgcpmap = new HashMap<>();

    public static Map<String, List<ProBasicMeterPoint>> wpmeterMap = new HashMap<>();

    public static Map<String, List<ProBasicWeatherStation>> poWsStationMap = new HashMap<>();

    public static Map<String, List<ProBasicProject>> wppromap = 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>> sqwtmap = new HashMap<>();

    public static Map<String, Map<String, ProBasicEquipmentPoint>> eqpointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> linepointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> propointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> wppointmap = new HashMap<>();
    public static Map<String, Map<String, ProBasicPowerstationPoint>> subwppointmap = new HashMap<>();

    public static Map<String, Map<String, ProBasicPowerstationPoint>> wswppointmap = 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<String, ProBasicStatusDi>> pointdismap = new HashMap<>();
    public static Map<String, Map<Integer, Integer>> aistateMap = new HashMap<>();
    public static Map<String, List<ProBasicEquipment>> subWtsMap = new HashMap<>();


    public static Map<String, Integer> redisDbMap = new HashMap<>();

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


        List<String> runWpids = Arrays.asList(runWindpowerstation.split(","));
        logger.info(runWpids.get(0) + "------------------" + runWpids.size());


        sqls = proBasicSquareService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        if (!sqls.isEmpty()) {
            for (ProBasicSquare sq : sqls) {
                sqmap.put(sq.getNemCode(), sq);
            }
        }

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

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

            }

        }


        rgls = proBasicRegionService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
        if (!rgls.isEmpty()) {
            for (ProBasicRegion sq : rgls) {
                rgmap.put(sq.getNemCode(), sq);

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

        egls = proBasicEnergyGroupService.list().stream().filter(i -> i.getIsAble() == 1 && !i.getParentId().equals("0")).collect(Collectors.toList());
        if (!egls.isEmpty()) {
            for (ProBasicEnergyGroup sq : egls) {
                egmap.put(sq.getNemCode(), sq);

                if (redisService.hasKey(sq.getNemCode() + "0")) {
                    String eg0String = redisService.get(sq.getNemCode() + "0");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(sq.getNemCode() + "0", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getNemCode() + "-1")) {
                    String eg1String = redisService.get(sq.getNemCode() + "-1");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(sq.getNemCode() + "-1", stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(sq.getNemCode() + "-2")) {
                    String eg2String = redisService.get(sq.getNemCode() + "-2");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(sq.getNemCode() + "-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);
            }
        }

        wpls = proBasicWindpowerstationService.list();
        for (ProBasicPowerstation station : wpls) {
            wpmap.put(station.getNemCode(), station);
        }

        wsls.stream().forEach(p -> {


            String wsString = redisService.get(p.getNemCode());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(wsString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            wswppointmap.put(p.getNemCode(), stringWindpowerstationpointnewMap);

        });

        wtls = proBasicEquipmentService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsable() == 1).collect(Collectors.toList());

        logger.info(wtls.size() + "");
        wtls.forEach(wt -> {

            if (wt.getNemCode().contains("_G_")) {
                wtgfls.add(wt);
            } else if (wt.getNemCode().contains("_F_")) {
                wtfdls.add(wt);
            }


            if (wt.getNemCode().contains("_F_")) {
                wt_fjls.add(wt);
            }

            eqmap.put(wt.getNemCode(), wt);

            String wtString = redisService.get(wt.getNemCode());
            Map<String, ProBasicEquipmentPoint> stringWindturbinetestingpointnewMap = JSONObject.parseObject(wtString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
            });
            eqpointmap.put(wt.getNemCode(), 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 (sqwtmap.containsKey(wt.getSquareId())) {
                sqwtmap.get(wt.getSquareId()).add(wt);
            } else {
                List<ProBasicEquipment> lnls = new ArrayList<>();
                lnls.add(wt);
                sqwtmap.put(wt.getSquareId(), lnls);
            }
        });


        //初始化标杆风机
        for (ProBasicEquipment wt : wtls) {
            if (wpwtmap.containsKey(wt.getWindpowerstationId())) {
                List<ProBasicEquipment> wts = wpwtmap.get(wt.getWindpowerstationId());
                for (ProBasicEquipment w : wts) {
                    wtstandardmap.put(wt.getNemCode(), w.getNemCode());
                    break;
                }
            }

        }


        pjls = proBasicProjectService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        pjls.stream().forEach(p -> {
            pjmap.put(p.getNemCode(), 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.getNemCode());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(pjString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            propointmap.put(p.getNemCode(), stringWindpowerstationpointnewMap);

        });

        subwpls = proBasicSubStationService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        subwpls.stream().forEach(sub -> {

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

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

        });


        wsls = proBasicWeatherStationService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        if (!wsls.isEmpty()) {

            for (ProBasicWeatherStation ws : wsls) {
                if (poWsStationMap.containsKey(ws.getWindpowerstationId())) {
                    List<ProBasicWeatherStation> ls = poWsStationMap.get(ws.getWindpowerstationId());
                    ls.add(ws);
                    poWsStationMap.put(ws.getWindpowerstationId(), ls);

                } else {
                    List<ProBasicWeatherStation> ls = new ArrayList<>();
                    ls.add(ws);
                    poWsStationMap.put(ws.getWindpowerstationId(), ls);
                }
            }
        }
        wsls.stream().forEach(weather -> {

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


        });


        lnls = proBasicLineService.list().stream().filter(i -> ObjectUtil.isNotEmpty(pjmap.get(i.getProjectId())) && runWpids.contains(pjmap.get(i.getProjectId()).getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        lnls.stream().forEach(l -> {
            lnmap.put(l.getNemCode(), 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.getNemCode());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(lnString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            linepointmap.put(l.getNemCode(), stringWindpowerstationpointnewMap);
        });


        wpls = proBasicWindpowerstationService.list().stream().filter(i -> runWpids.contains(i.getNemCode()) && i.getIsAble() == 1).collect(Collectors.toList());
        ;
        meterpoints = proBasicMeterPointService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
        meterpoints.stream().forEach(meterpoint -> {
            meterMap.put(meterpoint.getNemCode(), meterpoint);
        });


        for (ProBasicMeterPoint meterpoint2 : meterpoints) {
            if (wpmap.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 : proBasicMeterPointService.list()) {
            if (wpmap.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);
                }
            }

        }


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

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


        for (int i = 0; i < 9; i++) {
            Set<String> keys = redisService.keys(i);

            for (String key : keys) {
                redisDbMap.put(key, i);
            }
        }

        List<ProBasicStatusDi> statusdis = proBasicStatusDiService.list();

        Map<String, ProBasicStatusDi> items = null;
        if (statusdis != null && !statusdis.isEmpty()) {
            for (int i = 0; i < statusdis.size(); i++) {

                ProBasicStatusDi point = statusdis.get(i);
                if (pointdismap.containsKey(point.getWindturbineId())) {
                    items = pointdismap.get(point.getWindturbineId());
                    items.put(point.getUniformCode(), point);
                } else {
                    items = new HashMap<>();
                    pointdismap.put(point.getWindturbineId(), items);
                    items.put(point.getUniformCode(), point);
                }

            }
        }

        List<ProBasicStatusAi> statusais = proBasicStatusAiService.list();

        statusais.stream().forEach(ai -> {
            if (aistateMap.containsKey(ai.getModelId())) {
                aistateMap.get(ai.getModelId()).put(ai.getOriginalState(), ai.getMappingState());
            } else {
                Map<Integer, Integer> stateMap = new HashMap<>();
                stateMap.put(ai.getOriginalState(), ai.getMappingState());
                aistateMap.put(ai.getModelId(), stateMap);
            }
        });

        models = proEconEquipmentmodelService.list();
        models.stream().forEach(e->{
            modelMap.put(e.getNemCode(),e);
        });

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


}
