export const SpecificationMethod = (freeVallist, data, callback) => {
  // step1
  const step1Data = _proCateSelected(freeVallist, data)
  // step2
  const step2Data = _companyVfree(data, step1Data)
  // step3
  const step3Data = _disableTrue(data, step2Data)

  // callback
  callback(step3Data)
}

const _proCateSelected = (freeVallist, data) => {
  //freeVallist是自由辅助属性库，data是物料下所有商品
  const freeVal = freeVallist,
    step1ReturnVal = {}
  //找到所选的标签存入checktrue
  // checktrue存入所选中id
  let checktrue = [],
    // checkname存入所选中name
    checkname = [],
    // grouplists存 所有规格id
    grouplists = []
  for (let valFirst of freeVal) {
    for (let valSecond of valFirst.values) {
      //将自由辅助属性库 所有id放在一个数组里
      grouplists.push(valSecond.id)
      //把选中的属性放到checktrue
      if (checkedKey(valSecond, 'isChecked') && valSecond.isChecked == true) {
        checktrue.push(valSecond.id)
        checkname.push(valSecond.name)
      }
      if (checkedKey(valSecond, 'isDisabled')) {
        delete valSecond.isDisabled
      }
    }
  }

  step1ReturnVal.checktrue = checktrue
  step1ReturnVal.grouplists = grouplists
  step1ReturnVal.checkname = checkname
  return step1ReturnVal
}

//比较选中的与同类型商品自由属性 (第二步)
const _companyVfree = (data, step1Data) => {
  //物料下所有商品的自由辅助属性
  const Vfrees = data.goodsInfos,
    step2ReturnVal = {}

  let checktrue = step1Data.checktrue,
    grouplists = step1Data.grouplists,
    checkname = step1Data.checkname,
    selectRelation = [],
    Vfreelists = [],
    newseclectR = []
  //将选择的值与物料所有属性做包含判断
  for (let vfreeFirst of Object.keys(Vfrees)) {
    if (_isContained(Vfrees[vfreeFirst], checktrue)) {
      selectRelation = selectRelation.concat(Vfrees[vfreeFirst])
      newseclectR.push([...Vfrees[vfreeFirst]])
    }
    for (let vfreeSecond of Vfrees[vfreeFirst]) {
      Vfreelists.push(vfreeSecond)
    }
  }

  selectRelation = Array.from(new Set(selectRelation))
  Vfreelists = Array.from(new Set(Vfreelists))
  const nonExist = _comvaluesIs(grouplists, Vfreelists)

  step2ReturnVal.selectRelation = selectRelation
  step2ReturnVal.nonExist = nonExist
  step2ReturnVal.checktrue = checktrue
  step2ReturnVal.checkname = checkname
  return step2ReturnVal
}

//对无商品自由属性变虚线框 （第三步）
const _disableTrue = (data, step2Data) => {
  const freeArr = data.polyAttrsDtoList,
    step3ReturnVal = {}
  let selectRelation = step2Data.selectRelation,
    nonExist = step2Data.nonExist,
    checktrue = step2Data.checktrue,
    checkname = step2Data.checkname
  for (let selectRelatVal of selectRelation) {
    for (let freeArrFirst of freeArr) {
      for (let freeArrSecond of freeArrFirst.values) {
        if (nonExist.indexOf(freeArrSecond.id) != -1) {
          freeArrSecond.isDisableTrue = true
        }
        if (freeArrSecond.id == selectRelatVal) {
          freeArrSecond.isDisabled = false
        } else if (!checkedKey(freeArrSecond, 'isDisabled')) {
          freeArrSecond.isDisabled = true
        }
      }
    }
  }

  step3ReturnVal.checktrue = checktrue
  step3ReturnVal.checkname = checkname
  step3ReturnVal.freeArr = freeArr
  step3ReturnVal.data = data

  return step3ReturnVal
}

//对象中找key值是否存在
export const checkedKey = (val, key) => {
  const flag = Object.prototype.hasOwnProperty.call(val, key)
  return flag
}

//a是否包含b，包含返回true
export const _isContained = (a, b) => {
  if (!(a instanceof Array) || !(b instanceof Array)) return false
  if (a.length < b.length) return false
  var aStr = a.toString()
  for (var i = 0, len = b.length; i < len; i++) {
    if (aStr.indexOf(b[i]) == -1) return false
  }
  return true
}

//数组是否相等
export const _isArrEqual = (a, b) => {
  if (!(a instanceof Array) || !(b instanceof Array)) return false
  if (a.length != b.length) return false
  //数组去重排序
  const aval = Array.from(new Set([...a].sort())).toString()
  const bval = Array.from(new Set([...b].sort())).toString()
  if (aval == bval) return true
}

//比较所有聚合列表中是否都存在
export const _comvaluesIs = (val, nextval) => {
  let resval = []
  if (!(val instanceof Array) || !(nextval instanceof Array)) return false
  for (let i = 0; i < val.length; i++) {
    if (nextval.indexOf(val[i]) == -1) {
      resval.push(val[i])
    }
  }
  return resval
}

//删除指定元素
export const _removeByValue = (arr, val) => {
  for (var arrVal of arr) {
    if (arrVal == val) {
      arr.splice(i, 1)
      break
    }
  }
}