<style lang="less" scoped>
// @import "../../less/admin.less";
#AddRuleContent {
  width: 100%;
  min-width: 1000px;
  padding: 20px;
  padding-top: 50px;
  padding-bottom: 0;
  box-sizing: border-box;
  .table_form {
    width: 100%;
    box-sizing: border-box;
    background: #fff;
    padding: 20px;
    padding-bottom: 0;
    display: flex;
    flex-wrap: wrap;
    .table_cell {
      flex: 1;
      min-width: 25%;
    }
  }
  /deep/ .el-input--mini .el-input__inner,
  .el-select {
    width: 100%;
    font-size: 14px;
  }
  .tip_text {
    // margin-top: -8px;
    font-size: 12px;
    color: red;
    line-height: 16px;
    // transform: scale(.8, .8);
  }
  .form_btn {
    width: 100%;
    background: #fff;
    padding-bottom: 20px;
    text-align: center;
  }
  /deep/ .el-form-item.is-success .el-input__inner,
  .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  /deep/ .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  /deep/ .el-form-item.is-success .el-textarea__inner {
    border-color: #c9c9c9 !important;
  }
  .my_error {
    position: absolute;
    top: 0;
    left: -16px;
    img {
      width: 12px;
      height: 12px;
      cursor: pointer;
    }
  }
}
</style>
<style lang="less">
.popper_class {
  // background: #fff !important;
  border: 1px solid #ffa0a0 !important;
  color: #999999 !important;
  padding: 3px 50px 3px 10px !important;
  margin-left: -10px;
}
.popper__arrow {
  border-top-color: #ffa0a0 !important;
}
</style>
<template>
  <div>
    <crumbs :title="title" :param="$route.params" linkTo="ZskRuleManager"></crumbs>
    <div id="AddRuleContent">
      <el-form size="mini" :model="form" ref="ruleForm">
        <div class="table_form">
          <div class="table_cell">
            <!-- 规则名称 -->
            <el-form-item
              label-width="130px"
              label="规则名称："
              :rules="rules.parDescription"
              prop="parDescription"
            >
              <el-input style="width: 100%" v-model.trim="form.parDescription" />
            </el-form-item>
          </div>

          <div class="table_cell">
            <!-- 规则类型 -->
            <el-form-item
              label-width="130px"
              label="规则类型："
              :rules="rules.parRuleType"
              prop="parRuleType"
            >
              <el-select v-model="form.parRuleType" placeholder="请选择" @change="ruleTypeChange">
                <el-option
                  v-for="item in ruleTypeList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.id"
                ></el-option>
              </el-select>
              <template slot="error" slot-scope="scope">
                <div class="my_error">
                  <el-tooltip
                    class="item"
                    effect="light"
                    :content="scope.error"
                    placement="top-start"
                    popper-class="popper_class"
                  >
                    <img src="../../images/exclamationpoint.png" alt />
                  </el-tooltip>
                </div>
              </template>
              <div class="tip_text">注：更改规则类型，将会清空已填写的规则内容~</div>
            </el-form-item>
          </div>
          <div class="table_cell">
            <!-- 规则术语类型： -->
            <el-form-item
              label-width="130px"
              label="规则术语类型："
              :rules="rules.parLenCode"
              prop="parLenCode"
            >
              <template slot="error" slot-scope="scope">
                <div class="my_error">
                  <el-tooltip
                    class="item"
                    effect="light"
                    :content="scope.error"
                    placement="top-start"
                    popper-class="popper_class"
                  >
                    <img src="../../images/exclamationpoint.png" alt />
                  </el-tooltip>
                </div>
              </template>
              <el-select v-model="form.parLenCode" placeholder="请选择" @change="ruleTermChange">
                <el-option
                  v-for="item in ruleTermTypeList"
                  :key="item.id"
                  :label="item.name"
                  :value="item.code"
                ></el-option>
              </el-select>
              <div class="tip_text">注：更改规则术语类型，将会清空已填写的规则内容~</div>
            </el-form-item>
          </div>
          <div class="table_cell">
            <el-form-item
              label-width="130px"
              label="医学标准术语："
              :style="{ height: '100%' }"
              :rules="rules.parConceptId"
              prop="parConceptId"
            >
              <el-select
                clearable
                filterable
                remote
                :remote-method="searchConcept"
                v-model.trim="form.parConceptId"
                @change="parConceptIdChange"
              >
                <el-option
                  v-for="item in conceptList"
                  :key="item.conceptId"
                  :label="item.conceptName"
                  :value="item.conceptId"
                  :title="item.conceptName"
                ></el-option>
              </el-select>
            </el-form-item>
          </div>
          <div class="table_cell" v-if="showHasSub" style="max-width: 25%">
            <el-form-item
              label-width="130px"
              label="有无子条件："
              :rules="rules.parHasSub"
              prop="parHasSub"
            >
              <el-select v-model="form.parHasSub" placeholder="请选择" @change="hasSubChange">
                <el-option label="有" :value="1"></el-option>
                <el-option label="无" :value="0"></el-option>
              </el-select>
            </el-form-item>
          </div>
          <!-- <div
            class="table_cell"
            style="flex: 3; max-width: 50%"
            v-if="showMsg"
          >
          
            <el-form-item
              label-width="130px"
              label="附加信息："
              :rules="rules.parMsg"
              prop="parMsg"
            >
              <el-input
                type="textarea"
                :rows="1"
                placeholder="请输入附加信息"
                v-model.trim="form.parMsg"
              ></el-input>
            </el-form-item>
          </div>-->
        </div>
        <!-- 表格 -->
        <AddNewRuleTable
          ref="tableView"
          v-if="form.parHasSub && tableShow"
          :klRuleByIdSub="form.klRuleByIdSub"
          :maxNum="subRuleMaxNum"
          :showMsg="showMsg"
          :showMsg2="showMsg2"
          :ruleTermCodeStr="ruleTermCodeStr"
          @subTypeChange="subTypeChange"
          @searchConcept="searchConcept"
          @addGroup="addGroup"
          @delGroup="delGroup"
          @delGroupChild="delGroupChild"
          @setFormData="setFormData"
          @editKlRuleByIdSub="editKlRuleByIdSub"
          @clearValidate="clearValidate"
          @childClearConcept="childClearConcept"
          @childClearNumText="childClearNumText"
          @ChildDataTypeChange="ChildDataTypeChange"
          @childSubCodeChange="childSubCodeChange"
        />
        <el-form-item>
          <div class="form_btn">
            <el-button type="primary" size="medium " @click="submitForm('ruleForm')">确定</el-button>
          </div>
        </el-form-item>
      </el-form>
    </div>
  </div>
</template>
<script type="text/javascript">
import api from "@api/knowledgeLib.js";
import { formRules } from "./rules";
import AddNewRuleTable from "./AddNewRuleTable";
export default {
  name: "AddRule",
  data() {
    return {
      title: "规则维护-添加规则",
      ruleTypeList: [], //规则类型列表  1
      ruleTermTypeList: [], //规则术语类型列表  2
      conceptList: [], //医学标准术语列表 3
      baseTypeList: [], //基础规则类型列表  4
      baseTermTypeList: [], //基础规则术语类型 5
      subRuleMaxNum: null, //规则内容中规则的限制个数
      isCopy: false,
      parId: null,
      msgDict: "", //显示附加信息的类型
      firstPlace: null,
      tableShow: true,
      form: {
        parDescription: "",
        parRuleType: "",
        parConceptId: "",
        parlibName: "",
        parLenName: "",
        parHasSub: undefined,
        parLenCode: "",
        klRuleByIdSub: [],
      },
      rules: formRules,
      dragVal: null,
      dragArr: null,
    };
  },
  created() {
    this.getTypeList();
    this.setDict();
    const param = this.$route.params;
    let info = param.data;
    if (info) {
      this.parId = info.parId;
      this.isCopy = param.copy;
      this.title = "规则维护-" + (this.isCopy ? "复制" : "修改") + "规则";
      this.getDragData(info);
      // 编辑初始化选择框

      this.initEdidData();
    }
  },
  methods: {
    clearValidate(data) {
      this.$refs.ruleForm.clearValidate(data);
    },
    // 编辑初始化
    async initEdidData() {
      // 规则术语类型初始化
      const newruleTermTypeList = await this.ruleTypeList.find(
        (it) => it.id == this.form.parRuleType
      );
      this.ruleTermTypeList = await newruleTermTypeList.subMenuList;
      // 基础规则类型初始化
      const obj = await this.ruleTermTypeList.find(
        (it1) => it1.code == this.form.parLenCode
      );
      this.baseTypeList = obj.subMenuList;
      this.subRuleMaxNum = obj.number;

      this.conceptList = [
        {
          conceptName: this.form.parlibName,
          conceptId: this.form.parConceptId,
        },
      ];
      if (this.form.parConceptId && this.checkFirstPlace && this.conceptList) {
        this.firstPlace = this.conceptList.find(
          (it) => it.conceptId === this.form.parConceptId
        );
        if (this.firstPlace) {
          this.firstPlace["checkedType"] = this.ruleTermCodeStrs;
        }
      } else if (!this.form.parConceptId) {
        this.setInitGroupData();
        this.firstPlace = null;
      } else {
        this.firstPlace = null;
      }
      await this.form.klRuleByIdSub.forEach((item, i, arr) => {
        item.groupId = "groupId" + item.groupType;
        item.groupChildId = "child" + item.subId;
        //TODO => 赋值时一定要注意set更新页面
        this.$set(item, "baseTypes", [...this.baseTypeList]);
        // this.$set(key, "baseTypes", [...this.baseTypeList]);
        this.$set(
          item,
          "baseTermTypeList",
          item.baseTypes.find((it2) => it2.type === item.subType).subMenuList
        );
        this.$set(item, "conceptList", [
          {
            conceptName: item.subLibName || item.subConceptName,
            conceptId: item.subConceptId,
          },
        ]);
        if (item.subMaxOperator || item.subMinOperator) {
          item.dataType = "1";
        } else if (item.subEqValue) {
          item.dataType = "2";
        }
        // disable
        if (this.form.parHasSub && this.firstPlace) {
          const del =
            localStorage
              .getItem("zskDelDict")
              .match(
                new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
              ) || [];
          if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
            this.$set(item, "disabled", false);
            if (del.length > 0 && item.subType == del[0].split("-")[2]) {
              const delType = del[0].split("-");
              const types = del[0].split("-");
              const subobj = this.baseTypeList.find(
                (it) => it.type == types[2]
              );
              const screenArr = subobj.subMenuList.filter((item) => {
                return !types[3].includes(item.code);
              });
              this.$set(item, "baseTermTypeList", screenArr);
            }
          } else {
            this.$set(item, "disabled", true);
          }
        }
        const dragDel =
          localStorage
            .getItem("zskDragDict")
            .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
        //药品开单合理判断
        if (dragDel.length > 0) {
          const obj = this.baseTypeList.find((it) => it.type === 1);
          if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
            let klRuleByIdSub = this.form.klRuleByIdSub;
            klRuleByIdSub.forEach((item, i, arr) => {
              if (arr[i].key != 0) {
                const arr = this.baseTypeList.filter((it) => {
                  return it.type == 1;
                });
                if (i > 0) {
                  this.$set(item, "baseTypes", arr);
                }
              }
            });
            if (item.key == 2) {
              //获取互斥项code
              const list = obj.subMenuList.filter((it) => {
                return (
                  it.code == arr[i - 1].subLenCode &&
                  it.remark.split("|")[0] == 3
                );
              });
              const dragArr = list[0].remark.split("|")[1].split(",");
              this.dragArr = dragArr;
              this.dragVal = item.subLenCode;
              item.dragArr = dragArr
              //取出互斥项
              const screenArr = obj.subMenuList.filter((item) =>
                dragArr.some(
                  (ele) => ele === item.code && item.remark.split("|")[0] == 3
                )
              );
              this.$set(item, "baseTermTypeList", screenArr);
            } else {
              const screenArr = obj.subMenuList.filter((it) => {
                if (it.remark == "") {
                  return it;
                } else {
                  return it.remark.split("|")[0] == (item.key % 3) + 1;
                }
              });

              this.$set(item, "baseTermTypeList", screenArr);
            }
          }
          console.log(this.form);
        }
      });
    },
    //药品数据处理
    getDragData(info) {
      let dataArr = [];
      let arr = JSON.parse(JSON.stringify(info.klRuleByIdSub));
      arr.map((mapItem) => {
        if (dataArr.length == 0) {
          dataArr.push({ groupType: mapItem.groupType, List: [mapItem] });
        } else {
          let res = dataArr.some((item) => {
            //判断相同日期，有就添加到当前项
            if (item.groupType == mapItem.groupType) {
              item.List.push(mapItem);
              return true;
            }
          });
          if (!res) {
            //如果没找相同日期添加一个新对象
            dataArr.push({ groupType: mapItem.groupType, List: [mapItem] });
          }
        }
      });
      this.getDragData2(info, dataArr);
    },
    getDragData2(info, dataArr) {
      let arr = [];
      dataArr.map((item) => {
        item.List.map((it, i) => {
          it.key = i;
          it.del = i == 0 ? true : false;
          arr.push(it);
        });
      });
      info.klRuleByIdSub = arr;
      this.form = JSON.parse(JSON.stringify(info));
    },
    // 提交
    submitForm(formName) {
      this.$refs[formName].validate((valid) => {
        if (valid) {
          let params = JSON.parse(JSON.stringify(this.form));
          params.klRuleInfoSaveSub = params.klRuleByIdSub;
          delete params.klRuleByIdSub;
          params.klRuleInfoSaveSub.forEach((item, i, arr) => {
            if (i === 0) {
              item.groupType = 1;
            } else {
              if (item.groupId == arr[i - 1].groupId) {
                item.groupType = arr[i - 1].groupType;
                item.subMsg = arr[i - 1].subMsg;
              } else {
                item.groupType = arr[i - 1].groupType + 1;
              }
            }
          });
          params.klRuleInfoSaveSub.forEach((ite) => {
            delete ite.groupId;
            delete ite.groupChildId;
            delete ite.rowIndex;
            delete ite.baseTypes;
            delete ite.baseTermTypeList;
            delete ite.conceptList;
          });
          if (this.parId) {
            params.parId = this.isCopy ? undefined : this.parId;
            params.parStatus = this.isCopy ? 1 : this.form.parStatus;
          }
          this.saveRule(params);
        } else {
          return false;
        }
      });
    },
    // 子集修改父级的数组
    setFormData(index, data) {
      this.$set(this.form.klRuleByIdSub[index], "conceptList", data);
    },
    // table_form 规则类型选中
    ruleTypeChange(val) {
      this.form.parLenCode = "";
      const obj = this.ruleTypeList.find((it) => it.id === val);
      this.ruleTermTypeList = obj.subMenuList;
      this.subRuleMaxNum = undefined;
      this.setInitGroupData();
    },
    // table_form 规则术语类型选中
    ruleTermChange(val) {
      const obj = this.ruleTermTypeList.find((it) => it.code === val);
      this.form.parLenName = obj.name;
      this.baseTypeList = obj.subMenuList;
      this.subRuleMaxNum = obj.number;
      this.form.parHasSub = obj.subMenuList.length ? 1 : 0;
      this.setInitGroupData();
    },
    // 医学标准术语
    parConceptIdChange(val) {
      this.$nextTick(() => {
        if (val && this.checkFirstPlace && this.conceptList) {
          this.firstPlace = this.conceptList.find((it) => it.conceptId === val);
          if (this.firstPlace) {
            this.firstPlace["checkedType"] = this.ruleTermCodeStrs;
          }
        } else if (!val) {
          this.setInitGroupData();
          this.firstPlace = null;
        } else {
          this.firstPlace = null;
        }
        if (this.form.parHasSub && this.firstPlace) {
          const dict =
            localStorage
              .getItem("zskDicts")
              .match(new RegExp(this.firstPlace.checkedType + "-\\d+", "g")) ||
            [];
          const del =
            localStorage
              .getItem("zskDelDict")
              .match(
                new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
              ) || [];
          const types = dict[0].split("-");
          let obj = this.form.klRuleByIdSub;
          obj.forEach((item, i, arr) => {
            if (arr[i - 1] && arr[i - 1].groupId == item.groupId) {
              this.$set(item, "disabled", false);
              if (del.length > 0) {
                const delType = del[0].split("-");
                if (
                  item.subType == delType[2] ||
                  item.subLenCode == delType[3]
                ) {
                  this.$set(this.form.klRuleByIdSub, i, {
                    groupId: item.groupId,
                    groupChildId: "child" + new Date().valueOf(),
                    baseTypes: this.baseTypeList,
                    baseTermTypeList: [],
                    conceptList: [],
                    subDescription: "",
                    parRuleType: "",
                    subConceptId: "",
                    subType: "",
                    subMaxOperator: "",
                    subMaxUnit: "",
                    subMaxValue: "",
                    subMinOperator: "",
                    subMinUnit: "",
                    subMinValue: "",
                    subEqValue: "",
                    subLenCode: "",
                    dataType: "",
                    key: 0,
                  });
                }
              }
            } else {
              this.$set(item, "disabled", true);
              this.$set(item, "subType", parseInt(types[2]));
              const subobj = this.baseTypeList.find(
                (it) => it.type == types[2]
              );
              this.$set(item, "baseTermTypeList", subobj.subMenuList);
              this.$set(item, "subLenCode", types[1]);
              this.$set(item, "subDescription", this.firstPlace.conceptName);
              this.$set(item, "subConceptId", this.firstPlace.conceptId);
              this.$set(item, "subConceptName", this.firstPlace.conceptName);
              this.$set(item, "conceptList", [this.firstPlace]);
            }
          });
          this.$set(this.form, "klRuleByIdSub", obj);
        }
      });
    },
    // 初始化表格
    setInitGroupData(init) {
      this.tableShow = false;
      const date = new Date().valueOf();
      this.$nextTick(() => {
        if (this.form.parHasSub && this.form.parHasSub != 0) {
          this.$set(this.form, "klRuleByIdSub", [
            {
              groupId: date,
              groupChildId: "child" + new Date().valueOf(),
              baseTypes: this.baseTypeList,
              baseTermTypeList: [],
              conceptList: [],
              subDescription: "",
              parRuleType: "",
              subConceptId: "",
              subType: "",
              subMaxOperator: "",
              subMaxUnit: "",
              subMaxValue: "",
              subMinOperator: "",
              subMinUnit: "",
              subMinValue: "",
              subEqValue: "",
              subLenCode: "",
              dataType: "",
              key: 0,
              del: true,
            },
          ]);
        } else {
          this.$set(this.form, "klRuleByIdSub", []);
        }
        if (!init) {
          this.form.parConceptId = ""; //医学标准术语清空
          this.conceptList = []; //下拉列表清空
          this.firstPlace = null;
        }
        this.tableShow = true;
      });
    },
    // 有无子条件切换
    hasSubChange(val) {
      if (val) {
        this.setInitGroupData(true);
      } else {
        this.form.klRuleByIdSub = [];
      }
    },
    // 基础规则类型切换
    subTypeChange(val, index, groupId, key) {
      // index
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      const obj = this.baseTypeList.find((it) => it.type === val);
      let dragType = false;
      let isDel = false;
      let screenArr;
      let type;
      //药品开单合理判断
      if (dragDel.length > 0) {
        dragType = true;
        const types = dragDel[0].split("-");
        const arr = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId == groupId;
        });
        if (key == 1 && arr[2]) {
          type = arr[2].subLenCode == "" ? false : true;
        } else if (key == 2) {
          type = arr[1].subLenCode == "" ? false : true;
        }
        if (arr.length == 3 && key != 0 && type) {
          //获取互斥项code
          const val = key==1?arr[2].subLenCode:arr[1].subLenCode
          const list = obj.subMenuList.filter((it) => {
            return it.code ==val && it.remark.split("|")[0] == 3;
          });
          console.log(obj.subMenuList);
          const dragArr = list[0].remark.split("|")[1].split(",");
          this.dragArr = dragArr;
          arr[1].dragArr = arr[2].dragArr = dragArr;
          //取出互斥项
          screenArr = obj.subMenuList.filter((item) =>
            dragArr.some(
              (ele) => ele === item.code && item.remark.split("|")[0] == 3
            )
          );
        } else {
          screenArr = obj.subMenuList.filter((item) => {
            if (item.remark == "") {
              return item;
            } else {
              return item.remark.split("|")[0] == (key % 3) + 1;
            }
          });
        }
        // const klRuleByIdSub = this.form.klRuleByIdSub;
        // klRuleByIdSub.forEach((item, i) => {
        //   arr.forEach((it) => {
        //     if (item.groupId == it.groupId) {
        //       if (key == 0) {
        //         this.$set(item, "baseTypes", this.baseTypeList);
        //       } else {
        //          const arrList = this.baseTypeList.filter((it) => {
        //           return it.type == 1;
        //         });
        //         if (i > 0) {
        //           this.$set(item, "baseTypes", arrList);
        //         }
        //       }
        //     }
        //   });
        // });
      }
      //危急值实验室子项目已选医学标准术语判断
      if (this.form.parHasSub && this.firstPlace) {
        const del =
          localStorage
            .getItem("zskDelDict")
            .match(
              new RegExp(this.firstPlace.checkedType + "-\\d+" + "-\\d+", "g")
            ) || [];
        if (del.length > 0) {
          isDel = true;
          const types = del[0].split("-");
          const subobj = this.baseTypeList.find((it) => it.type == types[2]);
          screenArr = subobj.subMenuList.filter((item) => {
            return !types[3].includes(item.code);
          });
        }
      }
      this.$set(
        this.form.klRuleByIdSub[index],
        "baseTermTypeList",
        (isDel && val == 1) || dragType ? screenArr : obj.subMenuList
      );
      this.$set(this.form.klRuleByIdSub[index], "subLenCode", "");
      this.$set(this.form.klRuleByIdSub[index], "dataType", "");

      this.clearConcept(index);
      this.clearNumText(index);
    },
    clearConcept(index) {
      this.$set(this.form.klRuleByIdSub[index], "subConceptId", "");
      this.conceptList = [];
    },
    clearNumText(index) {
      this.$set(this.form.klRuleByIdSub[index], "subMaxOperator", "");
      this.$set(this.form.klRuleByIdSub[index], "subMaxValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subMaxUnit", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinOperator", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subMinUnit", "");
      this.$set(this.form.klRuleByIdSub[index], "subEqValue", "");
      this.$set(this.form.klRuleByIdSub[index], "subEqOperator", "");
    },
    editKlRuleByIdSub(data) {
      this.$set(this.form, "klRuleByIdSub", data);
      // this.form.klRuleByIdSub = data;
    },
    // 添加分组 || 规则
    addGroup(date, key, arg = { index: null, groupId: null }) {
      /**
       * @params
       *    date:存在则添加规则 不存在则添加分组
       *    arg:{index:添加规则用索引，groupId:添加分组用确切id}
       */
      !date && (date = new Date().valueOf());
      const obj = {
        groupId: date,
        groupChildId: "child" + new Date().valueOf(),
        baseTypes: this.baseTypeList,
        baseTermTypeList: [],
        conceptList: [],
        subDescription: "",
        parRuleType: "",
        subConceptId: "",
        subType: "",
        subMaxOperator: "",
        subMaxUnit: "",
        subMaxValue: "",
        subMinOperator: "",
        subMinUnit: "",
        subMinValue: "",
        subEqValue: "",
        subLenCode: "",
        dataType: "",
      };

      if (typeof arg.index == "number") {
        // 添加规则 直接在当前位置之后添加
        this.form.klRuleByIdSub.splice(arg.index + 1, 0, obj);
        this.$set(obj, "del", false);
        const dragDel =
          localStorage
            .getItem("zskDragDict")
            .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
        if (dragDel.length > 0) {
          const len = this.form.klRuleByIdSub.filter((item, i) => {
            return item.groupId == date;
          });
          let obj = this.form.klRuleByIdSub;
          obj.forEach((item, i, arr) => {
            len.forEach((its, index) => {
              if (item.groupId == its.groupId) {
                this.$set(its, "key", index);
                if (its.key > 0 && index > 0) {
                  const arrList = this.baseTypeList.filter((it) => {
                    return it.type == 1;
                  });
                  this.$set(its, "baseTypes", arrList);
                }
              }
            });
          });
          if (len.length == 3 && (key == 1 || key == 0) && key==0?len[2].subLenCode:len[1].subLenCode) {
            const dragVal = key==0?len[2].subLenCode:len[1].subLenCode
            this.dragVal =dragVal;
            const subobj = this.baseTypeList.find((it) => it.type == 1);
            const list = subobj.subMenuList.filter((it) => {
              return (
                it.code == dragVal && it.remark.split("|")[0] == 3
              );
            });
            // //获取互斥项code
            const dragArr = list[0].remark.split("|")[1].split(",");
            len[1].dragArr = len[2].dragArr = dragArr;
          }
        }
      } else {
        // 添加分组 在列表中相同groupId之后添加
        // 添加分组时判断是否需要加disabled和添加默认值
        if (this.form.parHasSub && this.firstPlace) {
          obj.disabled = true;
          const dict =
            localStorage
              .getItem("zskDicts")
              .match(new RegExp(this.firstPlace.checkedType + "-\\d+", "g")) ||
            [];
          const types = dict[0].split("-");
          this.$set(obj, "disabled", true);
          this.$set(obj, "subType", parseInt(types[2]));
          const subobj = this.baseTypeList.find((it) => it.type == types[2]);
          this.$set(obj, "baseTermTypeList", subobj.subMenuList);
          this.$set(obj, "subLenCode", types[1]);
          this.$set(obj, "subDescription", this.firstPlace.conceptName);
          this.$set(obj, "subConceptId", this.firstPlace.conceptId);
          this.$set(obj, "subConceptName", this.firstPlace.conceptName);
          this.$set(obj, "conceptList", [this.firstPlace]);
        }
        var i = -1;
        this.form.klRuleByIdSub.forEach((item, inx) => {
          if (item.groupId === arg.groupId) {
            i = inx;
          }
        });
        this.form.klRuleByIdSub.splice(i + 1, 0, obj);
        this.$set(obj, "del", true);
        this.$set(obj, "key", 0);
        this.dragArr = null;
      }
      this.$nextTick(() => {
        this.$refs.tableView.scrollFun();
      });
    },
    // 删除分组
    delGroup(groupId) {
      const list = this.form.klRuleByIdSub.filter(
        (item) => item.groupId != groupId
      );
      this.form.klRuleByIdSub = list;
    },
    // 删除规则
    delGroupChild(groupChildId, index, groupId, del, key, lens) {
      let newGroupList;
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      let list;
      if (dragDel.length > 0) {
        const arr = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId != groupId;
        });
        const len = this.form.klRuleByIdSub.filter((item, i) => {
          return item.groupId == groupId;
        });
        if (del) {
          const date = new Date().valueOf();
          if (key == 0 && arr.length > 0) {
            newGroupList = this.form.klRuleByIdSub.filter((item, i) => {
              return item.groupId != groupId;
            });
          } else {
            newGroupList = [
              {
                groupId: date,
                groupChildId: "child" + new Date().valueOf(),
                baseTypes: this.baseTypeList,
                baseTermTypeList: [],
                conceptList: [],
                subDescription: "",
                parRuleType: "",
                subConceptId: "",
                subType: "",
                subMaxOperator: "",
                subMaxUnit: "",
                subMaxValue: "",
                subMinOperator: "",
                subMinUnit: "",
                subMinValue: "",
                subEqValue: "",
                subLenCode: "",
                dataType: "",
                key: 0,
                del: true,
              },
            ];
            this.dragVal = null;
            this.dragArr = null;
          }
        } else if (key == 1) {
          let klRuleByIdSub = JSON.parse(
            JSON.stringify(this.form.klRuleByIdSub)
          );
          for (let i = klRuleByIdSub.length - 1; i >= 0; i--) {
            if (
              klRuleByIdSub[i].groupId == groupId &&
              klRuleByIdSub[i].key > 0
            ) {
              klRuleByIdSub.splice(i, 1);
            }
          }
          newGroupList = klRuleByIdSub;
          this.dragVal = null;
          this.dragArr = null;
        } else {
          newGroupList = this.form.klRuleByIdSub.filter(
            (item) => item.groupChildId != groupChildId
          );
          if (lens == 4) {
            const obj = this.baseTypeList.find((it) => it.type === 1);
            const screenArr = obj.subMenuList.filter((item) => {
              return item.remark.split("|")[0] == 2;
            });
            len[1].baseTermTypeList = screenArr;
          }
          
          this.dragVal = len[1].subLenCode;
        }
      } else {
        newGroupList = this.form.klRuleByIdSub.filter(
          (item) => item.groupChildId != groupChildId
        );
      }
      this.form.klRuleByIdSub = newGroupList;
    },
    setDict() {
      this.dict = localStorage.getItem("zskDicts");
      this.msgDict = localStorage.getItem("zskMsgDict");
      this.subDict = localStorage.getItem("zskSubDict");
    },
    showConfirmDialog(msg, resolve) {
      this.$alert(msg, "提示", {
        confirmButtonText: "确定",
        type: "warning",
      })
        .then(() => {
          resolve();
        })
        .catch(() => {});
    },
    searchConcept(val) {
      const param = {
        excludedConceptIds: [this.form.parRuleType],
        libType: this.form.parLenCode,
        name: val,
      };
      api
        .searchConcept(param)
        .then((res) => {
          if (res.data.code == "0") {
            const data = res.data.data;
            this.conceptList = data;
          }
        })
        .catch((error) => {
          console.log(error);
        });
    },
    getTypeList() {
      this.ruleTypeList = JSON.parse(localStorage.getItem("zskTypesList"));
    },
    saveRule(params) {
      api.saveRule(params).then((res) => {
        if (res.data.code == 0) {
          this.$message({
            message: "操作成功",
            type: "success",
          });
          this.$router.push({
            name: "ZskRuleManager",
            params: Object.assign({}, this.$route.params, { currentPage: 1 }),
          });
        } else {
          this.$message({
            message: res.data.msg,
            type: "warning",
          });
        }
      });
    },
    /**
     * 子组件调用方法
     */
    childClearConcept(index) {
      this.$set(this.form.klRuleByIdSub[index], "subConceptId", "");
      this.$set(this.form.klRuleByIdSub[index], "conceptList", []);
    },
    childClearNumText(index) {
      let obj = JSON.parse(JSON.stringify(this.form.klRuleByIdSub));
      obj[index].subMaxOperator = "";
      obj[index].subMaxValue = "";
      obj[index].subMaxUnit = "";
      obj[index].subMinOperator = "";
      obj[index].subMinValue = "";
      obj[index].subMinUnit = "";
      obj[index].subEqValue = "";
      // this.$set(obj[index], "subEqValue", "");
      obj[index].subEqOperator = "";
      // this.klRuleByIdSub = obj;
      // this.$emit("editKlRuleByIdSub", obj);
      this.editKlRuleByIdSub(obj);
    },
    ChildDataTypeChange(val, index) {
      this.form.klRuleByIdSub[index].subEqOperator = val === "2" ? "=" : "";
      this.$set(
        this.form.klRuleByIdSub[index],
        "subEqOperator",
        val === "2" ? "=" : ""
      );

      this.childClearNumText(index);
      // TODO 新增的内容追踪不到
      this.form.klRuleByIdSub.forEach((item, i) => {
        if (index === i) {
          this.$set(item, "dataType", val);
        }
      });
    },
    childSubCodeChange(val, index, numTypes, groupId, key, code, lens) {
      const dragDel =
        localStorage
          .getItem("zskDragDict")
          .match(new RegExp(this.ruleTermCodeStrs, "g")) || [];
      const subobj = this.baseTypeList.find((it) => it.type == 1);
      let obj = this.form.klRuleByIdSub;
      let type;
      const len = this.form.klRuleByIdSub.filter((item, i) => {
        return item.groupId == groupId;
      });
      const inx = key % 3 == 2 ? index - 1 : key % 3 == 1 ? index + 1 : index;
      if (key == 1 && len[2]) {
        type = len[2].subLenCode == "" ? false : true;
      } else if (key == 2) {
        type = len[1].subLenCode == "" ? false : true;
      }
      //判断药品合理性总条数是否大于1条,是否存在第二条或第三条类型为1,存在触发互斥
      if (
        //判断3条规则是否都已选中
        dragDel.length > 0 &&
        len.length == 3 &&
        index > 0 &&
        key > 0
      ) {
        if (type) {
          //判断是否存在符合互斥条件的两条出具,若存在,置空另一条出具
          if (
            code != "" &&
            (key == 1
              ? len[2].dragArr.indexOf(val)
              : len[1].dragArr.indexOf(val)) > -1 &&
            lens == 4
          ) {
            //剂型给药途径互斥判断
            const arr = this.baseTypeList.filter((it) => {
              return it.type == 1;
            });
            this.$set(this.form.klRuleByIdSub, inx, {
              groupId: this.form.klRuleByIdSub[inx].groupId,
              groupChildId: "child" + new Date().valueOf(),
              baseTypes: arr,
              baseTermTypeList: [],
              conceptList: [],
              subDescription: "",
              parRuleType: "",
              subConceptId: "",
              subType: "",
              subMaxOperator: "",
              subMaxUnit: "",
              subMaxValue: "",
              subMinOperator: "",
              subMinUnit: "",
              subMinValue: "",
              subEqValue: "",
              subLenCode: "",
              dataType: "",
              del: false,
              key: key == 2 ? 1 : 2,
            });
          }
        } else {
          const list = subobj.subMenuList.filter((it) => {
            return it.code == val && it.remark.split("|")[0] == 3;
          });
          //获取互斥项code
          const dragArr = list[0].remark.split("|")[1].split(",");
          this.dragArr = dragArr;
          len[1].dragArr = dragArr;
          len[2].dragArr = dragArr;
          // if (len[1]) {
          //   len[1].dragArr = dragArr;
          // } else if (len[2]) {
          //   len[2].dragArr = dragArr;
          // }
          //获取互斥项
          const screenArr = subobj.subMenuList.filter((item) =>
            dragArr.some(
              (ele) => ele === item.code && item.remark.split("|")[0] == 3
            )
          );
          if (
            this.form.klRuleByIdSub[inx] &&
            this.form.klRuleByIdSub[inx].subType != ""
          ) {
            this.$set(
              this.form.klRuleByIdSub[inx],
              "baseTermTypeList",
              screenArr
            );
          }
        }
        this.dragVal = val;
      }
      if ((numTypes + ",").indexOf(val + ",") > -1) {
        this.$set(this.form.klRuleByIdSub[index], "dataType", "1");
      } else {
        this.$set(this.form.klRuleByIdSub[index], "dataType", "");
      }
      this.childClearConcept(index);
      this.childClearNumText(index);
    },
    // 去重
    unique(arr, obj) {
      return arr.reduce((cur, next) => {
        obj[next] ? "" : (obj[next] = true && cur.push(next));
        return cur;
      }, []);
    },
  },
  watch: {
    "form.klRuleByIdSub": {
      handler(val) {
        this.form.klRuleByIdSub.forEach((item, i, arr) => {
          if (i == 0) {
            item.rowIndex = 1;
          } else if (item.groupId == arr[i - 1].groupId) {
            item.rowIndex = arr[i - 1].rowIndex;
          } else {
            item.rowIndex = arr[i - 1].rowIndex + 1;
          }
        });
      },
      deep: true,
    },
  },
  computed: {
    disable: function() {
      return Object.keys(this.firstPlace || {}).length > 0;
    },
    ruleTermCodeStr: function() {
      const str = this.form.parRuleType + "-" + this.form.parLenCode + "-" + 1;
      if (str.length <= 1) {
        return "";
      }
      return str;
    },
    ruleTermCodeStr2: function() {
      const str = this.form.parRuleType + "-" + this.form.parLenCode + "-" + 0;
      if (str.length <= 1) {
        return "";
      }

      return str;
    },
    ruleTermCodeStrs: function() {
      const str = this.form.parRuleType + "-" + this.form.parLenCode;
      if (str.length <= 1) {
        return "";
      }
      return str;
    },
    showMsg: function() {
      return (
        this.ruleTermCodeStr.length > 2 &&
        this.msgDict.indexOf(this.ruleTermCodeStr) > -1
      );
    },
    showMsg2: function() {
      return (
        this.ruleTermCodeStr2.length > 2 &&
        this.msgDict.indexOf(this.ruleTermCodeStr2) > -1
      );
    },
    showHasSub() {
      if (this.ruleTermCodeStrs.length > 2) {
        return this.subDict.indexOf(this.ruleTermCodeStrs) != -1;
      }
      return false;
    },
    checkFirstPlace: function() {
      return this.dict.indexOf(this.ruleTermCodeStrs) > -1;
    },
  },
  components: { AddNewRuleTable },
};
</script>
