text: import {
    // eslint-disable-next-line camelcase
    BundleService_ListBundles,
    // eslint-disable-next-line camelcase
    ValueService_SaveValue
  } from '../client/settings'
  import axios from 'axios'
  import keyBy from 'lodash/keyBy'
  
  const state = {
    config: null,
    initialized: false,
    bundles: {}
  }
  
  const getters = {
    config: state => state.config,
    initialized: state => state.initialized,
    extensions: state => {
      return [...new Set(Object.values(state.bundles).map(bundle => bundle.extension))].sort()
    },
    getBundlesByExtension: state => extension => {
      return Object.values(state.bundles)
        .filter(bundle => bundle.extension === extension)
        .sort((b1, b2) => {
          return b1.name.localeCompare(b2.name)
        })
    },
    getServerForJsClient: (state, getters, rootState, rootGetters) => rootGetters.configuration.server.replace(/\/$/, '')
  }
  
  const mutations = {
    SET_INITIALIZED (state, value) {
      state.initialized = value
    },
    SET_BUNDLES (state, bundles) {
      state.bundles = keyBy(bundles, 'id')
    },
    LOAD_CONFIG (state, config) {
      state.config = config
    }
  }
  
  const actions = {
    // Used by ocis-web.
    loadConfig ({ commit }, config) {
      commit('LOAD_CONFIG', config)
    },
  
    async initialize ({ commit, dispatch }) {
      await dispatch('fetchBundles')
      commit('SET_INITIALIZED', true)
    },
  
    async fetchBundles ({ commit, dispatch, getters, rootGetters }) {
      injectAuthToken(rootGetters)
      try {
        const response = await BundleService_ListBundles({
          $domain: getters.getServerForJsClient,
          body: {}
        })
        if (response.status === 201) {
          // the settings markup has implicit typing. inject an explicit type variable here
          const bundles = response.data.bundles
          if (bundles) {
            bundles.forEach(bundle => {
              bundle.settings.forEach(setting => {
                if (setting.intValue) {
                  setting.type = 'number'
                } else if (setting.stringValue) {
                  setting.type = 'string'
                } else if (setting.boolValue) {
                  setting.type = 'boolean'
                } else if (setting.singleChoiceValue) {
                  setting.type = 'singleChoice'
                } else if (setting.multiChoiceValue) {
                  setting.type = 'multiChoice'
                } else {
                  setting.type = 'unknown'
                }
              })
            })
            commit('SET_BUNDLES', bundles)
          } else {
            commit('SET_BUNDLES', [])
          }
        }
      } catch (err) {
        dispatch('showMessage', {
          title: 'Failed to fetch bundles.',
          status: 'danger'
        }, { root: true })
      }
    },
  
    async saveValue ({ commit, dispatch, getters, rootGetters }, { setting, payload }) {
      injectAuthToken(rootGetters)
      try {
        const response = await ValueService_SaveValue({
          $domain: getters.getServerForJsClient,
          body: {
            value: payload
          }
        })
        if (response.status === 201 && response.data.value) {
          commit('SET_SETTINGS_VALUE', response.data.value, { root: true })
        }
      } catch (e) {
        dispatch('showMessage', {
          title: `Failed to save »${setting.displayName}«.`,
          status: 'danger'
        }, { root: true })
      }
    }
  }
  
  export default {
    namespaced: true,
    state,
    getters,
    actions,
    mutations
  }
  
  function injectAuthToken (rootGetters) {
    axios.interceptors.request.use(config => {
      if (typeof config.headers.Authorization === 'undefined') {
        const token = rootGetters.user.token
        if (token) {
          config.headers.Authorization = `Bearer ${token}`
        }
      }
      return config
    })
  }
  