/* eslint-disable
    no-return-assign,
    no-undef,
*/
// TODO: This file was created by bulk-decaffeinate.
// Fix any style issues and re-enable lint.
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
'use strict'

// #
// Controller used in the public calendar global
// #

Application.Controllers.controller('CalendarController', ['$scope', '$state', '$aside', 'moment', 'Availability', 'Slot', 'Setting', 'growl', 'dialogs', 'bookingWindowStart', 'bookingWindowEnd', '_t', 'uiCalendarConfig', 'CalendarConfig', 'trainingsPromise', 'machinesPromise', 'spacesPromise',
  function ($scope, $state, $aside, moment, Availability, Slot, Setting, growl, dialogs, bookingWindowStart, bookingWindowEnd, _t, uiCalendarConfig, CalendarConfig, trainingsPromise, machinesPromise, spacesPromise) {
  /* PRIVATE STATIC CONSTANTS */
    let currentMachineEvent = null
    machinesPromise.forEach(m => m.checked = true)
    trainingsPromise.forEach(t => t.checked = true)
    spacesPromise.forEach(s => s.checked = true)

    // # check all formation/machine is select in filter
    const isSelectAll = (type, scope) => scope[type].length === scope[type].filter(t => t.checked).length

    /* PUBLIC SCOPE */

    // # List of trainings
    $scope.trainings = trainingsPromise.filter(t => !t.disabled)

    // # List of machines
    $scope.machines = machinesPromise.filter(t => !t.disabled)

    // # List of spaces
    $scope.spaces = spacesPromise.filter(t => !t.disabled)

    // # add availabilities source to event sources
    $scope.eventSources = []

    // # filter availabilities if have change
    $scope.filterAvailabilities = function (filter, scope) {
      if (!scope) { scope = $scope }
      scope.filter = ($scope.filter = {
        trainings: isSelectAll('trainings', scope),
        machines: isSelectAll('machines', scope),
        spaces: isSelectAll('spaces', scope),
        evt: filter.evt,
        dispo: filter.dispo
      })
      return $scope.calendarConfig.events = availabilitySourceUrl()
    }

    // # a variable for formation/machine/event/dispo checkbox is or not checked
    $scope.filter = {
      trainings: isSelectAll('trainings', $scope),
      machines: isSelectAll('machines', $scope),
      spaces: isSelectAll('spaces', $scope),
      evt: true,
      dispo: true
    }

    // # toggle to select all formation/machine
    $scope.toggleFilter = function (type, filter) {
      $scope[type].forEach(t => t.checked = filter[type])
      return $scope.filterAvailabilities(filter, $scope)
    }

    $scope.openFilterAside = () =>
      $aside.open({
        templateUrl: 'filterAside.html',
        placement: 'right',
        size: 'md',
        backdrop: false,
        resolve: {
          trainings () {
            return $scope.trainings
          },
          machines () {
            return $scope.machines
          },
          spaces () {
            return $scope.spaces
          },
          filter () {
            return $scope.filter
          },
          toggleFilter () {
            return $scope.toggleFilter
          },
          filterAvailabilities () {
            return $scope.filterAvailabilities
          }
        },
        controller: ['$scope', '$uibModalInstance', 'trainings', 'machines', 'spaces', 'filter', 'toggleFilter', 'filterAvailabilities', function ($scope, $uibModalInstance, trainings, machines, spaces, filter, toggleFilter, filterAvailabilities) {
          $scope.trainings = trainings
          $scope.machines = machines
          $scope.spaces = spaces
          $scope.filter = filter

          $scope.toggleFilter = (type, filter) => toggleFilter(type, filter)

          $scope.filterAvailabilities = filter => filterAvailabilities(filter, $scope)

          return $scope.close = function (e) {
            $uibModalInstance.dismiss()
            return e.stopPropagation()
          }
        }
        ] })

    /* PRIVATE SCOPE */

    const calendarEventClickCb = function (event, jsEvent, view) {
    // # current calendar object
      const { calendar } = uiCalendarConfig.calendars
      if (event.available_type === 'machines') {
        currentMachineEvent = event
        calendar.fullCalendar('changeView', 'agendaDay')
        return calendar.fullCalendar('gotoDate', event.start)
      } else if (event.available_type === 'space') {
        calendar.fullCalendar('changeView', 'agendaDay')
        return calendar.fullCalendar('gotoDate', event.start)
      } else if (event.available_type === 'event') {
        return $state.go('app.public.events_show', { id: event.event_id })
      } else if (event.available_type === 'training') {
        return $state.go('app.public.training_show', { id: event.training_id })
      } else {
        if (event.machine_id) {
          return $state.go('app.public.machines_show', { id: event.machine_id })
        } else if (event.space_id) {
          return $state.go('app.public.space_show', { id: event.space_id })
        }
      }
    }

    // # agendaDay view: disable slotEventOverlap
    // # agendaWeek view: enable slotEventOverlap
    const toggleSlotEventOverlap = function (view) {
    // set defaultView, because when we change slotEventOverlap
    // ui-calendar will trigger rerender calendar
      $scope.calendarConfig.defaultView = view.type
      const today = currentMachineEvent ? currentMachineEvent.start : moment().utc().startOf('day')
      if ((today > view.intervalStart) && (today < view.intervalEnd) && (today !== view.intervalStart)) {
        $scope.calendarConfig.defaultDate = today
      } else {
        $scope.calendarConfig.defaultDate = view.intervalStart
      }
      if (view.type === 'agendaDay') {
        return $scope.calendarConfig.slotEventOverlap = false
      } else {
        return $scope.calendarConfig.slotEventOverlap = true
      }
    }

    // # function is called when calendar view is rendered or changed
    const viewRenderCb = function (view, element) {
      toggleSlotEventOverlap(view)
      if (view.type === 'agendaDay') {
      // get availabilties by 1 day for show machine slots
        return uiCalendarConfig.calendars.calendar.fullCalendar('refetchEvents')
      }
    }

    const eventRenderCb = function (event, element) {
      if (event.tags.length > 0) {
        let html = ''
        for (let tag of Array.from(event.tags)) {
          html += `<span class='label label-success text-white'>${tag.name}</span> `
        }
        element.find('.fc-title').append(`<br/>${html}`)
      }
    }

    const getFilter = function () {
      const t = $scope.trainings.filter(t => t.checked).map(t => t.id)
      const m = $scope.machines.filter(m => m.checked).map(m => m.id)
      const s = $scope.spaces.filter(s => s.checked).map(s => s.id)
      return { t, m, s, evt: $scope.filter.evt, dispo: $scope.filter.dispo }
    }

    var availabilitySourceUrl = () => `/api/availabilities/public?${$.param(getFilter())}`

    const initialize = () =>
    // # fullCalendar (v2) configuration
      $scope.calendarConfig = CalendarConfig({
        events: availabilitySourceUrl(),
        slotEventOverlap: true,
        header: {
          left: 'month agendaWeek agendaDay',
          center: 'title',
          right: 'today prev,next'
        },
        minTime: moment.duration(moment(bookingWindowStart.setting.value).format('HH:mm:ss')),
        maxTime: moment.duration(moment(bookingWindowEnd.setting.value).format('HH:mm:ss')),
        defaultView: window.innerWidth <= 480 ? 'agendaDay' : 'agendaWeek',
        eventClick (event, jsEvent, view) {
          return calendarEventClickCb(event, jsEvent, view)
        },
        viewRender (view, element) {
          return viewRenderCb(view, element)
        },
        eventRender (event, element, view) {
          return eventRenderCb(event, element)
        }
      })

    // # !!! MUST BE CALLED AT THE END of the controller
    return initialize()
  }
])