import axios from 'axios'
import url from '@/plugins/routes'
const timeout = 5000
const state = {
  users: [],
  allUsers: [],
  filter: '',
  usersLoading: false,
  allUsersLoading: false,
  messages: [],
  menu: false,
  locked: false
}

const mutations = {
  setAllUsers: (state, users) => {
    state.allUsers = []
    state.allUsers = users
    for (let i = 0; i < state.allUsers.length; i++) {
      state.allUsers[i].fullName =
        state.allUsers[i].firstname + ' ' + state.allUsers[i].lastname
    }
  },
  setUsers: (state, users) => {
    for (let user in users) {
      let existuser = state.users.find(a => {
        return user === a.username
      })
      if (users[user].last_seen != null || users[user].last_seen != undefined) {
        users[user].last_seen = new Date(
          users[user].last_seen.year,
          users[user].last_seen.month - 1,
          users[user].last_seen.day,
          users[user].last_seen.hour,
          users[user].last_seen.minute,
          users[user].last_seen.second
        )
      }
      if (existuser) {
        existuser.sername = users[user].username
        existuser.firstname = users[user].firstname
        existuser.lastname = users[user].lastname
        existuser.locked = users[user].locked
        existuser.amount = users[user].amount
        existuser.type = users[user].type
        existuser.limit = users[user].limit
        existuser.last_seen = users[user].last_seen
        existuser.autoLock = users[user].autoLock
          ? users[user].autoLock
          : existuser.autoLock
      } else {
        state.users.push({
          username: users[user].username,
          firstname: users[user].firstname,
          lastname: users[user].lastname,
          locked: users[user].locked,
          amount: users[user].amount,
          type: users[user].type,
          loading: false,
          limit: users[user].limit,
          last_seen: users[user].last_seen,
          autoLock: users[user].autoLock
        })
      }
    }
    mutations.sortUsers(state)
  },
  updateUser: (state, data) => {
    let index = state.users.indexOf(
      state.users.find(a => {
        return a.username === data.username
      })
    )
    if (data.loading !== undefined) state.users[index].loading = data.loading
    if (data.last_seen !== undefined)
      state.users[index].last_seen = data.last_seen
  },
  sortUsers: state => {
    state.users = state.users.sort((a, b) => {
      if (a.lastname > b.lastname) return 1
      if (a.lastname < b.lastname) return -1
      if (a.firstname > b.firstname) return 1
      if (a.firstname < b.firstname) return -1
      return 0
    })
  },
  setFilter: (state, filter) => {
    state.filter = filter
  },
  setUsersLoading: (state, value) => {
    state.usersLoading = value
  },
  setAllUsersLoading: (state, value) => {
    state.allUsersLoading = value
  },
  addMessage: (state, data) => {
    var message = null
    if (state.messages.length > 0) {
      if (
        state.messages[0].user.username === data.user.username &&
        !data.error
      ) {
        message = state.messages[0]
        if ((new Date() - state.messages[0].date) / 1000 < 2) {
          clearTimeout(message.timeout)
          message.amount = message.amount + data.amount
          message.visible = true
          message.date = new Date()
          message.timeout = setTimeout(() => {
            if (!message.error) {
              message.visible = false
            }
          }, 5000)
          return
        } else {
          message.visible = false
        }
      }
    }
    let message2 = {
      user: data.user,
      error: data.error,
      storno: false,
      loading: false,
      visible: true,
      amount: data.amount,
      date: new Date(),
      timeout: setTimeout(() => {
        if (!message2.error) {
          message2.visible = false
        }
      }, 5000)
    }
    state.messages.unshift(message2)
  },
  updateMessage: (state, data) => {
    var message = state.messages.find(msg => {
      return msg.date - data.date === 0 ? true : false
    })
    if (message) {
      if (data.storno !== undefined) message.storno = data.storno
      if (data.loading !== undefined) message.loading = data.loading
    }
  },
  setMenu: (state, value) => {
    state.menu = value
  },
  setLocked: (satet, value) => {
    state.locked = value
  }
}

const actions = {
  // eslint-disable-next-line no-unused-vars
  async getUsers({ commit, rootState, dispatch }) {
    commit('setUsersLoading', true)
    try {
      const response = await axios.get(url.bar, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setUsers', response.data)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
    commit('setUsersLoading', false)
  },
  async addAmount({ commit, rootState, dispatch }, data) {
    try {
      commit('updateUser', { username: data.username, loading: true })
    } catch (e) {
      //error
    }
    try {
      const response = await axios.post(
        url.barAddAmount,
        { userId: data.username, amount: data.amount },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('setUsers', { [response.data.username]: response.data })
      commit('addMessage', {
        user: data.user,
        amount: data.amount,
        error: false
      })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      console.log(typeof e)
      for (const [key, value] of Object.entries(e)) {
        console.log(`${key}: ${value}`)
      }
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      commit('addMessage', {
        user: data.user,
        amount: data.amount,
        error: true
      })
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
    try {
      commit('updateUser', { username: data.username, loading: false })
    } catch (e) {
      //error
    }
  },
  async addCreditList({ commit, rootState, dispatch }, data) {
    try {
      commit('updateUser', { username: data.username, loading: true })
    } catch (e) {
      //error
    }
    try {
      const response = await axios.post(
        url.barGetUser,
        { userId: data.username },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('setUsers', { [response.data.username]: response.data })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
    try {
      commit('updateUser', {
        username: data.username,
        loading: false,
        last_seen: new Date()
      })
    } catch {
      // error
    }
  },
  async getAllUsers({ commit, rootState, dispatch }) {
    commit('setAllUsersLoading', true)
    try {
      const response = await axios.get(url.searchUser, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setAllUsers', response.data)
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.data === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
    commit('setAllUsersLoading', false)
  },
  async storno({ commit, rootState, dispatch }, data) {
    commit('updateMessage', { date: data.date, loading: true })
    try {
      const response = await axios.post(
        url.barU.storno,
        {
          userId: data.username,
          amount: data.amount
        },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('setUsers', { [response.data.username]: response.data })
      commit('updateMessage', { date: data.date, storno: true })
      dispatch('getLifeTime', null, { root: true })
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
    commit('updateMessage', { date: data.date, loading: false })
  },
  async getLocked({ commit, rootState, dispatch }) {
    try {
      const response = await axios.get(url.barU.lock, {
        headers: { Token: rootState.login.user.accessToken },
        timeout
      })
      commit('setLocked', response.data.value)
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
  },
  async setLocked({ commit, rootState, dispatch }) {
    try {
      const response = await axios.post(
        url.barU.lock,
        { value: true },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      commit('setLocked', response.data.value)
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
  },
  async unlock({ commit, rootState, dispatch }, password) {
    try {
      const valid = await axios.post(
        url.user.valid,
        { password: password },
        { headers: { Token: rootState.login.user.accessToken }, timeout }
      )
      if (valid.data.ok === 'ok') {
        const response = await axios.post(
          url.barU.lock,
          { value: false },
          { headers: { Token: rootState.login.user.accessToken } }
        )
        commit('setLocked', response.data.value)
      }
    } catch (e) {
      if (e.message == 'Network Error') {
        dispatch('connectionError/addError', null, { root: true })
      }
      if (e.response)
        if (e.response.status === 401) {
          dispatch('getLifeTime', null, { root: true })
          location.reload()
        }
    }
  },
  setFilter({ commit }, data) {
    commit('setFilter', data)
  },
  activateMenu({ commit }) {
    commit('setMenu', true)
  },
  deactivateMenu({ commit }) {
    commit('setMenu', false)
  }
}

const getters = {
  users: state => {
    return state.users
  },
  allUsers: state => {
    return state.allUsers
  },
  filter: state => {
    return state.filter
  },
  usersLoading: state => {
    return state.usersLoading
  },
  allUsersLoading: state => {
    return state.allUsersLoading
  },
  messages: state => {
    return state.messages
  },
  menu: state => {
    return state.menu
  },
  locked: state => {
    return state.locked
  }
}

export default {
  namespaced: true,
  state,
  mutations,
  actions,
  getters
}