import Cookie from 'js-cookie'
import functions from 'v-functions'
import { execute } from '../helper/clientApi'
import presets from './globalPresets'
import { findWhere } from 'underscore'

/**
 * @brief Objeto con funciones comunes de ambiente
 */
const environment = {
  /**
   * @brief Obtiene el token de los Cookies y el usuario del LocalStorage
   * @param {*} callback funcion a ejecutar cuando se obtuvieron los datos
   * @returns
   */
  getFormatRandomNumber: () => {
    const getRandomId = () => {
      return String(Math.floor(Math.random() * 10000))
    }

    const currentDate = new Date()

    let fixName = `${currentDate.getFullYear()}`
    fixName += `${(currentDate.getMonth() + 1).toString().padStart(2, '0')}`
    fixName += `${currentDate.getDate().toString().padStart(2, '0')}`
    fixName += `${currentDate.getHours().toString().padStart(2, '0')}`
    fixName += `${currentDate.getMinutes().toString().padStart(2, '0')}`
    fixName += `${currentDate.getMilliseconds().toString()}`
    fixName += `_${getRandomId()}`

    return fixName
  },

  getResultParameters: (confParameters, item, mainParameters) => {
    const resultParameters = []
    if (confParameters != null && confParameters.length) {
      confParameters.forEach((orParam) => {
        if (orParam.type === 'param') {
          const _parameters = [...mainParameters]
          const arrParam = _parameters.filter((paramSel) => (paramSel.name === orParam.id))
          if (arrParam.length) {
            resultParameters.push(arrParam[0].value)
          } else {
            resultParameters.push(null)
          }
        } else {
          if (item != null && item[orParam.id] != null) {
            resultParameters.push(item[orParam.id])
          } else {
            resultParameters.push(null)
          }
        }
      })
    }
    return resultParameters
  },
  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 && 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 = 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 = 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
  },
  setEnvUser: (user) => {
    functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, user)
  },
  getEnvUser: () => {
    return new Promise((resolve, reject) => {
      const token = Cookie.get(`${process.env.idApp}:${process.env.NODE_ENV}`)
      const user = functions.getDecodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`)
      if (!token || !user) {
        resolve({ token: undefined, user: undefined, redirectPath: '/login' })
      }
      resolve({ token, user })
    })
  },
  logout: () => {
    return new Promise((resolve, reject) => {
      Cookie.remove(`${process.env.idApp}:${process.env.NODE_ENV}`)
      functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, '')
      resolve('/')
    })
  },
  login: (token, user) => {
    return new Promise((resolve, reject) => {
      Cookie.set(`${process.env.idApp}:${process.env.NODE_ENV}`, token)
      functions.setEncodeStorage(`${process.env.idApp}/${process.env.NODE_ENV}`, user)
      resolve()
    })
  },
  getTime: () => {
    // return (new Date()).getTime()
    return 1668220842700
  },

  validaResultadoDB: (resultado, i18n, toast, showOKMessage = false) => {
    const showToast = (i18n, toast, message, type, i18nCode = null) => {
      const displayMessage = message

      // if (displayMessage.includes(':console-message:')) {
      //   console.warn(displayMessage.replace(':console-message:', ''))
      // } else
      if (toast && showOKMessage) {
        const cleanedMessage = displayMessage.replace(':no-display:', '')
        toast[type](
          <span dangerouslySetInnerHTML={{ __html: cleanedMessage }} />,
          presets.toaster
        )
      }
    }

    if (!resultado) {
      showToast(i18n, toast, i18n.t('common.errorApi'), 'error')
      return false
    }

    if (Array.isArray(resultado) && resultado.length > 0) {
      const { status, message, mensaje, i18n: i18nCode } = resultado[0]

      if (status === 'ERROR' || status === 'error' || status === 'WARNING' || status === 'warning' || status === 'INFO' || status === 'info') {
        if (i18n === 'session.inactive' || i18n === 'session.inactiva' || message === 'Sesión inactiva') {
          // if (store.state.sessionInactive === false) {
          // store.actions.setSessionInactive(true)
          // }
        } else {
          showToast(i18n, toast, (message || mensaje), status === 'ERROR' ? 'error' : 'warning', i18nCode)
        }
        return false
      }

      if ((status === 'OK' || status === 'ok' || status === 'SUCCESS' || status === 'success') && showOKMessage) {
        showToast(i18n, toast, (message || mensaje), 'success', i18nCode)
      }
    }

    return true
  },

  getFileParams (model, headers, value, prefix) {
    const head = findWhere(headers, { value })
    const { filename, extension } = functions.getFilePattern(model[value])
    const params = {}
    if (head.logicalName && head.logicalName !== null) {
      if (typeof head.logicalName === 'function') {
        params.logico = head.logicalName(model)
      } else {
        params.logico = head.logicalName
      }
    } else {
      params.logico = filename
    }
    if (prefix && prefix !== null) {
      params.logico = `${prefix}${params.logico}`
    }
    if (head.logicalExtension && head.logicalExtension !== null) {
      if (typeof head.logicalExtension === 'function') {
        params.ext = head.logicalExtension(model)
      } else {
        params.ext = head.logicalExtension
      }
    } else {
      params.ext = extension
    }
    return params
  },

  validaPermisos: async (token, administra, configura, graba_modifica, consulta) => {
    let permisos = await execute('FUN_INFO_SESION_ENTIDAD', [token])
    if (permisos === undefined || permisos.length <= 0) {
      return false
    }
    if (permisos[0].status === 'ERROR') {
      return false
    } else if (permisos[0].status === 'WARNING') {
      return false
    } else {
      permisos = permisos[0]
      const secVal = []
      if (permisos.administra === 'S') {
        return true
      } else if (permisos.configura === 'S') {
        secVal.push(2)
      } else if (permisos.graba_modifica === 'S') {
        secVal.push(3)
      } else if (permisos.consulta === 'S') {
        secVal.push(4)
      }
      if (configura === 'S' && secVal.includes(2) === true) {
        return true
      } else if (graba_modifica === 'S' && secVal.includes(3) === true) {
        return true
      } else if (consulta === 'S' && secVal.includes(4) === true) {
        return true
      }
      return false
    }
  },
  i18nHeaders: (i18n, headers) => {
    return new Promise((resolve) => {
      const newHeaders = []
      for (const hds of headers) {
        if (hds.i18n && hds.i18n.length > 0) {
          hds.text = i18n.t(hds.i18n)
        }
        if (hds.pristineMessages) {
          Object.keys(hds.pristineMessages).forEach((msg) => {
            if (msg.includes('-params') === false) {
              if (hds.pristineMessages[`${msg}-params`]) {
                hds.inputProps[`data-pristine-${msg}-message`] = hds.pristineMessages[msg]
                  ? i18n.t(hds.pristineMessages[msg], hds.pristineMessages[`${msg}-params`])
                  : 'txtNone'
              } else {
                hds.inputProps[`data-pristine-${msg}-message`] = hds.pristineMessages[msg]
                  ? i18n.t(hds.pristineMessages[msg])
                  : 'txtNone'
              }
            }
          })
        }
        newHeaders.push(hds)
      }
      resolve(newHeaders)
    })
  }
}

export default environment