import axios from 'axios'
import url from '@/plugins/routes'

const state = {
  month: [],
  allUsers: [],
  disabled: 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
    }
  },
  createMonth: (state, date) => {
    let month = []
    let id = 0
    const year = date.getFullYear()
    const mon = date.getMonth()
    let a = new Date(year, mon + 1, 0)
    let days = a.getDate()
    let startDate = 1
    for (let intDay = 1; intDay <= days; intDay++) {
      if (new Date(year, mon, intDay).getDay() === 3) {
        startDate = intDay
        break
      }
    }
    let end = false
    let week = { id: id, days: {} }
    for (let intDay = startDate; intDay <= days + 7; intDay++) {
      if (end) break
      let currentDate = new Date(year, mon, intDay)

      switch (currentDate.getDay()) {
        case 1:
          mutations.setStartEndDate(week)
          month.push(week)
          id++
          week = { id: id, days: {} }
          week.days.monday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Montag',
            worker: [],
            loading: false,
            locked: false
          }
          break
        case 2:
          week.days.tuesday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Dienstag',
            worker: [],
            loading: false,
            locked: false
          }
          break
        case 3:
          if (currentDate.getMonth() === mon + 1) {
            end = true
            mutations.setStartEndDate(week)
            month.push(week)
          } else {
            week.days.wednesday = {
              id: currentDate.getDay(),
              date: currentDate,
              name: 'Mittwoch',
              worker: [],
              loading: false,
              locked: false
            }
          }
          break
        case 4:
          week.days.thursday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Donnerstag',
            worker: [],
            loading: false,
            locked: false
          }
          break
        case 5:
          week.days.friday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Freitag',
            worker: [],
            loading: false,
            locked: false
          }
          break
        case 6:
          week.days.satturday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Samstag',
            worker: [],
            loading: false,
            locked: false
          }
          break
        case 0:
          week.days.sunday = {
            id: currentDate.getDay(),
            date: currentDate,
            name: 'Sontag',
            worker: [],
            loading: false,
            locked: false
          }
          break
      }
    }
    state.month = month
  },
  setStartEndDate: week => {
    if (week.days.monday) {
      week.startDate = week.days.monday.date
    } else if (week.days.tuesday) {
      week.startDate = week.days.tuesday.date
    } else if (week.days.wednesday) {
      week.startDate = week.days.wednesday.date
    } else if (week.days.thursday) {
      week.startDate = week.days.thursday.date
    } else if (week.days.friday) {
      week.startDate = week.days.friday.date
    } else if (week.days.satturday) {
      week.startDate = week.days.satturday.date
    } else if (week.days.sunday) {
      week.startDate = week.days.sunday.date
    }

    if (week.days.sunday) {
      week.endDate = week.days.sunday.date
    } else if (week.days.satturday) {
      week.endDate = week.days.satturday.date
    } else if (week.days.friday) {
      week.endDate = week.days.friday.date
    } else if (week.days.thursday) {
      week.endDate = week.days.thursday.date
    } else if (week.days.wednesday) {
      week.endDate = week.days.wednesday.date
    } else if (week.days.tuesday) {
      week.endDate = week.days.tuesday.date
    } else if (week.days.monday) {
      week.endDate = week.days.monday.date
    }
  },
  updateMonth: (state, data) => {
    const date = new Date(data.start.year, data.start.month - 1, data.start.day)
    const user = data.user
    for (let week = 0; week < state.month.length; week++) {
      for (let day in state.month[week].days) {
        if (state.month[week].days[day].date - date === 0) {
          if (user) {
            let worker = state.month[week].days[day].worker.find(a => {
              return a.username === user.username
            })
            if (!worker && data.com === 'add') {
              state.month[week].days[day].worker.push({
                firstname: user.firstname,
                lastname: user.lastname,
                username: user.username,
                fullName: user.firstname + ' ' + user.lastname
              })
            }
          }
          if (data.day) {
            state.month[week].days[day].locked = data.day.locked
          }
        }
      }
    }
  },
  setDayLoading: (state, { date, getters }) => {
    let day = getters.getDay(date)
    day.loading = true
  },
  setDayNotLoading: (state, { date, getters }) => {
    let day = getters.getDay(date)
    day.loading = false
  },
  setDisabled: (state, data) => {
    state.disabled = data
  }
}
const actions = {
  createMonth({ commit }, date) {
    commit('setDisabled', true)
    commit('createMonth', date)
    commit('setDisabled', false)
  },
  async getAllUsers({ commit, rootState, dispatch }) {
    try {
      const response = await axios.post(
        url.searchUser,
        { searchString: '' },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('setAllUsers', response.data)
    } catch (e) {
      if (e.response)
        if (e.response.data === 401) dispatch('logout', null, { root: true })
    }
  },
  // eslint-disable-next-line no-unused-vars
  async addUser({ commit, rootState, dispatch }, data) {
    try {
      const response = await axios.post(
        url.vorstand.sm.addUser,
        { ...data },
        {
          headers: { Token: rootState.login.user.accessToken }
        }
      )
      commit('updateMonth', { ...response.data[0], com: 'add' })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async getUser({ commit, rootState, dispatch, getters }, data) {
    commit('setDayLoading', { date: data.startdatetime, getters })
    try {
      const response = await axios.post(
        url.vorstand.sm.getUser,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      for (let item = 0; item < response.data.worker.length; item++) {
        commit('updateMonth', {
          ...response.data.worker[item],
          com: 'add',
          day: response.data.day
        })
      }
      commit('updateMonth', {
        start: response.data.day.date,
        day: response.data.day
      })
      commit('setDayNotLoading', { date: data.startdatetime, getters })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  // eslint-disable-next-line no-unused-vars
  async deleteUser({ commit, rootState, dispatch }, data) {
    try {
      // eslint-disable-next-line no-unused-vars
      const response = await axios.post(
        url.vorstand.sm.deleteUser,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('updateMonth', { ...data, com: 'delete' })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  async lockDay({ commit, rootState, dispatch }, data) {
    try {
      const response = await axios.post(
        url.vorstand.sm.lockDay,
        { ...data },
        { headers: { Token: rootState.login.user.accessToken } }
      )
      commit('updateMonth', { start: response.data.date, day: response.data })
    } catch (e) {
      if (e.response)
        if (e.response.status === 401) dispatch('logout', null, { root: true })
    }
  },
  setDayLoading({ commit, getters }, date) {
    commit('setDayLoading', { date, getters })
  },
  setDayNotLoading({ commit, getters }, date) {
    commit('setDayNotLoading', { date, getters })
  }
}
const getters = {
  month: state => {
    return state.month
  },
  allUsers: state => {
    return state.allUsers
  },
  getDayLoading: (state, getters) => date => {
    let day = getters.getDay(date)
    return day.loading
  },
  getDay: state => date => {
    for (let week = 0; week < state.month.length; week++) {
      for (let day in state.month[week].days) {
        if (state.month[week].days[day].date - date === 0) {
          return state.month[week].days[day]
        }
      }
    }
  },
  disabled: state => {
    return state.disabled
  }
}

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