import functions from 'v-functions'

/**
 * @brief Objeto con funciones comunes de ambiente
 */
const environment = {
  buildFunctiontsHeaders: (baseHeaders, iconResponse = () => {}, substituteValOnForm = () => {}) => {
    const newHeaders = []
    if (baseHeaders != null && baseHeaders.length) {
      for (let i = 0; i < baseHeaders.length; i++) {
        const field = baseHeaders[i]
        if (field.substituteValOnForm != null) {
          field.substituteValOnForm = (head, _model, _field, _isEdit) => { return substituteValOnForm(head, _model, _field, _isEdit) }
        }
        if (field.mappingRules != null && field.mappingRules.length) {
          const _mappingRules = [...field.mappingRules]
          // Insertar Funcion para substituteVal
          const rulesValue = _mappingRules.filter((rule) => (rule.type === 'value' || rule.type === 'icon' || rule.type === 'format' || rule.type === 'fieldValue'))
          if (rulesValue.length) {
            field.substituteVal = (item) => {
              const id = field.value
              const rules = [...rulesValue]
              if (rules.length) {
                for (let i = 0; i < rules.length; i++) {
                  const rule = { ...rules[i] }
                  const numberRuleValue = Number(rule.value)
                  const numberFieldValue = Number(item[rule.field])
                  const areNums = !isNaN(numberRuleValue) && !isNaN(numberFieldValue)
                  let response = rule.result
                  if (rule.type === 'icon') {
                    response = iconResponse(item[id], rule.result, item)
                  }
                  if (rule.rule === 'equal') {
                    if ((!areNums && item[rule.field] === rule.value) || (areNums && numberFieldValue === numberRuleValue)) {
                      return response
                    } else if ((rule.value === null || rule.value === '') && (item[rule.field] === null || item[rule.field] === '')) {
                      return response
                    }
                  } else if (rule.rule === 'greater_than') {
                    if ((!areNums && item[rule.field] > rule.value) || (areNums && numberFieldValue > numberRuleValue)) {
                      return response
                    }
                  } else if (rule.rule === 'less_than') {
                    if ((!areNums && item[rule.field] < rule.value) || (areNums && numberFieldValue < numberRuleValue)) {
                      return response
                    }
                  } else if (rule.rule === 'not_equal') {
                    if ((!areNums && item[rule.field] !== rule.value) || (areNums && numberFieldValue !== numberRuleValue)) {
                      return response
                    } else if ((rule.value === null || rule.value === '') && (item[rule.field] !== null || item[rule.field] !== '')) {
                      return response
                    }
                  }
                  if (rule.type === 'format') {
                    const isNum = !isNaN(numberFieldValue)
                    try {
                      if (rule.rule === 'number') {
                        if (isNum) {
                          return functions.formatNumber(numberFieldValue, rule.result)
                        }
                        return functions.formatNumber(item[rule.field], rule.result)
                      } else if (rule.rule === 'date') {
                        if (isNum) {
                          return functions.formatDate(numberFieldValue, rule.result)
                        }
                        return functions.formatDate(item[rule.field], rule.result)
                      }
                    } catch (e) {
                      return item[id]
                    }
                  }
                  if (rule.type === 'fieldValue') {
                    try {
                      return item[rule.result]
                    } catch (e) {
                      return item[id]
                    }
                  }
                }
                return item[id]
              }
              return item[id]
            }
          } else {
            field.substituteVal = null
          }
          // Insertar Funcion para classItem
          const rulesClass = _mappingRules.filter((rule) => (rule.type === 'class'))
          if (rulesClass.length) {
            field.classItem = (item) => {
              const rules = [...rulesClass]
              let resultClass = ''
              if (rules.length) {
                for (let i = 0; i < rules.length; i++) {
                  const rule = { ...rules[i] }
                  const numberRuleValue = Number(rule.value)
                  const numberFieldValue = Number(item[rule.field])
                  const areNums = !isNaN(numberRuleValue) && !isNaN(numberFieldValue)
                  if (rule.rule === 'equal') {
                    if ((!areNums && item[rule.field] === rule.value) || (areNums && numberFieldValue === numberRuleValue)) {
                      resultClass = `${resultClass} ${rule.result}`
                    } else if ((rule.value === null || rule.value === '') && (item[rule.field] === null || item[rule.field] === '')) {
                      resultClass = `${resultClass} ${rule.result}`
                    }
                  } else if (rule.rule === 'greater_than') {
                    if ((!areNums && item[rule.field] > rule.value) || (areNums && numberFieldValue > numberRuleValue)) {
                      resultClass = `${resultClass} ${rule.result}`
                    }
                  } else if (rule.rule === 'less_than') {
                    if ((!areNums && item[rule.field] < rule.value) || (areNums && numberFieldValue < numberRuleValue)) {
                      resultClass = `${resultClass} ${rule.result}`
                    }
                  } else if (rule.rule === 'not_equal') {
                    if ((!areNums && item[rule.field] !== rule.value) || (areNums && numberFieldValue !== numberRuleValue)) {
                      resultClass = `${resultClass} ${rule.result}`
                    } else if ((rule.value === null || rule.value === '') && (item[rule.field] !== null || item[rule.field] !== '')) {
                      resultClass = `${resultClass} ${rule.result}`
                    }
                  }
                }
                return resultClass
              }
              return resultClass
            }
          } else {
            field.classItem = null
          }
        } else {
          field.classItem = null
          field.substituteVal = null
        }

        if (field.showInForm != null && field.showInForm === true) {
          if (field.formatDefinition != null && field.formatDefinition.action != null) {
            if (field.formatDefinition.action === 'format') {
              field.format = (val, definition = field.formatDefinition) => {
                if (val != null) {
                  if (definition.value === 'lowercase') {
                    const valString = String(val)
                    return valString.toLowerCase()
                  } else if (definition.value === 'uppercase') {
                    const valString = String(val)
                    return valString.toUpperCase()
                  }
                }
                return val
              }
            }
          } else {
            field.format = null
          }
        }
        newHeaders.push({ ...field })
      }
    }
    return newHeaders
  }
}

export default environment