package com.lantone.qc.kernel.catalogue.ywzxyy.threelevelward;

import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.lantone.qc.kernel.catalogue.QCCatalogue;
import com.lantone.qc.kernel.util.CatalogueUtil;
import com.lantone.qc.kernel.util.SimilarityUtil;
import com.lantone.qc.pub.model.InputInfo;
import com.lantone.qc.pub.model.OutputInfo;
import com.lantone.qc.pub.model.doc.DoctorAdviceDoc;
import com.lantone.qc.pub.model.doc.FirstCourseRecordDoc;
import com.lantone.qc.pub.model.doc.LeaveHospitalDoc;
import com.lantone.qc.pub.model.doc.ThreeLevelWardDoc;
import com.lantone.qc.pub.model.doc.consultation.ConsultationDoc;
import com.lantone.qc.pub.model.doc.operation.OperationDiscussionDoc;
import com.lantone.qc.pub.model.doc.operation.OperationDoc;
import com.lantone.qc.pub.model.doc.operation.OperationRecordDoc;
import com.lantone.qc.pub.model.entity.Drug;
import com.lantone.qc.pub.model.label.DrugLabel;
import com.lantone.qc.pub.util.DateUtil;
import com.lantone.qc.pub.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @author HUJING
 * @create 2020-09-18 14:23
 * @desc 病程记录激素剂量与医嘱不一致
 **/
@Component
public class THR03079 extends QCCatalogue {
    @Autowired
    SimilarityUtil similarityUtil;

    public void start(InputInfo inputInfo, OutputInfo outputInfo) {
        status.set("0");
        List<DoctorAdviceDoc> doctorAdviceDocs = inputInfo.getDoctorAdviceDocs();
        List<ThreeLevelWardDoc> threeLevelWardDocs = inputInfo.getThreeLevelWardDocs();
        FirstCourseRecordDoc firstCourseRecordDoc = inputInfo.getFirstCourseRecordDoc();
        List<ConsultationDoc> consultationDocs = inputInfo.getConsultationDocs();
        List<OperationDoc> operationDocs = inputInfo.getOperationDocs();
        LeaveHospitalDoc leaveHospitalDoc = inputInfo.getLeaveHospitalDoc();
        if (doctorAdviceDocs.size() == 0) {
            return;
        }

        Map<Date, String> extData = null;
        if (outputInfo.getResult().get("THR02986") != null) {
            extData = (Map<Date, String>) outputInfo.getResult().get("THR02986").get("extData");
        }

        List<Map<String, String>> docAdvStruct = doctorAdviceDocs
                .stream()
                .filter(Objects::nonNull)
                .map(DoctorAdviceDoc::getStructureMap)
                .filter(x -> StringUtil.isNotBlank(x.get("药品类型")) && x.get("药品类型").contains("激素") && StringUtil.isNotBlank(x.get("医嘱单次剂量")))
//                .filter(x -> StringUtil.isNotBlank(x.get("医嘱状态判别")) && !x.get("医嘱状态判别").contains("已停止"))
                .collect(Collectors.toList());
        docAdvStruct.removeIf(x -> StringUtil.isNotBlank(x.get("给药方式")) && !filterKey.contains(x.get("给药方式")));

        //激素及开医嘱时间 <激素名,<激素用量,[激素使用时间...]>>
        Map<String, Map<String, List<Double>>> antibioticInfo = Maps.newLinkedHashMap();
        Map<String, Map<Date, Integer>> antibioticDateTimes = Maps.newHashMap();
        //记录同一激素同一天内是否开过多次，用于医嘱中需要处理的激素过滤（一天内同一激素开过多次的激素直接过滤）
        getAntibioticTimes(docAdvStruct, antibioticDateTimes);
        String drugName = null, value = null, startDateStr = null;
        Date startDate = null;
        for (Map<String, String> structMap : docAdvStruct) {
            drugName = structMap.get("医嘱项目名称");
            value = structMap.get("医嘱单次剂量");
            startDateStr = structMap.get("医嘱开始时间");
            startDate = StringUtil.parseDateTime(startDateStr);
            drugName = removeBracket(drugName).replaceAll("[^\u4e00-\u9fa5]", "");
            String drugStandardWord = similarityUtil.getDrugStandardWord(drugName);
            if (StringUtil.isNotBlank(drugStandardWord)) {
                drugName = drugStandardWord;
            }
            if (extData != null && extData.containsKey(startDate) && extData.get(startDate).equals(drugName)) {
                continue;   //THR02986  医嘱有激素使用病程无记录，规则中没报未记录的激素继续走这条规则，报未记录的激素过滤
            }
            if (antibioticDateTimes.get(drugName) != null) {
                if (antibioticDateTimes.get(drugName).get(startDate) != null && antibioticDateTimes.get(drugName).get(startDate) > 0) {
                    continue;   //一天内同一激素开过多次的激素直接过滤
                }
            }

            if (drugName.contains("甲泼尼龙") || drugName.contains("泼尼松") || drugName.contains("地塞米松") || drugName.contains("可的松")) {
                collectAntibioticInfo(antibioticInfo, structMap.get("医嘱项目名称"), value, startDateStr);
            }
        }

        //激素及开医嘱时间 <激素名,<激素用量,[激素使用时间...]>>
        Map<String, Map<String, List<Double>>> antibioticWardInfo = Maps.newLinkedHashMap();
        String dateStr = null;
        Map<String, Date> mapInfo = Maps.newLinkedHashMap();
        /*********************************************首程治疗计划********************************************************/
        if (firstCourseRecordDoc != null) {
            getInfo(mapInfo, firstCourseRecordDoc.getStructureMap(), "首次病程录", "病历日期", "治疗计划");
            DrugLabel drugLabel = firstCourseRecordDoc.getDrugLabel();
            dateStr = firstCourseRecordDoc.getStructureMap().get("病历日期");
            if (drugLabel != null && StringUtil.isNotBlank(dateStr)) {
                List<Drug> drugs = drugLabel.getDrugs();
                getCourseDrugInfo(antibioticWardInfo, drugs, dateStr);
            }
        }
        /*********************************************查房记录********************************************************/
        if (threeLevelWardDocs.size() > 0) {
            List<ThreeLevelWardDoc> allDoctorWradDocs = threeLevelWardDocs.get(0).getAllDoctorWradDocs();
            List<ThreeLevelWardDoc> wardDocs = allDoctorWradDocs
                    .stream()
                    .filter(x -> StringUtil.isNotBlank(x.getStructureMap().get("查房日期")) && x.getThreeLevelWardLabel().size() > 0)
                    .collect(Collectors.toList());
            wardDocs.forEach(x -> getInfo(mapInfo, x.getStructureMap(), "查房记录", "查房日期", "病情记录", "治疗计划和措施"));
            wardDocs.forEach(x -> getCourseDrugInfo(antibioticWardInfo, x.getThreeLevelWardLabel().get(x.getThreeLevelWardLabel().size() - 1).getDrugs(), x.getStructureMap().get("查房日期")));
        }
        /**********************************************手术记录、术后首程************************************************/
        if (operationDocs.size() > 0) {
            //手术记录
            List<OperationRecordDoc> operationRecordDocs = operationDocs
                    .stream()
                    .map(OperationDoc::getOperationRecordDoc)
                    .filter(Objects::nonNull)
                    .filter(x -> x.getOperationRecordLabel() != null && StringUtil.isNotBlank(x.getStructureMap().get("手术时间")))
                    .collect(Collectors.toList());
            operationRecordDocs.forEach(x -> getInfo(mapInfo, x.getStructureMap(), "手术记录", "手术时间", "手术经过及处理"));
            operationRecordDocs.forEach(x -> getCourseDrugInfo(antibioticWardInfo, x.getOperationRecordLabel().getDrugs(), x.getStructureMap().get("手术时间")));
            //术后首程
            List<OperationDiscussionDoc> operationDiscussionDocs = operationDocs
                    .stream()
                    .map(OperationDoc::getOperationDiscussionDoc)
                    .filter(Objects::nonNull)
                    .filter(x -> x.getOperationDiscussionLabel() != null && StringUtil.isNotBlank(x.getStructureMap().get("病历日期")))
                    .collect(Collectors.toList());
            operationDiscussionDocs.forEach(x -> getInfo(mapInfo, x.getStructureMap(), "术后首程", "病历日期", "手术简要经过", "术后处理措施"));
            operationDiscussionDocs.forEach(x -> getCourseDrugInfo(antibioticWardInfo, x.getOperationDiscussionLabel().getDrugs(), x.getStructureMap().get("病历日期")));
        }
        /*********************************************会诊结果单********************************************************/
        /*if (consultationDocs.size() > 0) {
            List<ConsultationResultsDoc> consultationResultsDocs = consultationDocs
                    .stream()
                    .map(ConsultationDoc::getConsultationResultsDoc)
                    .filter(Objects::nonNull)
                    .filter(x -> x.getConsultationResultLabel() != null && StringUtil.isNotBlank(x.getStructureMap().get("会诊日期及时间")))
                    .collect(Collectors.toList());
            consultationResultsDocs.forEach(x -> getCourseDrugInfo(antibioticWardInfo, x.getConsultationResultLabel().getDrugs(), x.getStructureMap().get("会诊日期及时间")));
        }*/
        /*********************************************出院小结********************************************************/
        if (leaveHospitalDoc != null) {
            if (inputInfo.getMedicalRecordInfoDoc() != null) {
                Map<String, String> medicalRecordInfoStructureMap = inputInfo.getMedicalRecordInfoDoc().getStructureMap();
                dateStr = medicalRecordInfoStructureMap.get("leaveHospitalDate");
                if (StringUtil.isBlank(dateStr)) {
                    dateStr = DateUtil.formatDateTime(new Date());
                }
                //如果存在出院小结，出院日期为空，存储系统当前时间
            }
            if (leaveHospitalDoc.getLeaveHospitalLabel() != null && StringUtil.isNotBlank(dateStr)) {
                getInfo(mapInfo, leaveHospitalDoc.getStructureMap(), "出院小结", "出院时间", "诊治经过");
                List<Drug> drugs = leaveHospitalDoc.getLeaveHospitalLabel().getDrugs();
                getCourseDrugInfo(antibioticWardInfo, drugs, dateStr);
            }
        }

        /**
         * 1.医嘱中开了激素，查房记录中没有该激素，则医嘱中该激素出现过的所有时间都会提示出来
         * 2.医嘱中开了激素，查房记录中有该激素：
         *      2.1 医嘱中该激素某使用量（如50），查房记录中没有该使用量（如只有100），则医嘱中该激素使用量出现过的所有时间都会提示出来
         *      2.2 医嘱中该激素某使用量（如50），查房记录中也有该使用量，对比这两个时间，若医嘱时间两天内的查房记录没有该使用量，则该医嘱时间会提示出来
         */
        StringBuffer sb = new StringBuffer();
        String drugKey = null;
        for (Map.Entry<String, Map<String, List<Double>>> ai : antibioticInfo.entrySet()) {
            drugKey = ai.getKey();
            drugKey = removeBracket(drugKey).replaceAll("[^\u4e00-\u9fa5]", "");
            String drugStandardWord = similarityUtil.getDrugStandardWord(drugKey);
            if (StringUtil.isNotBlank(drugStandardWord)) {
                drugKey = drugStandardWord;
            }
            if (antibioticWardInfo.containsKey(drugKey)) {
                Map<String, List<Double>> adDateValue = ai.getValue();
                Map<String, List<Double>> wardDateValue = antibioticWardInfo.get(drugKey);
                for (Map.Entry<String, List<Double>> adMap : adDateValue.entrySet()) {
                    boolean match = false;
                    String adDateStr = adMap.getKey();
                    Date adDate = StringUtil.parseDateTime(adDateStr);
                    List<Double> adUsage = adMap.getValue();
                    for (Map.Entry<String, List<Double>> wdvMap : wardDateValue.entrySet()) {
                        String wardDateStr = wdvMap.getKey();
                        Date wardDate = StringUtil.parseDateTime(wardDateStr);
                        List<Double> wardUsage = wdvMap.getValue();
                        adDate = DateUtil.dateZeroClear(adDate);
                        if (adDate.before(wardDate) && !CatalogueUtil.compareTime(adDate, wardDate, 48 * 60L)) {
                            if (wardUsage.toString().equals(adUsage.toString())) {
                                match = true;
                            }
                        }
                        if (wardDate.before(adDate) && !CatalogueUtil.compareTime(wardDate, adDate, 24 * 60L)) {
                            boolean isWard = false;
                            if (wardUsage.toString().equals(adUsage.toString())) {
                                isWard = true;
                            }
                            match = isWard;
                        }
                    }
                    adDateStr = DateUtil.formatDate(adDate);
                    if (!match && !sb.toString().contains(drugKey + "(" + adDateStr + ")")) {
                        List<Double> drugDosage = isContinueTreat(ai.getKey(), adDate, mapInfo, wardDateValue);
                        //去*号
                        drugKey = ai.getKey().replace("*", "");
                        if (drugDosage == null) {
                            infoAppend(sb, drugKey, adDateStr);
                        } else {
                            drugDosage.removeAll(adUsage);//比如adUsage有1.0、2.0,wardUsage中有2.0、3.0,removeAll之后wardUsage只剩3.0
                            if (drugDosage.size() != 0) {
                                infoAppend(sb, drugKey, adDateStr);
                            }
                        }
                    }
                }
            }
        }
        if (sb.toString().length() > 0) {
            status.set("-1");
            info.set("医嘱：" + sb.toString().substring(0, sb.toString().length() - 1));
        }
    }

    /**
     * 记录病程记录中是否有继续治疗，治疗同前等
     *
     * @param drug
     * @param adDate
     * @param mapInfo
     * @param wardDateMaps
     */
    private List<Double> isContinueTreat(String drug, Date adDate, Map<String, Date> mapInfo, Map<String, List<Double>> wardDateMaps) {
        for (Map.Entry<String, Date> map : mapInfo.entrySet()) {
            String content = map.getKey();
            Date dateValue = map.getValue();
            //开医嘱时间起，昨天今天明天记录内查找药
            if ((adDate.before(dateValue) && !CatalogueUtil.compareTime(adDate, dateValue, 48 * 60L))
                    || (dateValue.before(adDate) && !CatalogueUtil.compareTime(dateValue, adDate, 24 * 60L))) {
                String standardDrug = null;
                drug = drug.replaceAll("[^\\u4e00-\\u9fa5]", "");
                standardDrug = similarityUtil.getDrugStandardWord(drug);
                if (StringUtil.isBlank(drug)) {
                    continue;
                }
                if (!content.contains(drug) && (StringUtil.isNotBlank(content) && StringUtil.isNotBlank(standardDrug) && !content.contains(standardDrug)) &&
                        (regexFind(content, "继续", "治疗") || regexFind(content, "维持", "治疗") || regexFind(content, "继续", "抗感染") ||
                                regexFind(content, "治疗", "同前") || regexFind(content, "治疗同前"))) {
                    List<Double> drugDosage = null;
                    for (Map.Entry<String, List<Double>> wdvMap : wardDateMaps.entrySet()) {
                        String wardDateStr = wdvMap.getKey();
                        Date wardDate = StringUtil.parseDateTime(wardDateStr);
                        if (wardDate.before(dateValue)) {
                            drugDosage = wdvMap.getValue();
                        }
                    }
                    return drugDosage;
                }
            }
        }
        return null;
    }

    private boolean regexFind(String content, String... str) {
        String s = "";
        for (String word : str) {
            s += word + ".*";
        }
        s = s.substring(0, s.lastIndexOf(".*"));
        Pattern p = Pattern.compile(s);
        Matcher m = p.matcher(content);
        return m.find();
    }

    /**
     * 记录同一激素同一天内是否开过多次，用于医嘱中需要处理的激素过滤（一天内同一激素开过多次的激素直接过滤）
     *
     * @param docAdvStruct
     * @param antibioticDateTimes
     */
    private void getAntibioticTimes(List<Map<String, String>> docAdvStruct, Map<String, Map<Date, Integer>> antibioticDateTimes) {
        String drugName;
        String startDateStr;
        Date startDate;
        Map<Date, Integer> antibioticDateTime;
        for (Map<String, String> structMap : docAdvStruct) {
            drugName = structMap.get("医嘱项目名称");
            startDateStr = structMap.get("医嘱开始时间");
            startDate = StringUtil.parseDateTime(startDateStr);
            String drugStandardWord = similarityUtil.getDrugStandardWord(drugName);
            if (StringUtil.isNotBlank(drugStandardWord)) {
                drugName = drugStandardWord;
            }
            if (antibioticDateTimes.containsKey(drugName)) {
                Map<Date, Integer> map = antibioticDateTimes.get(drugName);
                if (map.containsKey(startDate)) {
                    map.put(startDate, map.get(startDate) + 1);
                } else {
                    map.put(startDate, 0);
                }
            } else {
                antibioticDateTime = Maps.newHashMap();
                antibioticDateTime.put(startDate, 0);
                antibioticDateTimes.put(drugName, antibioticDateTime);
            }
        }
    }

    private void getCourseDrugInfo(Map<String, Map<String, List<Double>>> antibioticWardInfo, List<Drug> drugs, String dateStr) {
        for (Drug drug : drugs) {
            String wardDrug = drug.getName();
            wardDrug = removeBracket(wardDrug);
            String drugStandardWord = similarityUtil.getDrugStandardWord(wardDrug);
            if (StringUtil.isNotBlank(drugStandardWord)) {
                wardDrug = drugStandardWord;
            }
            if (drug.getConsumption() != null) {
                String consumption = drug.getConsumption().getName();
                collectAntibioticInfo(antibioticWardInfo, wardDrug, consumption, dateStr);
            }
        }
    }

    /**
     * 拼接提示信息
     *
     * @param sb
     * @param drugKey
     * @param date
     */
    private void infoAppend(StringBuffer sb, String drugKey, String date) {
        sb.append(drugKey).append("(").append(date).append(")").append("_");
    }

    /**
     * 获取各模块信息<入院记录、首次病程录、手术记录、术后首程、会诊结果单、查房记录、出院小结>
     *
     * @param info
     * @param structureMap
     * @param modelType
     * @param dateKey
     * @param contentKey
     */
    private void getInfo(Map<String, Date> info, Map<String, String> structureMap, String modelType, String dateKey, String... contentKey) {
        String content = CatalogueUtil.structureMapJoin(structureMap, Lists.newArrayList(contentKey));
        String recordDateStr = structureMap.get(dateKey);
        if (StringUtil.isNotBlank(recordDateStr)) {
            Date date = StringUtil.parseDateTime(recordDateStr);
            if (StringUtil.isNotBlank(content) && date != null) {
                info.put(modelType + "->" + content, date);
            }
        }
    }

    /**
     * 收集激素各种信息
     *
     * @param antibioticInfo 激素使用量及所有时间
     * @param drugName       激素名称
     * @param value          激素用量
     * @param startDateStr   激素使用时间（医嘱开始时间或查房时间）
     */
    private void collectAntibioticInfo(Map<String, Map<String, List<Double>>> antibioticInfo, String drugName, String value, String startDateStr) {
        Map<String, List<Double>> antibioticValueList = null;
        double v = -1;
        try {
            v = Double.parseDouble(getNumber(value));
        } catch (Exception e) {
            System.out.println("THR03076:       " + drugName + ":" + value + "解析异常");
        }
        if (v < 0) {
            return;
        }
        if (v > 100) {
            v = v / 1000;
        }
        if (!antibioticInfo.containsKey(drugName)) {
            //存该激素使用第1个值
            antibioticValueList = Maps.newLinkedHashMap();
            antibioticValueList.put(startDateStr, Lists.newArrayList(v));
            antibioticInfo.put(drugName, antibioticValueList);
        } else {
            antibioticValueList = antibioticInfo.get(drugName);
            //存该激素使用时间时第n个量
            if (antibioticValueList.containsKey(startDateStr)) {
                antibioticValueList.get(startDateStr).add(v);
            } else {
                //存该激素使用时间时第1个量
                antibioticValueList.put(startDateStr, Lists.newArrayList(v));
            }
        }
    }

    public static String getNumber(String content) {
        String group = "";
        String compile = "([1-9]\\d*\\.?\\d*)|(0\\.\\d*[1-9]|\\.\\d*[1-9]|0)";
        Pattern p = Pattern.compile(compile);
        Matcher matcher = p.matcher(content);
        if (matcher.find()) {
            group = matcher.group(0);
        }
        return group;
    }

    /**
     * 如果文本包含中括号（[海正]美罗培南针），取括号之后的文字
     *
     * @param str
     * @return
     */
    private String removeBracket(String str) {
        if (str.contains("]") && str.indexOf("]") != str.length() - 1) {
            return str.substring(str.indexOf("]") + 1);
        }
        return str;
    }

    private static final List<String> filterKey = Lists.newArrayList("口服", "静脉滴注", "静脉注射(泵)", "静脉注射", "皮下注射", "冲服",
            "肌注", "关节腔注射", "饭后口服", "饭前口服", "饭中口服", "嚼服", "局部注射", "术中宫体注射",
            "含服", "饭后冲服", "皮内注射", "饭后嚼服", "饭前嚼服", "泡服", "动脉注射",
            "IG", "PO", "SC", "IM", "IV", "IP", "JB", "GT", "OWH", "ACI", "XX");

}
