const md5 = require('md5');
import {customClone} from "@/utils/xd.base";
import XdSelectList from "@/components/XdSelectList";
import XdSelectStatus from "@/components/XdSelectStatus";
import XdRange from "@/components/XdRange";
import XdRadioStatus from "@/components/XdRadioStatus";
import XdRadioList from "@/components/XdRadioList";
import XdSwitch from "@/components/XdSwitch";
import XdTransfer from "@/components/XdTransfer";
import XdUpload from "@/components/XdUpload";
import XdFontIcon from "@/components/XdFontIcon";
import XdCheckList from "@/components/XdCheckList";
import XdOverAddPrice from "@/components/XdOverAddPrice";
import XdSelectWeekTime from "@/components/XdSelectWeekTime";
import XdJsonView from "@/components/XdJsonView";
import XdRangeGroup from "@/components/XdRangeGroup";
import XdRemoteInput from "@/components/XdRemoteInput";
import XdRemoteCascader from "@/components/XdRemoteCascader";
import XdCascadeSelect from "@/components/XdCascadeSelect";
import XdTinymce from "@/components/XdTinymce";
import XdSetLabel from '@/components/XdSetLabel'
{{each files}}
import {{$value.fileName}} from "@/components/formItem/{{$value.fileName}}";
{{/each}}
{{each privateFiles}}
import {{$value.fileName}} from "@/components/formItemPrivate/{{$value.fileName}}";
{{/each}}


export default {
  name: "XdBaseDynamicField",
  componentName: 'XdFormBaseDynamicField',
  components: {
    XdRangeGroup,
    XdJsonView,
    XdCheckList,
    XdSwitch,
    XdRadioStatus,
    XdSelectList,
    XdSelectStatus,
    XdRange,
    XdRadioList,
    XdTransfer,
    XdUpload,
    XdFontIcon,
    XdOverAddPrice,
    XdSelectWeekTime,
    XdRemoteInput,
    XdRemoteCascader,
    XdCascadeSelect,
    XdTinymce,
    XdSetLabel,
    {{each files}}
    {{$value.fileName}},
    {{/each}}
    {{each privateFiles}}
    {{$value.fileName}},
    {{/each}}
  },
  props: {
    isAllDisabled:{
      type: Boolean,
      default: false
    },
    isGroupHide: {
      type: Boolean,
      default: true
    },
    isGroupShowBgc: {
      type: Boolean,
      default: true
    },
    isExpand:{
      type: Boolean,
      default: false
    },
    labelWidth: {type: String, default: '100px'},
    size: {type: String, default: 'medium'}, //medium / small / mini
    list: {type: Array | null, default: null},
    isCascaderSave:{
      type: Boolean,
      default: false //级联属性时候，是否需要用原来的值进行替换
    },
    pickerOptions: {
      type: Object,
      default() {
        return {
          shortcuts: [
            {
              text: '最近一周',
              onClick(picker) {
                const end = new Date();
                const start = new Date();
                start.setTime(start.getTime() - 3600 * 1000 * 24 * 7);
                picker.$emit('pick', [start, end]);
              }
            },
            {
              text: '最近一个月',
              onClick(picker) {
                const end = new Date();
                const start = new Date();
                start.setTime(start.getTime() - 3600 * 1000 * 24 * 30);
                picker.$emit('pick', [start, end]);
              }
            },
            {
              text: '最近三个月',
              onClick(picker) {
                const end = new Date();
                const start = new Date();
                start.setTime(start.getTime() - 3600 * 1000 * 24 * 90);
                picker.$emit('pick', [start, end]);
              }
            },
            {
              text: '最近六个月',
              onClick(picker) {
                const end = new Date();
                const start = new Date();
                start.setTime(start.getTime() - 3600 * 1000 * 24 * 180);
                picker.$emit('pick', [start, end]);
              }
            }, {
              text: '最近一年',
              onClick(picker) {
                const end = new Date();
                const start = new Date();
                start.setTime(start.getTime() - 3600 * 1000 * 24 * 365);
                picker.$emit('pick', [start, end]);
              }
            }
          ],
        }
      }
    },
    timeType: {
      type: Boolean,
      default: false //false=> 毫秒 true=>秒
    },
    textareaSize: {
      type: Object,
      default() {
        return {minRows: 4, maxRows: 6}
      }
    },
    //当设置值的时候启动表单根据当前传入值进行隐藏与显示
    activeStyle:{
      type: String,
      default: '',
    },

    //针对 edit X  //
    isAdvanced : {
      type: Boolean|null,
      default: null
    },
    isContent : {
      type: Boolean|null,
      default: null
    },
    isStyle : {
      type: Boolean|null,
      default: null
    }
  },

  watch: {
    list: {
      handler() {
        if(this.listTimer) clearTimeout(this.listTimer);
        this.listTimer = setTimeout(()=>{
          this.initStatus = false;
          this.init();

        }, 50)
      },
      immediate: false,
      deep:true,
    },
    form: {
      handler() {
        if(this.formTimer) {
          clearTimeout(this.formTimer);
          this.formTimer = null;
        }
        this.formTimer = setTimeout(()=>{
          this.$emit('input', this.getParams());
          this.isFrist = false
        }, 300);
      },
      deep: true
    },

    uiGroupList:{
      handler(value){
        this.$emit('on-group-status', value)
      },
      deep: true
    },
  },

  data() {
    return {
      isPC:false,
      refID: null,
      formTimer: null,
      formStatus: false, //初始化完成
      isFrist: true,

      form: {}, //绑定数据字段
      rules: {}, //验证规则

      uiList: [], //ui列表
      uiListValue: {}, //保存上一次的值
      uiGroupList:{}, //组信息

      //测试数据 备注；valueKey必须唯一
      testList: [],

      //分组功能收起功能
      groupStatus:{},
      //分组功能收起功能是否已初始化
      groupStatusFlag: false,

      //已支持禁用功能组件
      supportDisabled:[
        'el-input',
        'xd-cascade',
        'xd-cascade-panel',
        'xd-size',
        'xd-margin-padding',
        'xd-color',
        'xd-upload',
        'xd-footer-setting',
        'xd-radio-custom',
        'xd-item-notice',
        'xd-remote-select-list',
        'xd-multiple-input',
        'xd-group-input',
        'xd-set-label',
        'xd-set-sort-label',
        'xd-cascade-select',
        'xd-remote-cascader',
        'xd-tinymce',
        'xd-text-area-tag',
        'xd-day-range',
        'xd-table-product',
        'xd-select-pages-path',
        'xd-select-site-path',
        'xd-full-cut-rule',
        'xd-select-list',
        'xd-input-unit',
        'xd-table-cascade',
        'xd-select-status',
        'xd-radio',
        'xd-switch',
        'xd-check',
        'xd-range',
        'xd-date-range',
        'xd-order-setting',
        'xd-input-range',
        'xd-remote-cascader-panel',
        'xd-remote-input',
        'xd-date',
        'xd-range-group',
        'xd-over-add-price',
        'xd-select-week-time',

        'xd-choose-namespace',
        'xd-market-header',
        'xd-site-select-list',
        'xd-site-poster',
        'xd-site-news',
        'xd-site-content', //废弃
        'xd-select-tag', //废弃
      ],

      //变动与初始化表单否加载完成
      initStatus: false,
      //需要过滤的元素
      filterEleArr:['xd-line-title','slot','title','el-html','line','xd-line'],
    }
  },
  computed:{
    isGroupStatusEmpty(){
      return this.$xdHelper.isEmpty(this.groupStatus)
    }
  },

  created() {
    this.isPC = this.$xdHelper.isPC();
    this.refID = `Xd-${this.$xdHelper.randomChar(20)}`;
    this.init();

  },

  methods: {
    handleGroup(item){
      if(typeof item['isIcon'] !== 'undefined') return;
      if(this.isGroupHide === false) return;
      let key = `group_id_${item.group_id}`;
      this.$set(this.groupStatus, key, !this.groupStatus[key]);
    },

    getTimeOptions(item , isFast = true) {
      let temp = {};
      let options = this.$xdHelper.cloneDeep(this.pickerOptions);
      if (item.isShowPickerOptionsFast && isFast) temp = Object.assign({}, temp, options);

      //限制选择过去时间
      if (item['filterPassTime']) {
        temp['disabledDate'] = (time)=>{
          return time.getTime() > new Date().getTime()
        };
        return temp;
      }

      //限制选择未来时间
      if (item['filterFutureTime']) {
        temp['disabledDate'] = (time) => {
          return time.getTime() <= (new Date().getTime() - 24 * 60 * 60 * 1000)
        };
        return temp;
      }

      //时间段
      if(item['filterRange']
        && this.$xdHelper.checkVarType(item['filterRange']) === 'array'
        && item['filterRange'].length === 2
      ) {
        temp['disabledDate'] = (time) => {
          return time.getTime() < item['filterRange'][0] || time.getTime() > item['filterRange'][1]
        };
        return temp;
      }

      return temp;
    },

    handleElInout(key){
      let value = this.form[key];
      if(value.trim() === '') {
        this.form[key] = '';
      }
    },

    getClass(item){
      let params = {};
      if(this.activeStyle) {
        if(item.groupKey) {
          if(item.groupKey === this.activeStyle) params['xd-active'] = true;
          else params['xd-not-active'] = true;
        }
        else {
          params['active'] = true
        }
      }
      return {
        default: item.size === 'default',
        mini: item.size === 'mini' || !item.size,
        small: item.size === 'small',
        ...params,

        //设置是否可以隐藏节点
        "jfb-hidden": item.hidden === true,
      }
    },

    /**
     * @description 获取显示状态
     * @param item {Object} form对象
     */
    getInline(item) {
      return item['inline'] === true || item['inline'] === undefined
    },

    /**
     * @description 获取高和宽
     * @param item {Object} form对象
     * @param type {Boolean} true =》宽 false=》高
     */
    getWH(item, type) {
      if (type) return item['oneWidth'] ? item['oneWidth'] + 'px' : '100px';
      return item['oneHeight'] ? item['oneHeight'] + 'px' : '100px';
    },

    getWHIcon(item){
      let num = Math.min(item['oneWidth'],item['oneHeight']);
      if(num < 70) {
        let temp = num - 20;
        if(temp <= 16) return 16;
        return temp;
      }
      return 50;
    },

    /**
     *  @description  是否必填
     *  @param rules {null|object|Array}
     *  @return {boolean}
     */
    getRequire(rules = null){
      if(!rules) return false;
      if(this.$xdHelper.checkVarType(rules) === 'object' && rules['required']) return true;
      if(this.$xdHelper.checkVarType(rules) === 'array') {
       let temp = rules.filter(item=>{
         return item.required;
       });
       if(temp.length > 0) return true
      }
      return false
    },


    /**
     * @description 设置form item prop属性
     * @param item 插件对象
     */
    getProp(item) {
      if (item.ele === 'xd-range') {
        return this.getItemToFormKey(item, 'xdRange');
      } else if (item.ele === 'xd-date-range') {
        return this.getItemToFormKey(item, 'xdDate');
      } else if (item.ele === 'xd-over-add-price') {
        return this.getItemToFormKey(item, 'xdOverAddPrice')
      } else if (item.ele === 'xd-select-week-time') {
        return this.getItemToFormKey(item, 'xdSelectWeekTime')
      } else {
        return item['valueKey']
      }
    },

    getCustomClass(item){
      let params =  {
        'xd-html':  item.ele === 'el-html',
      };

      //标题与内容显示在一行
      if(item['labelInline'] && item['labelInline'] === true){
        params['cus-inline'] = true
      }

      //行缩进
      if(item['indent'] && item['indent'] === true) {
        params['cus-indent'] = true
      }

      if(this.activeStyle) {
        if(item.groupKey) {
          if(item.groupKey === this.activeStyle) params['xd-active'] = true;
          else params['xd-not-active'] = true;
        }
        else {
          params['active'] = true
        }
      }

      //设置是否可以隐藏节点
      params['jfb-hidden'] = (item.hidden === true);

      //设置组背景样式==========
      if(item['xd-group-color']) {
        params['group-bgColor'] = true
      }

      if(item['xd-group-color-first'] && item['xd-group-color-last']) {
        params['group-color-one'] = true
      }
      else {
        if(item['xd-group-color-first']) {
          params['group-color-first'] = true
        }
        if(item['xd-group-color-last']) {
          params['group-color-last'] = true
        }
      }

      if(item['xd-group-color'] &&
        (item['ele'] === 'xd-shadow' || item['ele'] === 'xd-border')
      ) {
        params['cus-shAndBorder'] = true;
      }
      //设置组背景样式==========

      return params
    },

    /**
     * @description 获取表单数据
     */
    getParams() {
      let form = this.$xdHelper.cloneDeep(this.form);
      let temp = {};
      Object.keys(form).map(key => {

        //区间输入值与时间区间插件
        if (/^(xdRange__|xdDate__)(.*)$/.test(key)) {
          let range = key.split('__');
          if (form[key] && form[key].length > 0) {
            range.splice(0, 1);
            temp[range[0]] = form[key][0];
            temp[range[1]] = form[key][1];

            //时间毫秒转秒处理
            if (/^(xdDate__)(.*)$/.test(key) && this.timeType) {
              temp[range[0]] = form[key][0] ? Math.floor(form[key][0] / 1000) : form[key][0];
              temp[range[1]] = form[key][1] ? Math.floor(form[key][1] / 1000) : form[key][1];
            }
          } else {
            range.splice(0, 1);
            temp[range[0]] = null;
            temp[range[1]] = null;
          }
        }

        //自定义时间插件与超过价格设置插件
        else if (/^(xdOverAddPrice__|xdSelectWeekTime__)(.*)$/.test(key)) {
          temp = {...temp, ...form[key]}
        }

        //其他模式
        else {
          if (this.$xdHelper.checkVarType(form[key]) === 'array' && this.dateFilter) {
            if (form[key].length > 0) {
              temp[key] = form[key];
            }
          } else {
            let ele = this.$xdHelper.isKeyInLists(this.uiList, key, 'valueKey');
            if(ele) {
              if (ele.ele === 'xd-date' && this.timeType) {
                temp[key] = form[key] ? Math.floor(form[key] / 1000) : form[key];
              } else {
                temp[key] = form[key];
              }
            }
          }

        }
      });

      //去掉特殊字符头尾空白符，空白符包括：空格、制表符 tab、换行符等其他空白符
      Object.keys(temp).map(key=>{
        if(this.$xdHelper.checkVarType(temp[key]) === 'string') temp[key] = temp[key].trim();
      });

      if (this.dateFilter) {
        if (this.$xdHelper.isEmpty(temp)) {
          return temp
        } else {
          return this.$xdHelper.deleteParamEmptyKey(temp);
        }
      }
      else return temp
    },

    //==设置表单======================================
    /**
     * @description 对象获取form键值
     * @param item  插件对象
     * @param prefix 前缀
     */
    getItemToFormKey(item, prefix) {
      let key = [];
      if (this.$xdHelper.checkVarType(item.valueKey) === 'array') {
        key = [...item['valueKey']];
      }
      if (this.$xdHelper.checkVarType(item.valueKey) === 'object') {
        Object.keys(item.valueKey).map((k) => {
          key.push(`${k}$${item.valueKey[k]}`)
        });
      }
      return `${prefix}__${key.join('__')}`
    },

    /**
     * @description 检查key值是否重复
     * @param keys {Object}  键值计数对象
     * @param list {Array} 检查对象或者数组
     * @param isArray {Boolean} 默认：true
     */
    checkKeyRepeat(keys, list, isArray = true){
      if(isArray) {
        let arr = this.$xdHelper.cloneDeep(list);
        arr.map(item => {
          if (!this.filterEleArr.includes(item.ele)) {
            let key = item['valueKey'];
            if(this.$xdHelper.checkVarType(key) === 'array') key = key.join('_');
            if (this.$xdHelper.checkVarType(key) === 'object') {
              let temp = [];
              Object.keys(key).map((item)=>{
                if(this.$xdHelper.checkVarType(item) === 'array') temp = temp.concat(key[item]);
                else  temp.push(key[item])
              });
              key = temp.join('_');
            }
            if (keys[key]) keys[key] = keys[key] + 1;
            else keys[key] = 1;
          }
        });
      }
      else {
        Object.keys(list).map(key=>{
          if (keys[key]) keys[key] = keys[key] + 1;
          else keys[key] = 1;
        })
      }

      let flag = false;
      let keyValue = '';
      Object.keys(keys).map(key => {
        if (keys[key] > 1) {
          keyValue = key;
          flag = true;
        }
      });
      if(flag) throw Error(`键值重复: ${JSON.stringify(keyValue)}`);
    },

    /**
     * @description 设置刷新key值
     * @param list {Array}
     */
    setIndexKey(list){
      return list.map(item=>{
        //刷新局部操作（方式1）
        if(item.isRefresh) return item;

        //刷新局部操作（方式2）
        let keyObj = {key: item.valueKey, value: item.value, defaultValue: item.defaultValue};
        if(item['isKey'] && item['key'] !== undefined) {
          keyObj['cusKey'] = item['key']
        }

        return {
          ...item,
          key: md5(JSON.stringify(keyObj))
        }
      })
    },

    /**
     * @description 特殊插件处理
     */
    handleSetFormAndRules(key, item){
      let formKey = this.getItemToFormKey(item, key);

      if(key === 'xdDate') {
        let sNowLen = (Math.floor(new Date().getTime() / 1000) + '').length;

        //秒转化为毫秒
        if(item.value && this.$xdHelper.checkVarType(item.value) === 'array' && item.value.length > 0) {
          item.value = item.value.map(time=>{
            let timeStr = time + '';
            if(timeStr.length === sNowLen) {
              return this.$xdHelper.multiplyFloatNumber(time, 1000);
            }
            else return time
          })
        }
      }

      if (this.isCascaderSave && this.form[formKey]) item['value'] = this.form[formKey];
      if (item['rules']) {
        this.$set(this.rules, formKey, item['rules'])
      }
      this.$set(this.form, formKey, item['value'])
    },

    /**
     * @description 设置刷新key值
     * @param list {Array}
     */
    setFormAndRules(list) {
      list.map(item =>{
        if(!this.filterEleArr.includes(item.ele)) {
          switch (item.ele) {
            case 'xd-range' :
              this.handleSetFormAndRules('xdRange', item);
              break;
            case 'xd-date-range' :
              this.handleSetFormAndRules('xdDate', item);
              break;
            case 'xd-over-add-price' :
              this.handleSetFormAndRules('xdOverAddPrice', item);
              break;
            case 'xd-select-week-time' :
              this.handleSetFormAndRules('xdSelectWeekTime', item);
              break;
            default :
              const isEmpty = (val)=>{
                if(this.$xdHelper.checkVarType(val) === 'array' || this.$xdHelper.checkVarType(val) === 'object') {
                  return this.$xdHelper.isEmpty(val)
                }
                return (val === null || val === '' || val === undefined)
              };
              //普通组件传入value无值时候，并且form有值 进行数据赋值财操作
              if(this.isCascaderSave && this.form[item['valueKey']] && isEmpty(item.value)){
                item['value'] = this.form[item['valueKey']];
              }
              //时间处理
              if(item.ele ==='xd-date') {
                let sNowLen = (Math.floor(new Date().getTime() / 1000) + '').length;
                if(item.value && this.$xdHelper.checkVarType(item.value) === 'number') {
                  let timeStr = item.value + '';
                  if (timeStr.length === sNowLen) {
                    item.value =  this.$xdHelper.multiplyFloatNumber(item.value, 1000);
                  }
                }
                console.log('sNowLen', item)
              }
              if (item['rules']) {
                this.$set(this.rules, item['valueKey'], item['rules'])
              }
              this.$set(this.form, item['valueKey'], item['value']);
          }
        }

      });
    },

    spDisabled(item, disabled){
      if(item.ele === 'xd-size') {
        item.disabled  = {
          wDisabled: disabled,
          hDisabled: disabled
        }
      }
      return item;
    },

    /**
     * @description 分组优化
     * @param list {Array}
     */
    sortList(list){
      let contentArr = [{
        label: "",
        groupKey: "content",
        ele: "title",
        size: "small",
      }];
      let advancedArr = [{
        label: "",
        groupKey: "advanced",
        ele: "title",
        size: "small",
      }];
      let styleArr = [{
        label: "",
        groupKey: "style",
        ele: "title",
        size: "small",
      }];

      //判断是否有完全分组
      let hasGroupKey = true;
      let len = list.length;
      for (let i = 0; i < len; i++) {
        if(list[i].groupKey === undefined) hasGroupKey = false;
      }

      //未完全分组不处理
      if(!hasGroupKey) return list;

      customClone(list).map(item=>{
        if(item.groupKey === 'content') contentArr.push(item);
        else if(item.groupKey === 'advanced') advancedArr.push(item);
        else if(item.groupKey === 'style') styleArr.push(item);
        else  contentArr.push(item);
      });
      return [].concat(contentArr).concat(styleArr).concat(advancedArr);
    },

    checkValueIsRefresh(list){
      let formData = this.getParams();
      list.map(item=>{
        if(item.value !== formData[item.valueKey]) {
          if(item['isRefresh'] === true) {
            item.isKey = true;
            item.key = this.$xdHelper.randomChar(20);
          }
        }
      })
    },

    /**
     * @description 初始化表单
     */
    init() {
      let arrList = [];

      //设置值
      if (this.list === null) arrList = this.testList;
      else arrList = this.list || [];

      //检查值是否发生变化
      if(!this.$xdHelper.isEmpty(this.form)) {
        this.checkValueIsRefresh(arrList)
      };


      //设置组背景样式==========
      if(this.isGroupShowBgc) {
        let groupColorStatus = false;
        let groupColorFirst = true; //第一个
        arrList = arrList.map((item,index)=>{
          if(item.ele === 'group_start') {
            groupColorStatus = true;
          }
          else if(item.ele === 'group_end') {
            groupColorStatus = false;
            groupColorFirst = true;
          }
          else {
            if(groupColorStatus) {
              //设置组第一元素样式名称
              if(groupColorFirst){
                item['xd-group-color-first'] = true;
                groupColorFirst = false
              }

              //设置组最后一个元素样式名称
              if(arrList[index+1].ele === 'group_end') {
                item['xd-group-color-last'] = true;
              }

              item['xd-group-color'] = true;
            }
          }
          return item;
        }).filter(item=>{
          return !(item.ele === 'group_start' || item.ele === 'group_end')
        });
      }
      else {
        arrList = arrList.filter(item=>{
          return !(item.ele === 'group_start' || item.ele === 'group_end')
        });
      }
      //设置组背景样式==========

      //检查键是否有重复
      let keys = {};
      this.checkKeyRepeat(keys, this.$xdHelper.cloneDeep(arrList));
      arrList = this.setIndexKey(arrList);
      this.setFormAndRules(arrList);

      //设置默认值
      let groupStyle = [];
      let groupContent = [];
      let groupAdvanced = [];
      let notSupportDisabled = [];
      let group_index = 0;
      let group_status = {group_id_0:true};
      let isFirstGroup = true;

      //优化列表排序
      arrList = this.sortList(arrList);

      //初始化值
      let newList = customClone(arrList).map(item=>{
        if(item.groupKey === 'style') {
         if(item.ele === 'title' && item.label !== ''  && groupStyle.filter(i=>i).length === 0) {
            item.isFirst = true
          }
          groupStyle.push(item.valueKey);
          if(this.isStyle !== null) {
            if(item.disabled === undefined) item.disabled =  !this.isStyle;
            item = this.spDisabled(item, !this.isStyle);
          }
        }
        if(item.groupKey === 'content') {
          if(item.ele === 'title' && item.label !== '' && groupContent.filter(i=>i).length === 0) {
            item.isFirst = true
          }
          groupContent.push(item.valueKey);
          if(this.isContent !== null) {
            if(item.disabled === undefined) item.disabled =  !this.isContent;
            item = this.spDisabled(item, !this.isStyle);
          }
        }
        if(item.groupKey === 'advanced') {
          if(item.ele === 'title' && item.label !== ''  && groupAdvanced.filter(i=>i).length === 0) {
            item.isFirst = true
          }
          groupAdvanced.push(item.valueKey);
          if(this.isAdvanced !== null) {
            if(item.disabled === undefined) item.disabled =  !this.isAdvanced;
            item = this.spDisabled(item, !this.isStyle);
          }
        }
        if(!this.supportDisabled.includes(item.ele)) notSupportDisabled.push(item);
        if(item.ele === 'title') {
          group_index++;
          item.group_id = group_index;

          //是否折叠操作（折叠时候显示第一个组）
          if(this.isExpand) {
            group_status[`group_id_${item.group_id}`] = isFirstGroup;
          }
          else group_status[`group_id_${item.group_id}`] = true;

          if(isFirstGroup) isFirstGroup = false;
        }
        else {
          item.groupIdClass = `group_id_${group_index}`;
          item.group_id = group_index;
        }
        return item
      });

      if(notSupportDisabled.length > 0) {
        console.warn(`Not Support Disabled: ${JSON.stringify(notSupportDisabled.map(item=>{
          return {
            key: item.valueKey,
            ele: item.ele
          }
        }))}`);
        window['$notSupportDisabled'] = notSupportDisabled;
      }

      //未分组
      if(newList.length > 0 && ( groupStyle.length === 0
        && groupContent.length === 0
        && groupAdvanced.length === 0)
      ) {
        this.uiGroupList = {style:groupStyle,content:[1],advanced:groupAdvanced};
      }

      //已分组
      else {
        this.uiGroupList = {
          style: groupStyle.filter(i=>i),
          content: groupContent.filter(i=>i),
          advanced: groupAdvanced.filter(i=>i)
        };
      }

      //未分组进行设置过滤完成值
      if(!this.groupStatusFlag) {
        this.groupStatus = group_status;
      }
      this.groupStatusFlag = true;


      this.uiList = newList.map(item=>{
        if(typeof this.isAllDisabled === 'boolean'){
          if(this.isAllDisabled  === true) item.disabled = this.isAllDisabled
        }
        return item
      });

      this.formStatus = true;
      if (!this.isFrist) this.$emit('input', this.getParams());

      //判断表单是否完成
      this.$nextTick(()=>{
        this.initStatus = true;
      })
    },
    //==设置表单 结束==================================


    //==设置验证与返回值================================
    /**
    * @description 获取插槽中的自定义表单元素
    */
    getSlotNodes(){
     return this.$children[0].$children.filter(item => {
       return item.$options['componentName'] === 'XdFormBaseDynamicField'
         || item.$options['componentName'] === 'ElForm';
     });
    },

    /**
    * @description 获取插槽中的自定义表单元素
    */
    getSlotPromises(){
     return this.getSlotNodes().map(item=>{
       if(item.$options['componentName'] === 'XdFormBaseDynamicField') return item['submit']();
       else return new Promise((resolve,reject)=>{
         item.validate((valid, error) => {
           if (valid) resolve(valid);
           else reject({valid, error});
         })
       })
     })
    },

    /**
     * @description 获取插槽中的自定义表单元素数据
     */
    getAllFormData(){
      let temp = {};
      this.getSlotNodes().map(item=>{
        if (item.$options['componentName'] === 'XdFormBaseDynamicField'){
          temp = Object.assign({}, temp, this.$xdHelper.cloneDeep(item.getParams()))
        }
        else{
          temp = Object.assign({}, temp, this.$xdHelper.cloneDeep(item.$options.propsData['model']))
        }
      });

      let keys = {};
      this.checkKeyRepeat(keys, temp, false);
      this.checkKeyRepeat(keys, this.getParams(), false);


      return Object.assign({},
        this.$xdHelper.cloneDeep(temp),
        this.$xdHelper.cloneDeep(this.getParams()),
      );
    },

    /**
     * @description 提交验证包含（插槽中的表单 + 与当前表单）
     */
    submitAll(){
       let promiseArr = this.getSlotPromises();
       promiseArr.push(this.submit());
       return new Promise((resolve, reject) => {
         Promise.all(promiseArr)
           .then(res => {
             resolve(res);
           })
           .catch((error)=>{
             let errorArr = Object.keys(error.error).map(key=>{
               return error.error[key][0]['message']
             });
             errorArr.splice(1);
             // let str = `数据项填写错误，包扩:【<span style="color:red">${errorArr.join('</span>】，【<span style="color:red">')}</span>】`;
             // this.$alert(str, '数据项错误', {
             //   confirmButtonText: '确定',
             //   dangerouslyUseHTMLString: true,
             // });
             this.$message({
               message: `填写错误：【${errorArr[0]}】`,
               type: 'error'
             })

             reject(error.valid);
          })
       })
     },

    /**
     * @description 提交前验证数据
     */
    submit() {
      return new Promise((resolve, reject) => {
        this.$refs[this.refID].validate((valid, error) => {
          if (valid) resolve(valid);
          else reject({valid, error});
        })
      });
    },

    //==设置验证与返回值================================

    //==图片上传=======================================
    /**
     * @description 上传成功
     */
    handleSuccess(res) {
      this.$emit('success', res)
    },

    /**
     * @description 上传到本地服务器成功返回值时刻触发，设置url字段
     * @param result
     * @param resolve
     */
    handleApiSuccessUrl(result, resolve) {
      this.$emit('onApiSuccessUrl', result, (url) => {
        resolve(url);
      })
    },

    /**
     * @description 单文件上传参数设置
     * @param file
     * @param resolve
     */
    handleGetParamsAndHeader(file, resolve) {
      this.$emit('onGetParamsAndHeader', file, (params) => {
        resolve(params);
      })
    },
    //==图片上传=======================================

    getGroupFormData(){
      let data = {};
      let group = [];
      Object.keys(this.getParams()).map(valueKey=>{
        let len = this.uiList.length;
        for(let i = 0;i < len; i++) {
          let item = this.uiList[i];
          if(valueKey === item.valueKey) {
            if(item.groupKey) {
              if(!data[item.groupKey]){
                group.push(item.groupKey);
                data[item.groupKey] = {};
              }
              data[item.groupKey][valueKey] =  this.getParams()[valueKey];
            }else{
              if(!data['all']){
                group.push('all');
                data['all'] = {};
              }
              data['all'][valueKey] = this.getParams()[valueKey];
            }
            break
          }

        }
      });
      if(group.length === 1) {
        if(group.includes('all')) return {group, data:{content: data['all']}};
        else return {data, group}
      }
      else return {data, group}
    },
  }
}