package thyyxxk.webserver.service.zhuyuanyisheng;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.extern.slf4j.Slf4j;
import org.jetbrains.annotations.Nullable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import thyyxxk.webserver.config.exception.BizException;
import thyyxxk.webserver.config.exception.ExceptionEnum;
import thyyxxk.webserver.dao.his.zhuyuanyisheng.YiZhuLuRuDao;
import thyyxxk.webserver.entity.ResultVo;
import thyyxxk.webserver.entity.datamodify.GetDropdownBox;
import thyyxxk.webserver.entity.datamodify.YzActOrder;
import thyyxxk.webserver.entity.yibao.ZyActpatient;
import thyyxxk.webserver.entity.yibao.patient.Patient;
import thyyxxk.webserver.entity.zhuyuanyisheng.yizhuluru.*;
import thyyxxk.webserver.service.PublicServer;
import thyyxxk.webserver.service.yibao.PatientService;
import thyyxxk.webserver.utils.*;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * <p>
 * 描述： 医嘱录入
 * </p>
 *
 * @author xc
 * @date 2022-01-04 16:59
 */
@Service
@Slf4j
public class YiZhuLuRuServer {


    private final YiZhuLuRuDao dao;
    private final PatientService patientService;
    private final PublicServer publicServer;


    public YiZhuLuRuServer(YiZhuLuRuDao dao, PatientService service, PublicServer publicServer) {
        this.dao = dao;
        this.patientService = service;
        this.publicServer = publicServer;
    }


    /**
     * 获取患者列表
     *
     * @param wardCode 根据病区来进行搜索
     * @return 返回患者信息
     */
    public ResultVo<List<ZyActpatient>> huoQuHuanZheLieBiao(String wardCode) {
        List<ZyActpatient> list = dao.huoQuHuanZheLieBiao(wardCode);
        if (ListUtil.isBlank(list)) {
            return ResultVoUtil.fail(ExceptionEnum.NO_DATA_EXIST);
        }
        list.sort(Comparator.comparingInt(o -> Integer.parseInt(o.getBedNo())));
        return ResultVoUtil.success(list);
    }

    /**
     * 获取患者的具体信息
     * 同时要计算一些数据信息
     *
     * @param inpatientNo 住院号
     * @return 返回
     */
    public ResultVo<PatientTemp> huoQuHuanZheXinXi(String inpatientNo) {
        ResultVo<Patient> resPpatient = patientService.getPatientInfo(inpatientNo);
        if (resPpatient.getCode() != 200) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, resPpatient.getMessage());
        }
        PatientTemp patient = EntityCopy.Copy(resPpatient.getData(), PatientTemp.class);
        HuanZheFeiYong feiYong = dao.feiYongXinXi(patient.getInpatientNo(), patient.getAdmissTimes(), patient.getLedgerSn());
        if (feiYong != null) {
            // 余额
            patient.setBalance(feiYong.getBalance());
            // 总费用
            patient.setTotalCharge(feiYong.getTotalCharge());
            // 药品 百分比
            patient.setYp(DecimalUtil.getPercent(Double.parseDouble(feiYong.getYp()), Double.parseDouble(feiYong.getTotalCharge())));
            // 检验检查 百分比
            patient.setJyjc(DecimalUtil.getPercent(Double.parseDouble(feiYong.getJyjc()), Double.parseDouble(feiYong.getTotalCharge())));
            // 医保 费用
            patient.setChargeYb(feiYong.getChargeYb());
            // 医保百分比
            patient.setYb(DecimalUtil.getPercent(Double.parseDouble(feiYong.getChargeYb()), Double.parseDouble(feiYong.getTotalCharge())));
        }
        // 年龄
        patient.setAge(DateUtil.calculateAge(patient.getBirthDate()));
        patient.setTimesBilled(dao.huoQuHuanZheXinXi(patient.getInpatientNo(), patient.getAdmissTimes()).getTimesBilled());
        return ResultVoUtil.success(patient);
    }

    /**
     * 获取医嘱的名称 这里为什么不用 医嘱的code和医嘱号呢，是因为药品编码和项目编码有些一样而医嘱号，又每次只能查询一个
     *
     * @param inpatientNo 住院号
     * @param admissTimes 住院次数
     * @param orderName   前端搜索的医嘱名称
     * @return 返回医嘱名称去重了
     */
    public ResultVo<List<GetDropdownBox>> huoQuYiZhuMingCheng(String inpatientNo, Integer admissTimes, String orderName) {
        return ResultVoUtil.success(dao.huoQuYiZhuMingZi(inpatientNo, admissTimes, StringUtil.isContainChinese(orderName)));
    }

    /**
     * 获取患者个人的频率
     *
     * @param patNo 住院号
     * @param times 住院次数
     * @return 返回自己的医嘱频率
     */
    public ResultVo<List<GetDropdownBox>> huoQuGeRenPinLv(String patNo, Integer times) {
        return ResultVoUtil.success(dao.huoQuGeRenPinLv(patNo, times));
    }

    /**
     * 获取医嘱的数据
     * 可以根据，医嘱时间区间，执行频率，医嘱名
     *
     * @param param 查询条件
     * @return 返回分页数据，同时做了树状图，这样会有一个问题，那就是开了套餐的数据查询不出来
     */
    public ResultVo<IPage<YzActOrder>> huoQuYiZhuShuJu(YiZhuFeiYongChaXunTiaoJian param) {
        QueryWrapper<?> qw = new QueryWrapper<>();
        qw.eq("inpatient_no", param.getPatNo())
                .eq("admiss_times", param.getTimes());
        if (StringUtil.notBlank(param.getOrderName())) {
            qw.eq("order_name", param.getOrderName());
        }
        if (StringUtil.notBlank(param.getStartTime())) {
            qw.ge("order_time", param.getStartTime())
                    .le("order_time", param.getEndTime());
        }

        if (StringUtil.notBlank(param.getFrequCode())) {
            qw.eq("frequ_code", param.getFrequCode());
        }
        List<Integer> zhaungTai = new ArrayList<Integer>() {
            private static final long serialVersionUID = 1194053908853933514L;

            {
                add(1);
                add(2);
                add(5);
            }
        };
        if (zhaungTai.contains(param.getZhuangTai())) {
            qw.eq("status_flag", param.getZhuangTai());
        } else if (param.getZhuangTai() == 3) {
            qw.in("status_flag", 3, 4);
        } else if (param.getZhuangTai() == 6) {
            qw.ne("frequ_code", "ONCE")
                    .isNull("end_time")
                    .eq("doctor_flag", "1")
                    .ne("status_flag", "5");
        } else if (param.getZhuangTai() == 7) {
            qw.eq("doctor_flag", "1")
                    .ge("status_flag", "2")
                    .ge("start_time", DateUtil.formatDatetime(DateUtil.addDateMinut(new Date(), -24)));
        } else if (param.getZhuangTai() == 8) {
            qw.eq("frequ_code", "ONCE");
        } else if (param.getZhuangTai() == 9) {
            qw.ne("frequ_code", "ONCE");
        }
        IPage<YzActOrder> page = new Page<>();
        if (param.getTotal() == 0) {
            page.setTotal(dao.huoQuYiZhuShuJuTotal(qw));
        } else {
            page.setTotal(param.getTotal());
        }

        List<YzActOrder> yiZhuList = dao.huoQuYiZhuShuJu(param.getCurrentPage(), param.getPageSize(), qw);
        // 还有那些没有被匹配的子级医嘱
        Map<BigDecimal, YzActOrder> wuFuJiYiZhu = yiZhuList.stream().collect(
                Collectors.toMap(YzActOrder::getActOrderNo, a -> a, (k1, k2) -> k1));

        if (ListUtil.isBlank(yiZhuList)) {
            return ResultVoUtil.fail(ExceptionEnum.NO_DATA_EXIST);
        }
        // 做成树状图
        Map<BigDecimal, YzActOrder> map = new HashMap<>();
        List<YzActOrder> tree = new ArrayList<>();
        for (YzActOrder item : yiZhuList) {
            if (item.getParentNo() == null) {
                tree.add(item);
                wuFuJiYiZhu.remove(item.getActOrderNo());
            }
            map.put(item.getActOrderNo(), item);
            EntityStringTrim.beanAttributeValueTrim(item);
            if (item.getSerial().equals("00")) {
                item.setGroupNoName("医技科室");
                item.setSerialName("项目");
            } else {
                if (item.getSerial().equals("01")) {
                    item.setSerialName("小包装");
                } else if (item.getSerial().equals("99")) {
                    item.setSerialName("大包装");
                }
            }
        }
        for (YzActOrder item : yiZhuList) {
            YzActOrder actOrder = map.get(item.getParentNo());
            if (actOrder != null) {
                wuFuJiYiZhu.remove(item.getActOrderNo());
                if (actOrder.getChildren() == null) {
                    actOrder.setChildren(new ArrayList<>());
                }
                item.setIsChildren(true);
                actOrder.getChildren().add(item);
            }
        }
        if (!wuFuJiYiZhu.isEmpty()) {
            tree.addAll(wuFuJiYiZhu.values());
        }
        // 删除前后空格
        EntityStringTrim.beanAttributeValueTrimList(tree);
        page.setRecords(tree);
        return ResultVoUtil.success(page);
    }

    /**
     * 获取搜索的项目信息，如药品和项目
     *
     * @param code 拼音首字母，中文，编码来进行搜索
     * @return 返回项目信息
     */
    public ResultVo<List<YiZhuMingChen>> huoQuXiangMu(String code) {
        code = StringUtil.isContainChinese(code);
        List<YiZhuMingChen> list = dao.yiZhuYaoPing(code, publicServer.getGroupNo());
        list.addAll(dao.yiZhuXiangMu(code));
        EntityStringTrim.beanAttributeValueTrimList(list);
        return ResultVoUtil.success(list);
    }

    /**
     * 获取某一个费用的详细信息
     *
     * @param code   编码
     * @param serial 00-项目 01-小包装的药品 99-大包装
     * @return 返回该费用的一些详细信息，以及一些提示信息。
     */
    public ResultVo<Map<String, Object>> huoQuFeiYongXinXi(String code, String serial) {
        Map<String, Object> map = new HashMap<>();
        if (serial.trim().equals("00")) {
            XinZhenYzActOrder xiangMu = dao.huoQuXiangMu(code);
            if (xiangMu != null) {
                if (xiangMu.getDelFlag() == 1) {
                    return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该医嘱下的项目，已经被停用了，请联系物价科。");
                }
            } else {
                Integer paiChiYiZhu = dao.shiFouPaiChiYiZhu(code);
                switch (paiChiYiZhu) {
                    case 1:
                        map.put("paiChiYiZhu", "全排斥医嘱");
                        break;
                    case 2:
                        map.put("paiChiYiZhu", "单组排斥医嘱");
                        break;
                    case 3:
                        map.put("paiChiYiZhu", "多组斥医嘱");
                        break;
                }
            }
        } else {
            YaoPinXinXi yp = dao.huoQuYaoPin(code.trim() + serial.trim());
            if (yp == null) {
                return ResultVoUtil.fail(ExceptionEnum.NO_DATA_EXIST, "该医嘱下的药品，可能已经被停用了或没有医保码，请联系药剂科。");
            }
            Integer yiShenDengJi = dao.huoQuYiShenDengJi(TokenUtil.getTokenUserId());
            int yiShen = yiShenDengJi == null ? 0 : yiShenDengJi;
            if (yp.getYpLevel() > yiShen) {
                return ResultVoUtil.fail(ExceptionEnum.NO_DATA_EXIST, "您没有开此药品的权限。");
            }
            map.put("piShi", dao.piShiGeiYaoFangShi());
            List<YaoPingJiLiang> yaoPingJiLiang = new ArrayList<>();
            if (StringUtil.notBlank(yp.getWeighUnit())) {
                yaoPingJiLiang.add(new YaoPingJiLiang(yp.getWeighUnit(), yp.getWeighUnitName(), yp.getWeight()));
            }
            if (StringUtil.notBlank(yp.getVolUnit())) {
                yaoPingJiLiang.add(new YaoPingJiLiang(yp.getVolUnit(), yp.getVolUnitName(), yp.getVolum()));
            }
            if (StringUtil.notBlank(yp.getPackUnit())) {
                yaoPingJiLiang.add(new YaoPingJiLiang(yp.getPackUnit(), yp.getPackUnitName(), yp.getPackSize()));
            }
            map.put("yaoPingJiLiang", yaoPingJiLiang);
            map.put("data", yp);
        }
        return ResultVoUtil.success(map);
    }

    /**
     * 获取频率
     *
     * @param code 五笔，拼音，中文，编码
     * @return 返回对应的数据
     */
    public ResultVo<List<GetDropdownBox>> huoQuZhuYuanPinLv(String code) {
        return ResultVoUtil.success(dao.huoQuZhuYuanPinLv(StringUtil.isContainChinese(code)));
    }

    /**
     * 获取给药方式
     *
     * @param code 五笔，拼音，中文，编码
     * @return 返回对应的数据
     */
    public ResultVo<List<GetDropdownBox>> huoQuGeiYaoFangShi(String code) {
        return ResultVoUtil.success(dao.huoQuGeiYaoFangShi(StringUtil.isContainChinese(code)));
    }

    /**
     * 获取执行科室
     *
     * @param code 五笔，拼音，中文，编码
     * @return 返回对应的数据
     */
    public ResultVo<List<GetDropdownBox>> huoQuZhiXinKeShi(String code) {
        return ResultVoUtil.success(dao.huoQuZhiXinKeShi(StringUtil.isContainChinese(code)));
    }


    /**
     * 用来校验数据 以及插入医嘱和插入抗菌药物以及，插入医嘱模板
     *
     * @param param 数据
     * @return 返回提示
     */
    @Transactional(rollbackFor = Exception.class)
    public ResultVo<String> shangChuanYiZhu(XinZhenYiZhu param) {
        if (ListUtil.isBlank(param.getList())) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "请选择数据");
        }

        Set<String> yaoPingCode = new HashSet<>();
        Set<String> xiangMuCode = new HashSet<>();
        StringBuilder cuoWuXinXi = new StringBuilder();

        Boolean needRule = publicServer.noNeedRule(38);
        // 这个是用来做父子组件的 map
        Map<BigDecimal, XinZhenYzActOrder> fuYiZhuId = new HashMap<>();
        for (XinZhenYzActOrder item : param.getList()) {
            if (item.getParentNo() == null) {
                fuYiZhuId.put(item.getId(), item);
            }
            if (item.getSerial().trim().equals("00")) {
                xiangMuCode.add(item.getOrderCode().trim());
            } else {
                yaoPingCode.add(item.getOrderCode().trim() + item.getSerial().trim());
            }
        }
        // 这个是药品的一些信息
        Map<String, XinZhenYzActOrder> yaoPingXinXi = new HashMap<>();
        Map<String, XinZhenYzActOrder> xiangMuXinXi = new HashMap<>();
        //  获取医生开药品的权限
        Integer yiShenDengJi = dao.huoQuYiShenDengJi(TokenUtil.getTokenUserId());
        if (!yaoPingCode.isEmpty()) {
            yaoPingXinXi = dao.huoQuYaoPinXinXi(yaoPingCode).stream().collect(
                    Collectors.toMap(item -> item.getOrderCode().trim() + item.getSerial().trim(), a -> a, (k1, k2) -> k1));
        }
        if (!xiangMuCode.isEmpty()) {
            xiangMuXinXi = dao.huoQuXiangMuXinXi(xiangMuCode).stream().collect(
                    Collectors.toMap(item -> item.getOrderCode().trim(), a -> a, (k1, k2) -> k1));
        }
        // 这个是 抗菌药物的信息
        List<YzActRecordKss> kssList = new ArrayList<>();
        // 判断一些基本信息错误 以及生成医嘱号
        int index = 0;
        int listSize = param.getList().size();
        for (XinZhenYzActOrder item : param.getList()) {
            index++;
            if (StringUtil.isBlank(item.getOrderCode())) {
                cuoWuXinXi.append(getCuoWuXinXi("项目编码不能为空", listSize, index));
            }
            if (StringUtil.isBlank(item.getOrderName())) {
                cuoWuXinXi.append(getCuoWuXinXi("项目名称不能为空", listSize, index));
            }
            if (StringUtil.isBlank(item.getExecUnit())) {
                cuoWuXinXi.append(getCuoWuXinXi("执行科室不能为空", listSize, index));
            } else if (item.getExecUnit().startsWith("8")) {
                cuoWuXinXi.append(getCuoWuXinXi("执行科室不能选择为病区", listSize, index));
            }
            if (!item.getSerial().trim().equals("00")) {
                if (StringUtil.isBlank(item.getFrequCode())) {
                    cuoWuXinXi.append(getCuoWuXinXi("频次不能为空", listSize, index));
                }
                if (StringUtil.isBlank(item.getDiscription())) {
                    cuoWuXinXi.append(getCuoWuXinXi("描述不能为空", listSize, index));
                }
                if (StringUtil.isBlank(item.getDrugSpecification())) {
                    cuoWuXinXi.append(getCuoWuXinXi("药品规格不能为空", listSize, index));
                }
                if (StringUtil.isBlank(item.getSupplyCode())) {
                    cuoWuXinXi.append(getCuoWuXinXi("给药方式不能为空", listSize, index));
                }
                if (item.getDose() == null || BigUtils.dengYu(item.getDose(), 0)) {
                    cuoWuXinXi.append(getCuoWuXinXi("一次计量不能为空", listSize, index));
                }
                if (StringUtil.isBlank(item.getDoseUnit())) {
                    cuoWuXinXi.append(getCuoWuXinXi("计量单位不能为空", listSize, index));
                }
                if (StringUtil.isBlank(item.getSerial())) {
                    cuoWuXinXi.append(getCuoWuXinXi("包装大小不能为空", listSize, index));
                }
                // 插入模板就不需要 填写时间 这里为什么不要使用 插入医嘱 这个判断就是因为还需要校验数据
                if (!param.getChaRuMuBan()) {
                    if (item.getOrderTime() == null) {
                        cuoWuXinXi.append(getCuoWuXinXi("医嘱时间不能为空", listSize, index));
                    } else if (item.getStartTime() == null) {
                        cuoWuXinXi.append(getCuoWuXinXi("开始时间不能为空", listSize, index));
                    } else if (DateUtil.shiJianDaXiao(item.getStartTime(), item.getOrderTime(), "<")) {
                        cuoWuXinXi.append(getCuoWuXinXi("开始时间不能在开医嘱之前", listSize, index));
                    }
                    if (item.getEndTime() != null) {
                        if (item.getFrequCode().trim().equals("ONCE")) {
                            item.setEndTime(null);
                        } else {
                            if (DateUtil.shiJianDaXiao(item.getEndTime(), item.getStartTime(), "<")) {
                                cuoWuXinXi.append(getCuoWuXinXi("结束时间不能在开始时间之前", listSize, index));
                            }
                        }

                    }
                }
            }
            XinZhenYzActOrder feiYongXinXi = yaoPingXinXi.get(item.getOrderCode().trim() + item.getSerial().trim());
            if (feiYongXinXi != null) {
                //                                              跳过 权限判断
                if (feiYongXinXi.getYpLevel() > yiShenDengJi && needRule) {
                    cuoWuXinXi.append(getCuoWuXinXi("您没有开此药品的权限", listSize, index));
                }
                if (feiYongXinXi.getDelFlag() == 1) {
                    cuoWuXinXi.append(getCuoWuXinXi("已被物价科停用，请联系物价科。", listSize, index));
                }
            } else {
                feiYongXinXi = xiangMuXinXi.get(item.getOrderCode().trim());
                if (feiYongXinXi != null) {
                    if (feiYongXinXi.getDelFlag() == 1) {
                        cuoWuXinXi.append(getCuoWuXinXi("已被物价科停用，请联系物价科。", listSize, index));
                    }
                }
                // 如果项目和药品全部没有那么就代表这是一个不会产生费用的医嘱
            }
            if (!item.getSerial().equals("00") && feiYongXinXi != null) {
                // 判断抗菌药物
                if (param.getChaRuYiZhu()) {
                    item.setKjywFlag(feiYongXinXi.getKjywFlag());
                    if (feiYongXinXi.getKjywFlag() == 1) {
                        if (item.getYyfs() == null) {
                            cuoWuXinXi.append(getCuoWuXinXi("请填写抗菌药物医嘱附注信息录入。", listSize, index));
                        } else if (item.getYyfs() == 1 || item.getYyfs() == 2) {
                            if (item.getSsqk() == null || item.getYyfs() == null) {
                                cuoWuXinXi.append(getCuoWuXinXi("当用药方式为 1 或 2 时，手术切口和用药时间不能为空。", listSize, index));
                            }
                        }
                    }
                }
                // 如果药品已经是最小包装规格了就不能带小数点
                // 同时计算药品的执行用量 以及 领量
                if (StringUtil.notBlank(feiYongXinXi.getDrugWeightUnit()) &&
                        item.getDoseUnit().trim().equals(feiYongXinXi.getDrugWeightUnit().trim())) {
                    if (BigUtils.bigXiaoYu(item.getDose(), feiYongXinXi.getDrugWeight())) {
                        item.setDrugQuan(BigDecimal.valueOf(1));
                        item.setDrugOcc(BigDecimal.valueOf(1));
                    } else {
                        item.setDrugQuan(DecimalUtil.divide(item.getDose(), feiYongXinXi.getDrugWeight()));
                        item.setDrugOcc(DecimalUtil.divide(item.getDose(), feiYongXinXi.getDrugWeight(), 2));
                    }
                } else if (StringUtil.notBlank(feiYongXinXi.getDrugVolUnit()) && item.getDoseUnit().trim().equals(feiYongXinXi.getDrugVolUnit())) {
                    if (BigUtils.bigXiaoYu(item.getDose(), feiYongXinXi.getDrugVolume())) {
                        item.setDrugQuan(BigDecimal.valueOf(1));
                        item.setDrugOcc(BigDecimal.valueOf(1));
                    } else {
                        item.setDrugQuan(DecimalUtil.divide(item.getDose(), feiYongXinXi.getDrugVolume()));
                        item.setDrugOcc(DecimalUtil.divide(item.getDose(), feiYongXinXi.getDrugVolume(), 2));
                    }
                } else if (StringUtil.notBlank(feiYongXinXi.getPackUnit()) && item.getDoseUnit().trim().equals(feiYongXinXi.getPackUnit())) {
                    if (new BigDecimal(item.getDose().intValue()).compareTo(item.getDose()) != 0) {
                        cuoWuXinXi.append(getCuoWuXinXi("已经是最小单位了请不要带小数点。", listSize, index));
                    }
                    item.setDrugQuan(DecimalUtil.divide(item.getDose(), feiYongXinXi.getPackSize()));
                    item.setDrugOcc(DecimalUtil.divide(item.getDose(), feiYongXinXi.getPackSize(), 2));
                }
                try {
                    // 这里把查询出来的一些信息 放到item 中 ，这个克隆不会影响已经有值的数据 这样就不用一个个set 了
                    EntityCopy.Copy(feiYongXinXi, item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } else {
                item.setDrugQuan(BigDecimal.valueOf(1));
                item.setDrugOcc(BigDecimal.valueOf(1));
            }
            // 判断是否需要上传
            if (param.getChaRuYiZhu()) {
                item.setActOrderNo(BigDecimal.valueOf(publicServer.getActOrderNo()));
                if (item.getKjywFlag() != null && item.getKjywFlag() == 1) {
                    YzActRecordKss kss = new YzActRecordKss();
                    kss.setActOrderNo(item.getActOrderNo());
                    kss.setChargeCode(item.getOrderCode());
                    kss.setYyfs(item.getYyfs());
                    kss.setSsqk(item.getSsqk());
                    kss.setYysj(item.getYysj());
                    kssList.add(kss);
                }
            }
            // 判断是不是需要 插入 模板数据
            if (param.getChaRuMuBan()) {
                item.setActOrderNo(BigDecimal.valueOf(publicServer.getPatternOrderCode()));
            }
            // 在这里把 父级的医嘱号放进去
            if (item.getParentNo() != null && fuYiZhuId.containsKey(item.getParentNo())) {
                item.setParentNo(fuYiZhuId.get(item.getParentNo()).getActOrderNo());
            }
        }
        // 提示信息
        if (cuoWuXinXi.length() > 0) {
            throw new BizException(ExceptionEnum.LOGICAL_HTML_ERROR, cuoWuXinXi.toString());
        }
        // 执行人
        String inputCode = TokenUtil.getTokenUserId();
        // 在这里插入医嘱
        if (param.getChaRuYiZhu()) {
            return chaRuYiZhu(param, kssList, inputCode);
        }
        if (param.getChaRuMuBan()) {
            dao.chaRuMuBanShuJu(param.getList(), param.getPatternCode());
        }
        return ResultVoUtil.success();
    }

    @Nullable
    @Transactional(rollbackFor = Exception.class)
    public ResultVo<String> chaRuYiZhu(XinZhenYiZhu param, List<YzActRecordKss> kssList, String inputCode) {
        if (StringUtil.isBlank(param.getInpatientNo()) || param.getAdmissTimes() == null) {
            throw new BizException(ExceptionEnum.LOGICAL_ERROR, "请先选择患者信息");
        }

        XinZhenYiZhu huanZheXinXi = dao.huoQuHuanZheXinXi(param.getInpatientNo(), param.getAdmissTimes());
        if (huanZheXinXi == null) {
            throw new BizException(ExceptionEnum.LOGICAL_ERROR, "没有查询到患者的在院信息。");
        }

        huanZheXinXi.setInfantFlag(publicServer.getInfantFlag(huanZheXinXi.getInpatientNo()));
        publicServer.huanZheJieSuan(param.getInpatientNo(), param.getAdmissTimes());
        if (ListUtil.notBlank(kssList)) {
            dao.shanChuYuanKuangJunYaoWu(kssList);
            dao.chaRuKuangJunYaoWuXinXi(huanZheXinXi.getInpatientNo(), huanZheXinXi.getAdmissTimes(), inputCode, kssList);
        }
        List<String> content = new ArrayList<>();
        String groupNo = publicServer.getGroupNo();
        for (XinZhenYzActOrder item : param.getList()) {
            if (StringUtil.isBlank(item.getDrugFlag())) {
                item.setDrugFlag("o");
            }
            if (item.getSerial().trim().equals("00")) {
                item.setGroupNo("00");
            } else if (item.getSerial().trim().equals("01") || item.getSerial().trim().equals("99")) {
                item.setGroupNo(groupNo);
            }
            if (item.getEndTime() != null) {
                item.setModifier(inputCode);
            }
            content.add(String.format("医嘱名：<span style='color:#409eff'>【%s】</span><br>" +
                            "医嘱时间：<span style='color:#409eff'>【%tF %<tT】</span><br>" +
                            "患者姓名：<span style='color:#409eff'>【%s】</span><br>" +
                            "床位：<span style='color:#409eff'>【%s】</span><br>" +
                            "频次：<span style='color:#409eff'>【%s】</span>",
                    item.getOrderName(), item.getOrderTime(), huanZheXinXi.getName(), huanZheXinXi.getBedNo(), item.getFrequCode()));
        }
        dao.chaRuYiZhu(huanZheXinXi.getInpatientNo(), huanZheXinXi.getAdmissTimes(), inputCode, huanZheXinXi.getInfantFlag(),
                huanZheXinXi.getDeptCode(), huanZheXinXi.getDeptCode(), huanZheXinXi.getReferPhysician(), param.getList());
        publicServer.faSongXiaoXi(huanZheXinXi, content, "新增医嘱", inputCode);
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "医嘱保存成功。");
    }

    /**
     * 错误信息提示，如果只有一个 list 那就不需要提示是多少行了
     *
     * @param message  消息
     * @param listSize 当前传入数据的大小
     * @param index    当前的数据的下标
     * @return 返回提示信息
     */
    private String getCuoWuXinXi(String message, int listSize, int index) {
        if (listSize == 1) {
            return message + "<br>";
        } else {
            return String.format("第【%d】行，%s <br>", index, message);
        }
    }

    /**
     * 获取模板的名字
     *
     * @param code 编码
     * @return 返回模板名称 list
     */
    public ResultVo<IPage<yzOrderPattern>> huoQuYiZhuMuBan(String code, String deptCode, Integer muBanLeiXing,
                                                           long currentPage, long total) {
        IPage<yzOrderPattern> page = new Page<>();
        if (total == 0) {
            page.setTotal(dao.huoQuMuBanTotal(StringUtil.isContainChinese(code), TokenUtil.getTokenUserId(), deptCode, muBanLeiXing));
        }
        page.setRecords(dao.huoQuMuBan(StringUtil.isContainChinese(code), TokenUtil.getTokenUserId(), deptCode, muBanLeiXing, currentPage));
        return ResultVoUtil.success(page);
    }

    public ResultVo<List<YzActOrder>> huoQuMuBanShuJu(String code) {
        List<YzActOrder> muBanShuJu = dao.huoQuMuBanShuJu(code);

        Map<BigDecimal, YzActOrder> wuFuJi = muBanShuJu.stream().collect(
                Collectors.toMap(YzActOrder::getId, a -> a, (k1, k2) -> k1));

        Map<BigDecimal, YzActOrder> map = new HashMap<>();
        List<YzActOrder> tree = new ArrayList<>();
        for (YzActOrder item : muBanShuJu) {
            if (item.getParentNo() == null) {
                tree.add(item);
                wuFuJi.remove(item.getId());
            }
            map.put(item.getId(), item);
        }
        for (YzActOrder item : muBanShuJu) {
            YzActOrder yzActOrder = map.get(item.getParentNo());
            if (yzActOrder != null) {
                wuFuJi.remove(item.getId());
                item.setIsChildren(true);
                if (yzActOrder.getChildren() == null) {
                    yzActOrder.setChildren(new ArrayList<>());
                }
                yzActOrder.getChildren().add(item);
            }
        }
        if (!wuFuJi.isEmpty()) {
            tree.addAll(wuFuJi.values());
        }
        return ResultVoUtil.success(tree);
    }

    @Transactional(rollbackFor = Exception.class)
    public ResultVo<String> baoCunMuBan(yzOrderPattern param) {
        yzOrderPattern yzOrderPattern;
        if (param.getInputType().equals("3")) {
            yzOrderPattern = dao.yuanLaiDeMuBanBianMa(param.getPatternName(), TokenUtil.getTokenUserId());
        } else {
            yzOrderPattern = dao.gongGongMuBan(param.getPatternName());
        }
        List<Integer> role = publicServer.getRoleCode().getData();
        if (param.getInputType().equals("1") && publicServer.noNeedRule(role, 38)) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "您没有权限修改和删除全院模板。");
        } else if (param.getInputType().equals("2") && publicServer.noNeedRule(role, 38, 11)) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "您没有权限修改和删除科室模板。");
        }
        String patternCode = yzOrderPattern.getPatternCode();
        if (StringUtil.notBlank(patternCode) && !param.getQingZhiTiHuan()) {
            return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "模板名重复。是否替换：【900】");
        }
        if (StringUtil.notBlank(patternCode)) {
            // 更新的时候先删除模板
            dao.shanChuLaoMuBan(patternCode);
            param.setPatternCode(patternCode);
        } else {
            param.setPatternCode(publicServer.getPatternCode());
        }

        param.setPyCode(PingYinUtils.pyShouZiMuDaXie(param.getPatternName()));
        param.setDCode(PingYinUtils.getWBCode(param.getPatternName()));
        param.setInputId(TokenUtil.getTokenUserId());

        XinZhenYiZhu xinZhenYiZhu = new XinZhenYiZhu();
        xinZhenYiZhu.setChaRuMuBan(true);
        xinZhenYiZhu.setPatternCode(param.getPatternCode());
        xinZhenYiZhu.setList(param.getList());
        dao.chaRuMuBan(param);
        ResultVo<String> chaRuMuBan = shangChuanYiZhu(xinZhenYiZhu);
        if (chaRuMuBan.getCode() != 200) {
            throw new BizException(ExceptionEnum.LOGICAL_HTML_ERROR, chaRuMuBan.getMessage());
        }
        if (StringUtil.notBlank(patternCode)) {
            return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "已替换原模板。");
        }
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "创建模板成功。");
    }

    /**
     * 删除或修改模板
     *
     * @param patternCode 模板点吗
     * @param patternName 模板名称
     * @param sortNo      排序号
     * @param flag        标志 1-修改 2- 删除 3-收藏和取消收藏
     * @return 返回给前端提示
     */
    public ResultVo<String> muBanCaoZuo(String patternCode, String patternName, String deptCode, Integer sortNo, Integer flag) {
        if (StringUtil.isBlank(patternCode)) {
            return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "项目编码为空。");
        }
        yzOrderPattern yzOrderPattern = dao.huoQuMuBanXinXi(patternCode);
        if (yzOrderPattern == null) {
            return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "没有查询到对应的模板信息。");
        }
        EntityStringTrim.beanAttributeValueTrim(yzOrderPattern);
        String inputId = TokenUtil.getTokenUserId();
        List<Integer> role = publicServer.getRoleCode().getData();
        // 管理员 和 医务部的无视 规则
        if (!role.contains(1) && !role.contains(38) && flag != 3) {
            // 只有模板在不等于 自己的时候触发
            if (!inputId.equals(yzOrderPattern.getInputId())) {
                if (yzOrderPattern.getInputType().equals("2") && !role.contains(11)) {
                    return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该模板为科室模板您没有权限修改或删除，请联系科主任进行修改。");
                } else if (yzOrderPattern.getInputType().equals("1")) {
                    return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该模板为全院模板，无法删除或修改。");
                }
            }
        }
        if (flag == 1) {
            if (StringUtil.isBlank(patternName)) {
                return ResultVoUtil.fail(ExceptionEnum.NULL_POINTER, "模板名称不能为空。");
            }
            if (patternName.trim().equals(yzOrderPattern.getPatternName().trim()) && sortNo.equals(yzOrderPattern.getSortNo())) {
                return ResultVoUtil.fail(ExceptionEnum.INTERNAL_SERVER_ERROR, "数据没有变化，请勿点击。");
            }
            dao.genXingMuBan(patternName.trim(), PingYinUtils.pyShouZiMuDaXie(patternName), PingYinUtils.getWBCode(patternName), yzOrderPattern.getPatternCode(), sortNo);
            return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "修改成功。");
        } else if (flag == 2) {
            // 删除父模板以及下面的子模板 数据
            dao.shanChuMuBan(yzOrderPattern.getPatternCode());
            return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "删除成功。");
        } else if (flag == 3) {
            // 收藏模板
            String collectCode = dao.chongFuShouCang(inputId, patternCode);
            if (collectCode == null) {
                dao.chaRuShouCang(publicServer.getPatternCode(), yzOrderPattern.getPatternName() + "(收藏)",
                        yzOrderPattern.getPyCode(), yzOrderPattern.getDCode(), deptCode, inputId, yzOrderPattern.getPatternCode());
                return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "收藏成功。");
            } else {
                dao.shanChuMuBan(yzOrderPattern.getPatternCode());
                return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "已取消收藏。");
            }
        }
        return ResultVoUtil.success();
    }

    /**
     * 医嘱操作
     *
     * @param actOrderNo 医嘱号
     * @param flag       标志 1-设为紧急 2-撤销 3-停止
     * @return 返回提示
     */
    @Transactional(rollbackFor = Exception.class)
    public ResultVo<String> yiZhuChaoZuo(BigDecimal actOrderNo, Integer flag, String content) {
        YzActOrder yz = dao.chaXunYiZhuXinXin(actOrderNo);
        if (yz == null) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "没有查询到该医嘱可能已经被撤销了");
        }
        switch (flag) {
            case 1:
                return sheZhiJinJi(yz);
            case 2:
                return ceXiaoYiZhu(yz, content);
            case 3:
                return tingZhiShiJian(yz, content);
        }
        return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "你想干什么？");
    }

    public ResultVo<String> sheZhiJinJi(YzActOrder yz) {
        String emergencyFlag = null;
        if (yz.getEmergencyFlag() == null || !yz.getEmergencyFlag().trim().equals("1")) {
            emergencyFlag = "1";
        }
        dao.sheZhiJinJi(yz.getActOrderNo(), emergencyFlag);
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION);
    }

    private ResultVo<String> ceXiaoYiZhu(YzActOrder param, String content) {
        if (StringUtil.isBlank(content)) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "请填写撤销原因。");
        }
        YzActOrder yz = dao.chaXunYiZhuXinXin(param.getActOrderNo());
        if (yz == null) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "没有找到对应医嘱的信息。");
        }
        String userCode = TokenUtil.getTokenUserId();
        if (publicServer.noNeedRule(38)) {
            if (!yz.getPhysician().trim().equals(userCode)) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "不是本人开的医嘱无权撤销。");
            }
            if (DateUtil.shiJianDaXiao(new Date(), DateUtil.addDateMinut(yz.getStartTime(), 24), ">")) {
                return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "已经超过24个小时了，无法撤销。");
            }
        }
        if (!yz.getStatusFlag().trim().equals("2")) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "该医嘱无法被撤销。");
        }
        // 获取该医嘱下面的项目有没有被执行了，如果被执行了的话就不能撤销了。
        publicServer.huoQuGaiYiZhuXiaXiangMu(yz.getActOrderNo());
        // 插入撤销的原因
        dao.chaRuCheXiaoYuanYin(yz.getActOrderNo(), yz.getInpatientNo(), yz.getAdmissTimes(), content, yz.getOrderCode());
        //  删除费用 删除药品的药单 删除医嘱表 删除医技
        dao.cheXiaoYiZhu(yz.getActOrderNo());
        // 把原来的医嘱插入到 yz_erase_order 这个表
        dao.chaRuShanChuBiao(yz.getActOrderNo());
        // 更新原来的状态
        dao.genXingShanChuBiaoZhi(userCode, yz.getActOrderNo());
        log.info("删除医嘱==》数据：{}，操作人：{}", JSON.toJSONString(yz), userCode);
        publicServer.faSongXiaoXi(dao.huoQuHuanZheXinXi(yz.getInpatientNo(), yz.getAdmissTimes()),
                Stream.of(String.format("医嘱名：【%s】，<br>" +
                        "医嘱号：【%s】，<br>" +
                        "撤销原因【%s】", yz.getOrderName(), yz.getActOrderNo(), content)).collect(Collectors.toList()),
                "撤销医嘱", TokenUtil.getTokenUserId());
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION, "医嘱撤销成功。");
    }

    private ResultVo<String> tingZhiShiJian(YzActOrder yz, String content) {
        String userCode = TokenUtil.getTokenUserId();
        if (StringUtil.isBlank(content)) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "请选择停止时间。");
        }
        String LOGICAL_ERROR = tingZhiYiZhuJiaoYan(yz, content);
        if (LOGICAL_ERROR != null) return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, LOGICAL_ERROR);
        dao.sheZhiTingZhiShiJian(userCode, yz.getActOrderNo(), content);
        log.info("停止医嘱==》医嘱号：{}，停止时间：{}，操作人：{}", yz.getActOrderNo(), content, userCode);
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION);
    }

    private String tingZhiYiZhuJiaoYan(YzActOrder yz, String content) {
        if (!DateUtil.dateStrIsValid(content, DateUtil.DEFAULT_PATTERN)) {
            return "请输入正确的时间格式。";
        }
        if (yz.getEndTime() != null) {
            return "该医嘱已经被停止了，无法修改。";
        }
        if (DateUtil.shiJianDaXiao(content, DateUtil.formatDatetime(yz.getStartTime()), "<")) {
            return "停止时间不能在开始时间前面。";
        }
        if (yz.getFrequCode().trim().equals("ONCE")) {
            return "临时医嘱，无法设置停止时间。";
        }
        return null;
    }

    @Transactional(rollbackFor = Exception.class)
    public ResultVo<String> piLiangXiuGaiTingZhiShiJian(YiZhuTingZhiShiJian param) {
        if (param.getActOrderNoList().size() > 20) {
            return ResultVoUtil.fail(ExceptionEnum.INTERNAL_SERVER_ERROR, "批量操作每次不得大于20条");
        }
        List<YzActOrder> yiZhuXinXi = dao.yiZhuXinXiJiHe(param.getActOrderNoList());
        if (yiZhuXinXi == null) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_ERROR, "没有查询到对应的医嘱信息，您选择的数据可以已经被全部停止或撤销。");
        }
        StringBuilder cuoWuXinXi = new StringBuilder();
        for (YzActOrder yzActOrder : yiZhuXinXi) {
            String jiaoYan = tingZhiYiZhuJiaoYan(yzActOrder, param.getEndTime());
            if (jiaoYan != null) {
                cuoWuXinXi.append("医嘱号：")
                        .append(yzActOrder.getActOrderNo())
                        .append("<br>")
                        .append("医嘱名:")
                        .append(yzActOrder.getOrderName())
                        .append("<br>")
                        .append(jiaoYan)
                        .append("<br><br>");
            }
        }
        if (cuoWuXinXi.length() > 0) {
            return ResultVoUtil.fail(ExceptionEnum.LOGICAL_HTML_ERROR, cuoWuXinXi.toString());
        }
        dao.piLiangSheZhiTingZhiShiJian(param.getActOrderNoList(), TokenUtil.getTokenUserId(), param.getEndTime());
        return ResultVoUtil.success(ExceptionEnum.SUCCESS_AND_NOTIFICATION);
    }


}