import _ from 'lodash';
export default {
  data() {
    return {
      // 内部数据配置项
      dataSource: this.data
    };
  },
  computed: {
    /**
     * 源列表数据监听
     *
     * @return {Array}
     */
    sourceData() {
      // 初始化数据
      let _treeData = _.cloneDeep(this.dataSource);

      // 对于顶级节点加入父级 ID 值
      _treeData.forEach(item => {
        item[this.pidName] = 0;
      });

      // 构造除去选中值 `this.selectedKeyValue` 的源数据
      return this.constructTreeBox(this.selectedKeyValue, _treeData);
    },
    /**
     * 目标列表数据监听
     *
     */
    targetData() {
      // 初始化数据
      let _treeData = _.cloneDeep(this.dataSource);

      // 对于顶级节点加入父级 ID 值
      _treeData.forEach(item => {
        item[this.pidName] = 0;
      });
      // 构造除去反向选中值 `this.unselectedKeyValue` 的目标树数据
      console.log("tar", this.constructTreeBox(this.unselectedKeyValue, _treeData));
      return this.constructTreeBox(this.unselectedKeyValue, _treeData);
    },
    /**
     * 查找所有选中的 key 值
     *
     * @return {Array}
     */
    selectedKeyValue() {
      // 初始化
      let _treeData = _.cloneDeep(this.dataSource);
      let _selectedKey = _.cloneDeep(this.value);
      let self = this;

      // 递归获取选中的 key 值（包含父级的）
      function getSelectedKeyValue(data, key) {
        // 初始化数据
        let _treeData = _.cloneDeep(data);

        _treeData.map(base => {
          // 检测子节点数据是否存在
          if (base[self.childrenName] && base[self.childrenName].length > 0) {
            // 若存在，则进行递归，获取子节点
            getSelectedKeyValue(base[self.childrenName], base[self.valueName]);
          }

          return base;
        });

        // 计算同级的数量
        let _count = 0;
        _selectedKey.forEach(item => {
          data.forEach(child => {
            if (child[self.valueName] === item) {
              _count++;
            }
          });
        });

        // 加入父级 key 值
        if (_count === data.length && key) {
          _selectedKey.push(key);
        }
      }

      // 执行方法
      getSelectedKeyValue(_treeData, undefined);
      return _selectedKey;
    },
    /**
     * 查找所有未选中的 key 值
     *
     * @return {Array}
     */
    unselectedKeyValue() {
      // 初始化
      let _treeData = _.cloneDeep(this.dataSource);
      let _selectedKey = _.difference(this.allKeyValue(true), this.selectedKeyValue);
      let self = this;
      // 递归获取选中的 key 值（包含父级的）
      function getSelectedKeyValue(data, key) {
        // 初始化数据
        let _treeData = _.cloneDeep(data);
        _treeData.map(base => {
          // 检测子节点数据是否存在
          if (base[self.childrenName] && base[self.childrenName].length > 0) {
            // 若存在，则进行递归，获取子节点
            getSelectedKeyValue(base[self.childrenName], base[self.valueName]);
          }
          return base;
        });
        // 计算同级的数量
        let _count = 0;
        _selectedKey.forEach(item => {
          data.forEach(child => {
            if (child[self.valueName] === item) {
              _count++;
            }
          });
        });

        // 加入父级 key 值
        if (_count === data.length && key) {
          _selectedKey.push(key);
        }
      }

      // 执行方法
      getSelectedKeyValue(_treeData, undefined);

      return _selectedKey;
    }
  },
  watch: {
    // 监听数据
    data: {
      deep: true,
      immediate: true,
      handler(val) {
        this.dataSource = val;
      }
    }
  },
  methods: {
    /**
     * 递归函数 获取目标树结构数据
     *
     * @param value
     * @param data
     * @return {*}
     */
    constructTreeBox(value, data) {
      // 初始化数据
      let self = this;

      // 检测数据数组
      if (data.length === 0 || value.length === 0) return data;

      // 遍历数据结构
      let _data = data.map(base => {
        // 检测子节点数据是否存在
        if (base[self.childrenName] && base[self.childrenName].length > 0) {
          // 若存在，则进行递归，获取子节点
          base[self.childrenName] = self.constructTreeBox(value, base[self.childrenName]);
        }

        return base;
      });

      // 过滤数据
      value.forEach(item => {
        _data = _data.filter(base => base[self.valueName] !== item);
      });
      return _data;
    },
    /**
     * 查找所有的 key 值
     *
     * @param val [Boolean] true/false
     * @param val [Array] data
     */
    allKeyValue(val, data) {
      // 初始化
      let _treeData = data ? _.cloneDeep(data) : _.cloneDeep(this.dataSource);
      let _treeAllKey = [];
      let self = this;

      // 递归获取所有的 key 值
      function getAllKeyValue(data) {
        // 初始化数据
        let _treeData = _.cloneDeep(data);

        _treeData.map(base => {
          // 检测子节点数据是否存在
          if (base[self.childrenName] && base[self.childrenName].length > 0) {
            // 若存在，则进行递归，获取子节点
            getAllKeyValue(base[self.childrenName]);
          }

          return base;
        });

        data.forEach(item => {
          if (val) {
            if (item[self.childrenName] && item[self.childrenName].length === 0) {
              _treeAllKey.push(item[self.valueName]);
            }
          } else {
            _treeAllKey.push(item[self.valueName]);
          }
        });
      }

      // 执行方法
      getAllKeyValue(_treeData);
      return _treeAllKey;
    },
    // 获取子节点，去除父节点key
    getChildKeys(data, val) {
      let keys = [];
      function filterParentKey(_data, key) {
        _data.filter(item => {
          if (item.id == key && !item.isTreeNode) {
            keys.push(key);
            return;
          } else {
            if (item.child.length > 0) {
              filterParentKey(item.child, key);
            } else {
              return;
            }
          }
        });
      }

      for (let i = 0; i < val.length; i++) {
        const key = val[i];
        filterParentKey(data, key);
      }

      return keys;
    }
  }
};
