import { defineStore } from 'pinia'

const FETCH_ANNOUNCEMENT_INTERVAL_MS = 1000 * 60 * 5

export const useAnnouncementsStore = defineStore('announcements', {
  state: () => ({
    announcements: [],
    supportsAnnouncements: true,
    fetchAnnouncementsTimer: undefined,
  }),
  getters: {
    unreadAnnouncementCount() {
      if (!window.vuex.state.users.currentUser) {
        return 0
      }

      const unread = this.announcements.filter(
        (announcement) => !(announcement.inactive || announcement.read),
      )
      return unread.length
    },
  },
  actions: {
    fetchAnnouncements() {
      if (!this.supportsAnnouncements) {
        return Promise.resolve()
      }

      const currentUser = window.vuex.state.users.currentUser
      const isAdmin =
        currentUser &&
        currentUser.privileges.includes('announcements_manage_announcements')

      const getAnnouncements = async () => {
        if (!isAdmin) {
          return window.vuex.state.api.backendInteractor.fetchAnnouncements()
        }

        const all =
          await window.vuex.state.api.backendInteractor.adminFetchAnnouncements()
        const visible =
          await window.vuex.state.api.backendInteractor.fetchAnnouncements()
        const visibleObject = visible.reduce((a, c) => {
          a[c.id] = c
          return a
        }, {})
        const getWithinVisible = (announcement) =>
          visibleObject[announcement.id]

        all.forEach((announcement) => {
          const visibleAnnouncement = getWithinVisible(announcement)
          if (!visibleAnnouncement) {
            announcement.inactive = true
          } else {
            announcement.read = visibleAnnouncement.read
          }
        })

        return all
      }

      return getAnnouncements()
        .then((announcements) => {
          this.announcements = announcements
        })
        .catch((error) => {
          // If and only if backend does not support announcements, it would return 404.
          // In this case, silently ignores it.
          if (error && error.statusCode === 404) {
            this.supportsAnnouncements = false
          } else {
            throw error
          }
        })
    },
    markAnnouncementAsRead(id) {
      return window.vuex.state.api.backendInteractor
        .dismissAnnouncement({ id })
        .then(() => {
          const index = this.announcements.findIndex((a) => a.id === id)

          if (index < 0) {
            return
          }

          this.announcements[index].read = true
        })
    },
    startFetchingAnnouncements() {
      if (this.fetchAnnouncementsTimer) {
        return
      }

      const interval = setInterval(
        () => this.fetchAnnouncements(),
        FETCH_ANNOUNCEMENT_INTERVAL_MS,
      )
      this.fetchAnnouncementsTimer = interval

      return this.fetchAnnouncements()
    },
    stopFetchingAnnouncements() {
      const interval = this.fetchAnnouncementsTimer
      this.fetchAnnouncementsTimer = undefined
      clearInterval(interval)
    },
    postAnnouncement({ content, startsAt, endsAt, allDay }) {
      return window.vuex.state.api.backendInteractor
        .postAnnouncement({ content, startsAt, endsAt, allDay })
        .then(() => {
          return this.fetchAnnouncements()
        })
    },
    editAnnouncement({ id, content, startsAt, endsAt, allDay }) {
      return window.vuex.state.api.backendInteractor
        .editAnnouncement({ id, content, startsAt, endsAt, allDay })
        .then(() => {
          return this.fetchAnnouncements()
        })
    },
    deleteAnnouncement(id) {
      return window.vuex.state.api.backendInteractor
        .deleteAnnouncement({ id })
        .then(() => {
          return this.fetchAnnouncements()
        })
    },
  },
})