cdss-core/src/main/java/com/diagbot/facade/NeoFacade.java

package com.diagbot.facade;

import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.diagbot.client.StandConvertServiceClient;
import com.diagbot.dto.BaseDiagnoseDTO;
import com.diagbot.dto.BaseRegulationDTO;
import com.diagbot.dto.DrugNameDTO;
import com.diagbot.dto.DrugTypeCacheDTO;
import com.diagbot.dto.DrugTypeDTO;
import com.diagbot.dto.NeoPushDTO;
import com.diagbot.dto.RuleDTO;
import com.diagbot.entity.KlDiseaseCorresponding;
import com.diagbot.entity.SymptomFeature;
import com.diagbot.entity.TranHospitalFilter;
import com.diagbot.enums.IsDeleteEnum;
import com.diagbot.enums.PushRelationTypeEnum;
import com.diagbot.enums.RedisEnum;
import com.diagbot.exception.CommonErrorCode;
import com.diagbot.exception.CommonException;
import com.diagbot.model.entity.PD;
import com.diagbot.service.KlDiseaseCorrespondingService;
import com.diagbot.service.SymptomFeatureService;
import com.diagbot.service.TranHospitalFilterService;
import com.diagbot.util.ListUtil;
import com.diagbot.util.NeoUtil;
import com.diagbot.util.RedisUtil;
import com.diagbot.util.StringUtil;
import com.diagbot.vo.DiseaseItemVO;
import com.diagbot.vo.NeoPushVO;
import com.diagbot.vo.neoPushEntity.ChiefPushVo;
import com.diagbot.vo.neoPushEntity.Diag;
import com.diagbot.vo.neoPushEntity.PresentPushVo;
import com.diagbot.vo.neoPushEntity.Symptom;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import io.github.lvyahui8.spring.facade.DataFacade;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.MapUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import static com.diagbot.util.StringUtil.permutationNoRepeat;

/**
 * @Description: 缓存等相关装饰层
 * @author: Mark
 * @time: 2018/8/6 9:11
 */
@Component
@Slf4j
public class NeoFacade {
    @Autowired
    NeoFacade self;
    @Autowired
    StandConvertServiceClient standConvertServiceClient;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    SymptomFeatureService symptomFeatureService;
    @Autowired
    KlDiseaseCorrespondingService klDiseaseCorrespondingService;
    @Autowired
    TranHospitalFilterService tranHospitalFilterService;
    @Autowired
    private KlRuleFacade klRuleFacade;
    @Autowired
    private KlRelationFacade klRelationFacade;
    @Autowired
    private KlDiagnoseBaseFacade klDiagnoseBaseFacade;
    @Autowired
    private KlRegulationBaseFacade klRegulationBaseFacade;

    /**
     * 返回药品缓存信息
     *
     * @return
     */
    public void getDrugCache() {
        List<DrugTypeDTO> list = klRelationFacade.getDrugType();
        List<DrugTypeCacheDTO> cacheDTOList = new ArrayList<>();
        for (DrugTypeDTO drugTypeDTO : list) {
            DrugTypeCacheDTO drugTypeCacheDTO = new DrugTypeCacheDTO();
            drugTypeCacheDTO.setDrugType(drugTypeDTO.getDrugType());
            drugTypeCacheDTO.setDrugs(drugTypeDTO.getDrugs().stream().map(DrugNameDTO::getDrug).collect(Collectors.toList()));
            cacheDTOList.add(drugTypeCacheDTO);
        }
        Map redisMap = cacheDTOList.stream().collect(
                Collectors.toMap(k -> RedisEnum.drugType.getName() + k.getDrugType(),
                        v -> v.getDrugs(), (v1, v2) -> (v2)));
        if (redisMap != null && redisMap.size() > 0) {
            redisUtil.multiSet(redisMap);
        }
    }


    public void diseaseCorrespondCache() {
        List<KlDiseaseCorresponding> symptomFeatures = klDiseaseCorrespondingService.list(null);
        if (ListUtil.isNotEmpty(symptomFeatures)) {
            Map map = symptomFeatures.stream().collect(Collectors.toMap(
                    k -> RedisEnum.diseaseCorrespond.getName() + k.getDiagPingan(),
                    v -> {
                        Map<String, Object> desc = new HashMap<>();
                        desc.put("diag_icd", v.getDiagIcd());
                        desc.put("sign", v.getHighRiskSign());
                        return desc;
                    },
                    (v1, v2) -> (v2)
            ));
            redisUtil.multiSet(map);
        }
    }

    public void diseaseFilterCache() {
        Map<String, Map> data = new HashMap<>();
        QueryWrapper<TranHospitalFilter> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("is_deleted", IsDeleteEnum.N.getKey());
        List<TranHospitalFilter> tranHospitalFilters = tranHospitalFilterService.list(queryWrapper);
        if (ListUtil.isNotEmpty(tranHospitalFilters)) {
            Map<Long, List<TranHospitalFilter>> longListMap = tranHospitalFilters.stream().collect(Collectors.groupingBy(TranHospitalFilter::getHospitalId));
            longListMap.forEach((x, y) -> {
                Map<String, Long> collect = y.stream().collect(Collectors.toMap(TranHospitalFilter::getUniqueName, TranHospitalFilter::getDocNum, (existing, replacement) -> replacement));
                data.put(RedisEnum.diseaseFilter.getName() + x.toString(), collect);
            });
            redisUtil.multiSet(data);
        }
    }

    public void symptomFeatureCache() {
        List<SymptomFeature> symptomFeatures = symptomFeatureService.list(null);
        if (ListUtil.isNotEmpty(symptomFeatures)) {
            Map map = symptomFeatures.stream().collect(Collectors.toMap(
                    k -> RedisEnum.symptomFeature.getName() + k.getMinCombineElement(),
                    v -> {
                        Map<String, String> desc = new HashMap<>();
                        desc.put("minCombineElement", v.getMinCombineElement());
                        desc.put("bodyPart", v.getBodyPart());
                        desc.put("change", v.getVariety());
                        desc.put("color", v.getColor());
                        desc.put("degree", v.getDegree());
                        desc.put("frequency", v.getFrequency());
                        desc.put("position", v.getPosition());
                        desc.put("radiationSituation", v.getRadiationSituation());
                        desc.put("shapePropety", v.getShapePropety());
                        return desc;
                    },
                    (v1, v2) -> (v2)
            ));
            redisUtil.multiSet(map);
        }
    }

    /**
     * 图谱反推的数据
     *
     * @param pushVO
     * @return
     */
    public NeoPushDTO getReversePush(NeoPushVO pushVO) {
        NeoPushDTO neoPushDTO = new NeoPushDTO();
        // 如果有诊断名称，则通过诊断反推
        if (null != pushVO.getDiagVo() && pushVO.getDiagVo().getDiags().size() > 0) {
            neoPushDTO = getDiagInfo(pushVO);
        }

        return neoPushDTO;
    }

    private List<String> getDiseaseByChief(NeoPushVO pushVO) {
        List<String> chiefDiags = Lists.newArrayList();
        ChiefPushVo chiefPushVo = pushVO.getChiefPushVo();
        if (chiefPushVo != null) {
            List<Diag> diags = chiefPushVo.getDiags();
            if (ListUtil.isNotEmpty(diags)) {
                chiefDiags = diags.stream().map(x -> x.getName()).collect(Collectors.toList());
            }
        }
        return chiefDiags;
    }

    private List<String> getDisByPresent(NeoPushVO pushVO) {
        List<String> presentDiags = Lists.newArrayList();
        PresentPushVo presentPushVo = pushVO.getPresentPushVo();
        if (presentPushVo != null) {
            List<Diag> diags = presentPushVo.getDiags();
            if (ListUtil.isNotEmpty(diags)) {
                presentDiags = diags.stream().map(x -> x.getName()).collect(Collectors.toList());
            }
        }
        return presentDiags;
    }

    private List<String> getDisByDiag(NeoPushVO pushVO) {
        List<String> diags = Lists.newArrayList();
        if (pushVO.getDiagVo() != null && ListUtil.isNotEmpty(pushVO.getDiagVo().getDiags())) {
            diags = pushVO.getDiagVo().getDiags().stream().map(x -> x.getName()).collect(Collectors.toList());
        }
        return diags;
    }

    /**
     * 把现病史中的诊断添加到推送诊断中
     *
     * @param lis_dis
     * @param presentDiags
     */
    public List<String> addDiagFromPresent(List<String> lis_dis, List<String> presentDiags) {
        List<String> lis_dis_new = Lists.newArrayList();
        if (ListUtil.isNotEmpty(lis_dis) && ListUtil.isNotEmpty(presentDiags)) {
            //            if (lis_dis.size() >= 10) {
            if (lis_dis.size() >= 1) {
                for (int i = 0; i < lis_dis.size(); i++) {
                    //                    if (i == 10 - presentDiags.size()) {
                    if (i == 1) {
                        for (String dis : presentDiags) {
                            if (!lis_dis_new.contains(dis)) {
                                lis_dis_new.add(dis);
                            }
                        }
                        lis_dis_new.add(lis_dis.get(i));
                    } else {
                        lis_dis_new.add(lis_dis.get(i));
                    }
                }
            } else {
                lis_dis_new.addAll(lis_dis);
                lis_dis_new.addAll(presentDiags);
            }
            lis_dis_new = lis_dis_new.stream().distinct().collect(Collectors.toList());
        } else {
            lis_dis.addAll(presentDiags);
            lis_dis_new = lis_dis;
        }
        return lis_dis_new;
    }

    private Map<Integer, List<String>> splitSymptom(String s_m, List<String> redis_key) {
        List<String> filter_keys = redis_key.stream().filter(x -> s_m.contains(x)).collect(Collectors.toList());
        List<Map<String, String>> redisDatas = redisUtil.getSf(filter_keys, RedisEnum.symptomFeature.getName());
        Map<String, List<String>> min_filds = Maps.newHashMap();
        if (ListUtil.isNotEmpty(redisDatas)) {
            redisDatas.forEach(x -> {
                List<String> datas = Lists.newArrayList();
                String minCombineElement = x.get("minCombineElement");
                String radiationSituation = x.get("radiationSituation");
                String color = x.get("color");
                String change = x.get("change");
                String degree = x.get("degree");
                String shapePropety = x.get("shapePropety");
                String position = x.get("position");
                String bodyPart = x.get("bodyPart");
                String frequency = x.get("frequency");
                searchWord(radiationSituation, s_m, "、", datas);
                searchWord(color, s_m, "、", datas);
                searchWord(change, s_m, "、", datas);
                searchWord(degree, s_m, "、", datas);
                searchWord(shapePropety, s_m, "、", datas);
                searchWord(position, s_m, "、", datas);
                searchWord(bodyPart, s_m, "、", datas);
                searchWord(frequency, s_m, "、", datas);
                min_filds.put(minCombineElement, datas);
            });
        }
        Map<Integer, List<String>> fild_pailie = Maps.newHashMap();
        if (MapUtils.isNotEmpty(min_filds)) {
            min_filds.forEach((k, v) -> {
                v.add(k);
                for (int i = v.size(); i > 0; i--) {
                    List<String> datad = permutationNoRepeat(v, i);
                    if (fild_pailie.containsKey(i)) {
                        List<String> strings = fild_pailie.get(i);
                        datad.removeAll(strings);
                        strings.addAll(datad);
                        fild_pailie.put(i, strings);
                    } else {
                        fild_pailie.put(i, datad);
                    }
                }
            });
        }
        return fild_pailie;
    }

    public void searchWord(String color, String regionWord, String patternFild, List<String> datas) {
        if (StringUtil.isNotEmpty(color)) {
            String[] splitsData = color.split(patternFild);
            for (String fils : splitsData) {
                if (regionWord.contains(fils)) {
                    datas.add(fils);
                }
            }
        }
    }

    public List<String> getSymptoms(NeoPushVO pushVO) {
        List<String> symptom_chief = Lists.newArrayList();
        List<String> symptom_present = Lists.newArrayList();
        ChiefPushVo chiefPushVo = pushVO.getChiefPushVo();
        PresentPushVo presentPushVo = pushVO.getPresentPushVo();
        if (chiefPushVo != null) {
            List<Symptom> symptoms = chiefPushVo.getSymptoms();
            if (ListUtil.isNotEmpty(symptoms)) {
                symptom_chief = symptoms.stream().map(x -> x.getName()).collect(Collectors.toList());
            }
        }
        if (presentPushVo != null) {
            List<Symptom> symptoms = presentPushVo.getSymptoms();
            if (ListUtil.isNotEmpty(symptoms)) {
                symptom_present = symptoms.stream().map(x -> x.getName()).collect(Collectors.toList());
            }
        }
        symptom_present.removeAll(symptom_chief);
        symptom_chief.addAll(symptom_present);
        return symptom_chief;
    }


    public void filterAndSort(List<String> dises, List<String> allDis, int gender_code, double age, PD pd, List<String> depts) {
        //推送出的所有疾病进行性别和年龄的过滤
        List<Map<String, String>> diseases = null;
        Map<String, Double> dis_fbl = new HashMap<>();

        if (ListUtil.isNotEmpty(allDis)) {
            diseases = redisUtil.geth(allDis);
            allDis = diseases.stream().filter(x -> NeoUtil.matchBasic(x, gender_code, age) && NeoUtil.matchPds(x.get("name"), pd)
                    && NeoUtil.matchDept(x, depts)).map(x -> x.get("name")).collect(Collectors.toList());
            diseases.forEach(x -> {
                String name = x.get("name");
                double clafy = Double.parseDouble(x.get("clafy"));
                dis_fbl.put(name, clafy);
            });
        }

        Map<Long, List<String>> numberDiseasesMap = disCountSort(allDis);

        //根据发病率排序
        //        Map<String, Double> disdistributionCache = self.getDisdistributionCache();
        Map<Long, Map<String, Double>> disPack = new LinkedHashMap<>();
        numberDiseasesMap.forEach((x, y) -> {
            Map<String, Double> collect = y.stream()
                    .collect(Collectors.toMap(v -> v, v -> dis_fbl.get(v), (e1, e2) -> e2));
            disPack.put(x, collect);
        });
        disPack.forEach((x, y) -> {
            //倒序排序
            //            Map<String, Double> collect = y.entrySet().stream()
            //                    .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
            //                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
            //正序排序
            Map<String, Double> collect = y.entrySet().stream()
                    .sorted(Map.Entry.comparingByValue())
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e2, LinkedHashMap::new));
            disPack.put(x, collect);
            collect.forEach((k, n) -> {
                dises.add(k);
            });
        });
    }


    /**
     * 推送的疾病计数排序
     *
     * @param allDis
     * @return
     */
    public Map<Long, List<String>> disCountSort(List<String> allDis) {
        Map<String, Long> dis_count = allDis.stream().collect(

                Collectors.groupingBy(Function.identity(), Collectors.counting())
        );
        if (dis_count != null && dis_count.size() > 0) {
            dis_count = dis_count.entrySet().stream().sorted((o1, o2) -> o2.getValue().compareTo(o1.getValue()))
                    .map(entry -> {
                        Map<String, Long> result = new LinkedHashMap();
                        result.put(entry.getKey(), entry.getValue());
                        return result;
                    }).reduce((map1, map2) -> {
                        map2.entrySet().forEach(entry -> map1.put(entry.getKey(), entry.getValue()));
                        return map1;
                    }).get();

        }
        Map<Long, List<String>> number_diseases = new LinkedHashMap<>();
        dis_count.forEach((x, y) -> {
            if (number_diseases.containsKey(y)) {
                List<String> diseases = number_diseases.get(y);
                diseases.add(x);
                number_diseases.put(y, diseases);
            } else {
                List<String> diseases = Lists.newArrayList();
                diseases.add(x);
                number_diseases.put(y, diseases);
            }
        });
        return number_diseases;
    }

    /**
     * 反推信息
     *
     * @param dis
     * @return
     */
    public NeoPushDTO reverseInfoMySql(String dis, NeoPushVO neoPushVO) {
        NeoPushDTO neoPushDTO = new NeoPushDTO();
        //查询疾病相关的项目
        DiseaseItemVO diseaseItemVO = new DiseaseItemVO();
        diseaseItemVO.setDiseaseName(dis);
        diseaseItemVO.setAge(neoPushVO.getAgeNum());
        diseaseItemVO.setSexType(neoPushVO.getSex());
        Map<Long, List<String>> items = klRelationFacade.getItemByDiseaseMap(diseaseItemVO);
        if (MapUtils.isNotEmpty(items)) {
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.SYMPTOMMAIN.getKey()))) {
                neoPushDTO.setSymptoms(items.get(PushRelationTypeEnum.SYMPTOMMAIN.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.VITAL.getKey()))) {
                neoPushDTO.setVitals(items.get(PushRelationTypeEnum.VITAL.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.LIS.getKey()))) {
                neoPushDTO.setLis(items.get(PushRelationTypeEnum.LIS.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.PACS.getKey()))) {
                neoPushDTO.setPacs(items.get(PushRelationTypeEnum.PACS.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.DIFFDIAGNOSE.getKey()))) {
                neoPushDTO.setDifferentialDis(items.get(PushRelationTypeEnum.DIFFDIAGNOSE.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
            if (ListUtil.isNotEmpty(items.get(PushRelationTypeEnum.SCALE.getKey()))) {
                neoPushDTO.setScales(items.get(PushRelationTypeEnum.SCALE.getKey())
                        .stream().map(x -> NeoUtil.updatePushInfo(x)).collect(Collectors.toList()));
            }
        }
        return neoPushDTO;
    }

    /**
     * 推送疾病信息
     *
     * @param neoPushVO
     * @return
     */
    public NeoPushDTO getDiagInfo(NeoPushVO neoPushVO) {
        NeoPushDTO pushDTO = new NeoPushDTO();
        String term = neoPushVO.getDiagVo().getDiags().get(0).getName();
        pushDTO = this.reverseInfoMySql(term, neoPushVO);

        return pushDTO;
    }

    /**
     * 提取方法
     *
     * @param jsonArray
     * @param originName
     * @param map
     */
    public void putMap(JSONArray jsonArray, String originName, Map<String, String> map) {
        if (jsonArray.size() == 2) {
            double likeRate = jsonArray.getDoubleValue(1);
            // System.out.println(originName + " " + likeRate);
            if (likeRate > 0.9) {
                String standName = jsonArray.getString(0);
                map.put(originName, standName);
            } else {
                map.put(originName, originName);
            }
        }
    }

    public void allRuleCache() {
//        List<RuleDTO> ruleDTOList = klRuleFacade.getAllRule();
//        if (ListUtil.isNotEmpty(ruleDTOList)) {
//            Map map = ruleDTOList.stream().collect(Collectors.toMap(
//                    k -> RedisEnum.allRule.getName() + k.getLibType() + "_" + k.getLibName() + "_" + k.getRuleType(),
//                    v -> v,
//                    (v1, v2) -> (v2)
//            ));
//            redisTemplate.opsForValue().multiSet(map);
//        }
        try {
            Map<String, Object> invokeParams = new HashMap<>();
            Map<String, RuleDTO> map = DataFacade.get("getAllRules", invokeParams, Map.class);
            redisUtil.multiSet(map);
        } catch (Exception e) {
            throw new CommonException(CommonErrorCode.SERVER_IS_ERROR, "获取所有规则失败" + e.getMessage());
        }
    }

    public void allBaseDiagnose() {
        List<BaseDiagnoseDTO> list = klDiagnoseBaseFacade.getAllBaseDiagnose();
        if (ListUtil.isNotEmpty(list)) {
            redisUtil.set(RedisEnum.allBaseDiagnose.getName(), list);
        }
    }

    public void allBaseRegulation() {
        List<BaseRegulationDTO> list = klRegulationBaseFacade.getSelectBase(new ArrayList<>());
        if (ListUtil.isNotEmpty(list)) {
            redisUtil.set(RedisEnum.allBaseRegulation.getName(), list);
        }
    }
}