import { getBrowser as getBrowserMetadata } from '@/api/ADempiere/dictionary'
import { showMessage } from '@/utils/ADempiere/notification'
import { isEmptyValue } from '@/utils/ADempiere/valueUtils'
import { generateField } from '@/utils/ADempiere/dictionaryUtils'
import router from '@/router'
import language from '@/lang'

const browser = {
  state: {
    browser: []
  },
  mutations: {
    addBrowser(state, payload) {
      state.browser.push(payload)
    },
    dictionaryResetCacheBrowser(state) {
      state.browser = []
    },
    changeBrowserAttribute(state, payload) {
      let value = payload.attributeValue
      if (payload.attributeNameControl) {
        value = payload.browser[payload.attributeNameControl]
      }
      payload.browser[payload.attributeName] = value
    }
  },
  actions: {
    getBrowserFromServer({ commit, dispatch }, {
      containerUuid,
      routeToDelete
    }) {
      return new Promise(resolve => {
        getBrowserMetadata(containerUuid)
          .then(browserResponse => {
            const panelType = 'browser'
            const additionalAttributes = {
              containerUuid,
              panelType
            }
            const {
              query,
              whereClause,
              process
            } = browserResponse

            //  Convert from gRPC
            const fieldsRangeList = []
            let isShowedCriteria = false
            let awaitForValues = 0
            let fieldsList = browserResponse.fieldsList.map((fieldItem, index) => {
              const someAttributes = {
                ...additionalAttributes,
                fieldListIndex: index
              }
              const field = generateField({
                fieldToGenerate: fieldItem,
                moreAttributes: someAttributes,
                isSOTrxMenu: routeToDelete.meta.isSOTrx
              })
              // Add new field if is range number
              if (field.isRange && field.componentPath === 'FieldNumber') {
                const fieldRange = generateField({
                  fieldToGenerate: fieldItem,
                  moreAttributes: someAttributes,
                  typeRange: true
                })
                if (!isEmptyValue(fieldRange.value)) {
                  fieldRange.isShowedFromUser = true
                }
                fieldsRangeList.push(fieldRange)
              }

              // Only isQueryCriteria fields with values, displayed in main panel
              if (field.isQueryCriteria) {
                if (field.isSQLValue) {
                  isShowedCriteria = true
                  field.isShowedFromUser = true
                  awaitForValues++
                }
                if (query.includes(`@${field.columnName}@`) ||
                  query.includes(`@${field.columnName}_To@`) ||
                  whereClause.includes(`@${field.columnName}@`) ||
                  whereClause.includes(`@${field.columnName}_To@`)) {
                  field.isMandatory = true
                  field.isMandatoryFromLogic = true
                  field.isShowedFromUser = true
                }

                if (isEmptyValue(field.value)) {
                  // isMandatory params to showed search criteria
                  if (field.isMandatory || field.isMandatoryFromLogic) {
                    isShowedCriteria = true
                  }
                } else {
                  // with value
                  field.isShowedFromUser = true
                }
              }

              return field
            })
            fieldsList = fieldsList.concat(fieldsRangeList)

            // Get dependent fields
            fieldsList
              .forEach((field, index, list) => {
                if (field.isActive && field.parentFieldsList.length) {
                  field.parentFieldsList.forEach(parentColumnName => {
                    const parentField = list.find(parentField => {
                      return parentField.columnName === parentColumnName && parentColumnName !== field.columnName
                    })
                    if (parentField) {
                      parentField.dependentFieldsList.push(field.columnName)
                    }
                  })
                }
              })

            // Panel for save on store
            const newBrowser = {
              ...browserResponse,
              containerUuid,
              fieldList: fieldsList,
              panelType,
              // app attributes
              awaitForValues, // control to values
              awaitForValuesToQuery: awaitForValues, // get values from request search
              isShowedCriteria,
              isShowedTotals: true
            }

            commit('addBrowser', newBrowser)
            dispatch('addPanel', newBrowser)

            resolve(newBrowser)

            // Convert from gRPC process list
            const actions = []
            if (process) {
              actions.push({
                type: 'process',
                panelType: 'process',
                uuid: process.uuid,
                name: process.name,
                description: process.description,
                isReport: process.isReport,
                isDirectPrint: process.isDirectPrint,
                containerUuidAssociated: containerUuid,
                panelTypeAssociated: panelType
              })
              // TODO: No list of parameters
              // // add process associated in vuex store
              // dispatch('addProcessAssociated', {
              //   processToGenerate: process,
              //   containerUuidAssociated: containerUuid
              // })
            }
            // Add process menu
            dispatch('setContextMenu', {
              containerUuid,
              actions
            })
          })
          .catch(error => {
            router.push({ path: '/dashboard' })
            dispatch('tagsView/delView', routeToDelete)
            showMessage({
              message: language.t('login.unexpectedError'),
              type: 'error'
            })
            console.warn(`Dictionary Browser - Error ${error.code}: ${error.message}.`)
          })
      })
    },
    changeBrowserAttribute({ commit, getters }, {
      containerUuid,
      browser,
      attributeName,
      attributeNameControl,
      attributeValue
    }) {
      if (isEmptyValue(browser)) {
        browser = getters.getBrowser(containerUuid)
      }
      commit('changeBrowserAttribute', {
        browser,
        attributeName,
        attributeValue,
        attributeNameControl
      })
    }
  },
  getters: {
    getBrowser: (state) => (browserUuid) => {
      return state.browser.find(
        item => item.uuid === browserUuid
      )
    }
  }
}

export default browser