<template>
    <!-- 工程管理 新增、编辑 表单组件 -->
    <div>
        <!-- 表单 1 -->
        <el-form
            label-width="130px"
            size="medium"
            ref="projectParamsRef1"
            :model="projectParams1"
            :rules="projectParams1Rules"
            v-if="formCount === 116"
        >
          <el-form-item label="配置名称" prop="configName" required>
            <el-input :maxlength="50" v-model="projectParams1.configName" placeholder="请输入" />
          </el-form-item>
          <el-form-item label="温度阈值(°C)" required>
            <el-col :span="11">
              <el-form-item prop="configVal1Min">
                <el-input :maxlength="50" v-model="projectParams1.configVal1Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal1Max">
                <el-input :maxlength="50" v-model="projectParams1.configVal1Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="湿度阈值(%)" required>
            <el-col :span="11">
              <el-form-item prop="configVal2Min">
                <el-input :maxlength="50" v-model="projectParams1.configVal2Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal2Max">
                <el-input :maxlength="50" v-model="projectParams1.configVal2Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="噪声(分贝)" required>
            <el-col :span="11">
              <el-form-item prop="configVal3Min">
                <el-input :maxlength="50" v-model="projectParams1.configVal3Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal3Max">
                <el-input :maxlength="50" v-model="projectParams1.configVal3Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="PM2.5(μg/m3)" required>
            <el-col :span="11">
              <el-form-item prop="configVal4Min">
                <el-input :maxlength="50" v-model="projectParams1.configVal4Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal4Max">
                <el-input :maxlength="50" v-model="projectParams1.configVal4Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="PM10(μg/m3)" required>
            <el-col :span="11">
              <el-form-item prop="configVal5Min">
                <el-input :maxlength="50" v-model="projectParams1.configVal5Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal5Max">
                <el-input :maxlength="50" v-model="projectParams1.configVal5Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
        </el-form>
        <!-- 表单 2 -->
        <el-form
          label-width="130px"
          size="medium"
          ref="projectParamsRef2"
          :model="projectParams2"
          :rules="projectParams2Rules"
          v-if="formCount === 117"
        >
          <el-form-item label="配置名称" prop="configName" required>
            <el-input :maxlength="50" v-model="projectParams2.configName" placeholder="请输入" />
          </el-form-item>
          <el-form-item label="倾角阈值" required>
            <el-col :span="11">
              <el-form-item prop="configVal1Min">
                <el-input :maxlength="50" v-model="projectParams2.configVal1Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal1Max">
                <el-input :maxlength="50" v-model="projectParams2.configVal1Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
        </el-form>
        <!-- 表单 3 -->
        <el-form
          label-width="130px"
          size="medium"
          ref="projectParamsRef3"
          :model="projectParams3"
          :rules="projectParams3Rules"
          v-if="formCount === 118"
        >
          <el-form-item label="配置名称" prop="configName" required>
            <el-input :maxlength="50" v-model="projectParams3.configName" placeholder="请输入" />
          </el-form-item>
          <el-form-item label="拉力阈值" required>
            <el-col :span="11">
              <el-form-item prop="configVal1Min">
                <el-input :maxlength="50" v-model="projectParams3.configVal1Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal1Max">
                <el-input :maxlength="50" v-model="projectParams3.configVal1Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
        </el-form>
        <!-- 表单 4 -->
        <el-form
          label-width="160px"
          size="medium"
          ref="projectParamsRef4"
          :model="projectParams4"
          :rules="projectParams4Rules"
          v-if="formCount === 119"
        >
          <el-form-item label="配置名称" prop="configName" required>
            <el-input :maxlength="50" v-model="projectParams4.configName" placeholder="请输入" />
          </el-form-item>
          <el-form-item label="含氧量阈值(%VOL)" required>
            <el-col :span="11">
              <el-form-item prop="configVal1Min">
                <el-input :maxlength="50" v-model="projectParams4.configVal1Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal1Max">
                <el-input :maxlength="50" v-model="projectParams4.configVal1Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="一氧化碳阈值(ppm)" required>
            <el-col :span="11">
              <el-form-item prop="configVal2Min">
                <el-input :maxlength="50" v-model="projectParams4.configVal2Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal2Max">
                <el-input :maxlength="50" v-model="projectParams4.configVal2Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="可燃气体阈值(%LEL)" required>
            <el-col :span="11">
              <el-form-item prop="configVal3Min">
                <el-input :maxlength="50" v-model="projectParams4.configVal3Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal3Max">
                <el-input :maxlength="50" v-model="projectParams4.configVal3Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
          <el-form-item label="硫化氢阈值(ppm)" required>
            <el-col :span="11">
              <el-form-item prop="configVal4Min">
                <el-input :maxlength="50" v-model="projectParams4.configVal4Min" placeholder="请输入" />
              </el-form-item>
            </el-col>
            <el-col style="display: flex; justify-content: center" class="line" :span="2">-</el-col>
            <el-col :span="11">
              <el-form-item prop="configVal4Max">
                <el-input :maxlength="50" v-model="projectParams4.configVal4Max" placeholder="请输入" />
              </el-form-item>
            </el-col>
          </el-form-item>
        </el-form>

        <!--  新增-按钮群  -->
        <div
          v-if="subSort === 1"
          style="display: flex; justify-content: right"
        >
          <el-button type="success" @click="onSubmitAdd">确认</el-button>
          <el-button
            @click="
                () => {
                    this.$emit('closeDialog')
                }
            "
          >取消</el-button
          >
        </div>

        <!--  编辑-按钮群  -->
        <div
          v-if="subSort === 2"
          style="display: flex; justify-content: right"
        >
          <el-button type="success" @click="onSubmitEdit">确认</el-button>
          <el-button
            @click="
                () => {
                    this.$emit('closeDialog')
                }
            "
          >取消</el-button
          >
        </div>

    </div>
</template>

<script>
import {
  addWarningApi,
  editWarningApi
} from '@/api/base/warning'
export default {
    name: 'FormWarning',
    props: {
        editParams: {
            type: Object,
            default: () => null,
        },
        formCount: {
            type: Number,
            default: () => null
        }
    },
    components: {  },
    created() {

    },
    mounted() {
        if (this.editParams) {
          console.log(this.editParams)
            switch (this.formCount) {
              case 116:
                Object.assign(this.projectParams1, this.editParams)
                break;
              case 117:
                Object.assign(this.projectParams2, this.editParams)
                break;
              case 118:
                Object.assign(this.projectParams3, this.editParams)
                break;
              case 119:
                Object.assign(this.projectParams4, this.editParams)
                break;
            }
            this.subSort = 2
        } else {
            this.subSort = 1
        }
        console.log(this.editParams, this.formCount, this.subSort)
    },
    data() {
        return {
            subSort: '', // 提交类型：新增 1 / 修改 2
            projectParams1: {
              configName: undefined, // 配置名称
              configVal1Min: undefined, // 温度阈值min
              configVal1Max: undefined, // 温度阈值max
              configVal2Min: undefined, // 湿度阈值min
              configVal2Max: undefined, // 湿度阈值max
              configVal3Min: undefined, // 噪声min
              configVal3Max: undefined, // 噪声max
              configVal4Min: undefined, // PM2.5 min
              configVal4Max: undefined, // PM2.5 max
              configVal5Min: undefined, // PM10 min
              configVal5Max: undefined, // PM10 max
            },
            projectParams2: {
              configName: undefined, // 配置名称
              configVal1Min: undefined, // 倾角阈值min
              configVal1Max: undefined, // 倾角阈值max
            },
            projectParams3: {
              configName: undefined, // 配置名称
              configVal1Min: undefined, // 拉力阈值min
              configVal1Max: undefined, // 拉力阈值max
            },
            projectParams4: {
              configName: undefined, // 配置名称
              configVal1Min: undefined, // 含氧量阈值min
              configVal1Max: undefined, // 含氧量阈值max
              configVal2Min: undefined, // 一氧化碳阈值min
              configVal2Max: undefined, // 一氧化碳阈值max
              configVal3Min: undefined, // 可燃气体阈值min
              configVal3Max: undefined, // 可燃气体阈值max
              configVal4Min: undefined, // 硫化氢阈值min
              configVal4Max: undefined, // 硫化氢阈值max
            },
            // 校验规则
            projectParams1Rules: {
              configName: [
                  {
                      required: true,
                      message: '请输入配置名称',
                      trigger: 'blur',
                  },
              ],
              configVal1Min: [
                {
                  required: true,
                  message: '请输入温度阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
                    } else {
                      callback();
                    }
                    }else{
                      callback();
                  }
                },
                  trigger: 'blur'
                }
              ],
              configVal1Max: [
                {
                  required: true,
                  message: '请输入温度阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请正确输入温度阈值(小数点后最多保留两位)'));
                    } else {
                      callback();
                    }
                    }else{
                      callback();
                  }
                },
                  trigger: 'blur'
                }
              ],
              configVal2Min: [
                {
                  required: true,
                  message: '请输入湿度阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    console.log(value+"444444444444444")
                    console.log(valueTemp+"111111111111111")
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal2Max: [
                {
                  required: true,
                  message: '请输入湿度阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal3Min: [
                {
                  required: true,
                  message: '请输入噪声阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal3Max: [
                {
                  required: true,
                  message: '请输入噪声阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal4Min: [
                {
                  required: true,
                  message: '请输入PM2.5阈值',
                  trigger: 'blur',
                }, 
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal4Max: [
                {
                  required: true,
                  message: '请输入PM2.5阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal5Min: [
                {
                  required: true,
                  message: '请输入PM10阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal5Max: [
                {
                  required: true,
                  message: '请输入PM10阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
            },
            projectParams2Rules: {
              configName: [
                {
                  required: true,
                  message: '请输入配置名称',
                  trigger: 'blur',
                },
              ],
              configVal1Min: [
                {
                  required: true,
                  message: '请输入倾角阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 90) {
                      callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal1Max: [
                {
                  required: true,
                  message: '请输入倾角阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 90 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 90) {
                      callback(new Error('请输入0~90内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
            },
            projectParams3Rules: {
              configName: [
                {
                  required: true,
                  message: '请输入配置名称',
                  trigger: 'blur',
                },
              ],
              configVal1Min: [
                {
                  required: true,
                  message: '请输入拉力阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal1Max: [
                {
                  required: true,
                  message: '请输入拉力阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
            },
            projectParams4Rules: {
              configName: [
                {
                  required: true,
                  message: '请输入配置名称',
                  trigger: 'blur',
                },
              ],
              configVal1Min: [
                {
                  required: true,
                  message: '请输入含氧量阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal1Max: [
                {
                  required: true,
                  message: '请输入含氧量阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal2Min: [
                {
                  required: true,
                  message: '请输入一氧化碳阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal2Max: [
                {
                  required: true,
                  message: '请输入一氧化碳阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal3Min: [
                {
                  required: true,
                  message: '请输入可燃气体阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal3Max: [
                {
                  required: true,
                  message: '请输入可燃气体阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^[+-]?(\d+(\.\d*)?|\.\d*[1-9]\d*)$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请勿输入非数字'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 || valueTemp > 100 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 || valueTemp > 100) {
                      callback(new Error('请输入0~100内的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal4Min: [
                {
                  required: true,
                  message: '请输入硫化氢阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo = /^(0|[1-9]\d*)(\.\d{0,2})?$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
              configVal4Max: [
                {
                  required: true,
                  message: '请输入硫化氢阈值',
                  trigger: 'blur',
                },
                {
                  validator: (rule, value, callback) => {
                    if (value === '' || value === null) {
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const regexTwo =  /^(0|[1-9]\d*)(\.\d{0,2})?$/;
                    if(!regexTwo.test(value)){
                      return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    }
                    const valueTemp = parseFloat(value);
                    // 检查前导零（例如 '0000' 或 '000.000000'）
                    // if(valueTemp.toString()==="0")
                    // if (value !== valueTemp.toString() && value !== "0") {
                    //   return callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    // }
                    if(valueTemp.toString().includes('.')==true){
                      if (valueTemp < 0 ||valueTemp.toString().split(".")[1].length>2) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                    }else{
                      if (valueTemp < 0 ) {
                      callback(new Error('请输入大于零的数据且小数点后最多保留两位'));
                    } else {
                      callback();
                    }
                  }
                  trigger: 'blur'
                }
              }
              ],
            },
            // 各类下拉
            projRange: [],
            provinceRange: [],
            typeRange: [],
            numReg: /^\d+$/
        }
    },
    methods: {
        /** 校验数字 */
        // validateNum(rule, value, callback) {
        //   if(!this.numReg.test(value)) {
        //     callback(new Error('请输入数字'))
        //   } else {
        //     callback()
        //   }
        // },
        /** 改变树结构 */
        changeTree(leaf) {
          leaf.map(item => {
            item.value = item.id
            if(item.children) {
              this.changeTree(item.children)
            }
          })
          return leaf
        },
        /** 新增确认按钮 */
        onSubmitAdd() {
            switch (this.formCount) {
              case 116:
                this.$refs.projectParamsRef1.validate(valid => {
                  if(valid) {
                    this.projectParams1.configuType = this.formCount
                    console.log(this.projectParams1, 'form1')
                    this.handleAdd(this.projectParams1)
                  }
                })
                break;
              case 117:
                this.$refs.projectParamsRef2.validate(valid => {
                  if(valid) {
                    this.projectParams2.configuType = this.formCount
                    console.log(this.projectParams2, 'form2')
                    this.handleAdd(this.projectParams2)
                  }
                })
                break;
              case 118:
                this.$refs.projectParamsRef3.validate(valid => {
                  if(valid) {
                    this.projectParams3.configuType = this.formCount
                    console.log(this.projectParams3, 'form3')
                    this.handleAdd(this.projectParams3)
                  }
                })
                break;
              case 119:
                this.$refs.projectParamsRef4.validate(valid => {
                  if(valid) {
                    this.projectParams4.configuType = this.formCount
                    console.log(this.projectParams4, 'form4')
                    this.handleAdd(this.projectParams4)
                  }
                })
                break;
            }
        },
        async handleAdd(param) {
          let res = await addWarningApi(param)
          if(res.code === 200) {
            this.$modal.msgSuccess('操作成功')
            this.$emit('closeDialog', true)
          }
        },
        /** 新增确认按钮 */
        onSubmitEdit() {
          switch (this.formCount) {
            case 116:
              this.$refs.projectParamsRef1.validate(valid => {
                if(valid) {
                  this.projectParams1.configuType = this.formCount
                  console.log(this.projectParams1, 'form1')
                  this.handleEdit(this.projectParams1)
                }
              })
              break;
            case 117:
              this.$refs.projectParamsRef2.validate(valid => {
                if(valid) {
                  this.projectParams2.configuType = this.formCount
                  console.log(this.projectParams2, 'form2')
                  this.handleEdit(this.projectParams2)
                }
              })
              break;
            case 118:
              this.$refs.projectParamsRef3.validate(valid => {
                if(valid) {
                  this.projectParams3.configuType = this.formCount
                  console.log(this.projectParams3, 'form3')
                  this.handleEdit(this.projectParams3)
                }
              })
              break;
            case 119:
              this.$refs.projectParamsRef4.validate(valid => {
                if(valid) {
                  this.projectParams4.configuType = this.formCount
                  console.log(this.projectParams4, 'form4')
                  this.handleEdit(this.projectParams4)
                }
              })
              break;
          }
        },
        async handleEdit(param) {
          let res = await editWarningApi(param)
          if(res.code === 200) {
            this.$modal.msgSuccess('操作成功')
            this.$emit('closeDialog', true)
          }
        },
    },
}
</script>

<style scoped>
::v-deep .el-select {
    width: 100%;
}
::v-deep .el-form-item__label{
  font-weight: normal;
}
</style>
