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

Application.Controllers.controller('ApplicationController', ['$rootScope', '$scope', '$window', '$locale', 'Session', 'AuthService', 'Auth', '$uibModal', '$state', 'growl', 'Notification', '$interval', 'Setting', '_t', 'Version',
  function ($rootScope, $scope, $window, $locale, Session, AuthService, Auth, $uibModal, $state, growl, Notification, $interval, Setting, _t, Version) {
  /* PRIVATE STATIC CONSTANTS */

    // User's notifications will get refreshed every 30s
    const NOTIFICATIONS_CHECK_PERIOD = 30000;

    /* PUBLIC SCOPE */

    // Fab-manager's version
    $scope.version =
      { version: '' };

    // currency symbol for the current locale (cf. angular-i18n)
    $rootScope.currencySymbol = $locale.NUMBER_FORMATS.CURRENCY_SYM;

    /**
     * Set the current user to the provided value and initialize the session
     * @param user {Object} Rails/Devise user
     */
    $scope.setCurrentUser = function (user) {
      if (!angular.isUndefinedOrNull(user)) {
        $rootScope.currentUser = user;
        Session.create(user);
        getNotifications();
        // fab-manager's app-version
        if (user.role === 'admin') {
          return $scope.version = Version.get();
        } else {
          return $scope.version = { version: '' };
        }
      }
    };

    /**
     * Login callback
     * @param e {Object} see https://docs.angularjs.org/guide/expression#-event-
     * @param callback {function}
     */
    $scope.login = function (e, callback) {
      if (e) { e.preventDefault(); }
      return openLoginModal(null, null, callback);
    };

    /**
     * Logout callback
     * @param e {Object} see https://docs.angularjs.org/guide/expression#-event-
     */
    $scope.logout = function (e) {
      e.preventDefault();
      return Auth.logout().then(function () {
        Session.destroy();
        $rootScope.currentUser = null;
        $rootScope.toCheckNotifications = false;
        $scope.notifications = {
          total: 0,
          unread: 0
        };
        return $state.go('app.public.home');
      }, function (error) {
        console.error(`An error occurred logging out: ${error}`);
      });
    };

    /**
     * Open the modal window allowing the user to create an account.
     * @param e {Object} see https://docs.angularjs.org/guide/expression#-event-
     */
    $scope.signup = function (e) {
      if (e) { e.preventDefault(); }

      return $uibModal.open({
        templateUrl: '<%= asset_path "shared/signupModal.html" %>',
        size: 'md',
        controller: ['$scope', '$uibModalInstance', 'Group', 'CustomAsset', function ($scope, $uibModalInstance, Group, CustomAsset) {
          // default parameters for the date picker in the account creation modal
          $scope.datePicker = {
            format: Fablab.uibDateFormat,
            opened: false,
            options: {
              startingDay: Fablab.weekStartingDay
            }
          };

          // callback to open the date picker (account creation modal)
          $scope.openDatePicker = function ($event) {
            $event.preventDefault();
            $event.stopPropagation();
            return $scope.datePicker.opened = true;
          };

          // retrieve the groups (standard, student ...)
          Group.query(function (groups) {
            $scope.groups = groups;
          });

          // retrieve the CGU
          CustomAsset.get({ name: 'cgu-file' }, function (cgu) {
            $scope.cgu = cgu.custom_asset;
          });

          // default user's parameters
          $scope.user = {
            is_allow_contact: true,
            is_allow_newsletter: false
          };

          // Errors display
          $scope.alerts = [];
          $scope.closeAlert = function (index) {
            $scope.alerts.splice(index, 1);
          };

          // callback for form validation
          $scope.ok = function () {
          // try to create the account
            $scope.alerts = [];
            // remove 'organization' attribute
            const orga = $scope.user.organization;
            delete $scope.user.organization;
            // register on server
            return Auth.register($scope.user).then(function (user) {
              // creation successful
              $uibModalInstance.close(user);
            }, function (error) {
              // creation failed...
              // restore organization param
              $scope.user.organization = orga;
              // display errors
              angular.forEach(error.data.errors, function (v, k) {
                angular.forEach(function (v, err) {
                  $scope.alerts.push({
                    msg: k + ': ' + err,
                    type: 'danger'
                  });
                });
              });
            });
          };
        }]
      }).result['finally'](null).then(function (user) {
        // when the account was created successfully, set the session to the newly created account
        $scope.setCurrentUser(user);
      });
    };

    /**
     * Open the modal window allowing the user to change his password.
     * @param token {string} security token for password changing. The user should have recieved it by mail
     */
    $scope.editPassword = function (token) {
      $uibModal.open({
        templateUrl: '<%= asset_path "shared/passwordEditModal.html" %>',
        size: 'md',
        controller: ['$scope', '$uibModalInstance', '$http', function ($scope, $uibModalInstance, $http) {
          $scope.user = { reset_password_token: token };
          $scope.alerts = [];
          $scope.closeAlert = function (index) {
            $scope.alerts.splice(index, 1);
          };

          return $scope.changePassword = function () {
            $scope.alerts = [];
            return $http.put('/users/password.json', { user: $scope.user }).success(function () { $uibModalInstance.close(); }).error(function (data) {
              angular.forEach(data.errors, function (v, k) {
                angular.forEach(function (v, err) {
                  $scope.alerts.push({
                    msg: k + ': ' + err,
                    type: 'danger'
                  });
                });
              });
            });
          };
        }]
      }).result['finally'](null).then(function () {
        growl.success(_t('your_password_was_successfully_changed'));
        return Auth.login().then(function (user) {
          $scope.setCurrentUser(user);
        }, function (error) {
          console.error(`Authentication failed: ${error}`);
        }
        );
      });
    };

    /**
     * Compact/Expend the width of the left navigation bar
     * @param event {Object} see https://docs.angularjs.org/guide/expression#-event-
     */
    $scope.toggleNavSize = function (event) {
      let $classes, $targets;
      if (typeof event === 'undefined') {
        console.error('[ApplicationController::toggleNavSize] Missing event parameter');
        return;
      }

      let toggler = $(event.target);
      if (!toggler.data('toggle')) { toggler = toggler.closest('[data-toggle^="class"]'); }

      const $class = toggler.data()['toggle'];
      const $target = toggler.data('target') || toggler.attr('data-link');

      if ($class) {
        const $tmp = $class.split(':')[1];
        if ($tmp) { $classes = $tmp.split(','); }
      }

      if ($target) {
        $targets = $target.split(',');
      }

      if ($classes && $classes.length) {
        $.each($targets, function (index) {
          if ($classes[index].indexOf('*') !== -1) {
            const patt = new RegExp('\\s',
              +$classes[index].replace(/\*/g, '[A-Za-z0-9-_]+').split(' ').join('\\s|\\s'),
              +'\\s', 'g');
            $(toggler).each(function (i, it) {
              let cn = ` ${it.className} `;
              while (patt.test(cn)) {
                cn = cn.replace(patt, ' ');
              }
              return it.className = $.trim(cn);
            });
          }

          return (($targets[index] !== '#') && $($targets[index]).toggleClass($classes[index])) || toggler.toggleClass($classes[index]);
        });
      }

      toggler.toggleClass('active');
    };

    /* PRIVATE SCOPE */
    /**
     * Kind of constructor: these actions will be realized first when the controller is loaded
     */
    const initialize = function () {
      // try to retrieve any currently logged user
      Auth.login().then(function (user) {
        $scope.setCurrentUser(user);
        // force users to complete their profile if they are not
        if (user.need_completion) {
          return $state.transitionTo('app.logged.profileCompletion');
        }
      }, function () {
        console.info('No users currently logged');
        $rootScope.toCheckNotifications = false;
      });

      // bind to the $stateChangeStart event (AngularJS/UI-Router)
      $rootScope.$on('$stateChangeStart', function (event, toState, toParams) {
        if (!toState.data) { return; }

        const { authorizedRoles } = toState.data;
        if (!AuthService.isAuthorized(authorizedRoles)) {
          event.preventDefault();
          if (AuthService.isAuthenticated()) {
          // user is not allowed
            console.error('[ApplicationController::initialize] user is not allowed');
          } else {
          // user is not logged in
            openLoginModal(toState, toParams);
          }
        }
      });

      // we stop polling notifications when the page is not in foreground
      onPageVisible(function (state) { $rootScope.toCheckNotifications = (state === 'visible'); });

      Setting.get({ name: 'fablab_name' }, function (data) { $scope.fablabName = data.setting.value; });
      Setting.get({ name: 'name_genre' }, function (data) { $scope.nameGenre = data.setting.value; });

      // shorthands
      $scope.isAuthenticated = Auth.isAuthenticated;
      $scope.isAuthorized = AuthService.isAuthorized;
      $rootScope.login = $scope.login;
    };

    /**
     * Retreive once the notifications from the server and display a message popup for each new one.
     * Then, periodically check for new notifications.
     */
    var getNotifications = function () {
      $rootScope.toCheckNotifications = true;
      if (!$rootScope.checkNotificationsIsInit && !!$rootScope.currentUser) {
        setTimeout(function () {
          // we request the most recent notifications
          Notification.last_unread(function (notifications) {
            $rootScope.lastCheck = new Date();
            $scope.notifications = notifications.totals;

            const toDisplay = [];
            angular.forEach(notifications.notifications, function (n) { toDisplay.push(n); });

            if (toDisplay.length < notifications.totals.unread) {
              toDisplay.push({ message: { description: _t('and_NUMBER_other_notifications', { NUMBER: notifications.totals.unread - toDisplay.length }, 'messageformat') } });
            }

            angular.forEach(toDisplay, function (notification) { growl.info(notification.message.description); });
          });
        }, 2000);

        const checkNotifications = function () {
          if ($rootScope.toCheckNotifications) {
            return Notification.polling({ last_poll: $rootScope.lastCheck }).$promise.then(function (data) {
              $rootScope.lastCheck = new Date();
              $scope.notifications = data.totals;

              angular.forEach(data.notifications, function (notification) { growl.info(notification.message.description); });
            });
          }
        };

        $interval(checkNotifications, NOTIFICATIONS_CHECK_PERIOD);
        $rootScope.checkNotificationsIsInit = true;
      }
    };

    /**
     * Open the modal window allowing the user to log in.
     */
    var openLoginModal = function (toState, toParams, callback) {
      <% active_provider = AuthProvider.active %>
      <% if active_provider.providable_type != DatabaseProvider.name %>
      $window.location.href = '<%=user_omniauth_authorize_path(AuthProvider.active.strategy_name.to_sym)%>';
      <% else %>
      return $uibModal.open({
        templateUrl: '<%= asset_path "shared/deviseModal.html" %>',
        size: 'sm',
        controller: ['$scope', '$uibModalInstance', '_t', function ($scope, $uibModalInstance, _t) {
          const user = ($scope.user = {});
          $scope.login = function () {
            Auth.login(user).then(function (user) {
              // Authentication succeeded ...
              $uibModalInstance.close(user);
              if (callback && (typeof callback === 'function')) {
                return callback(user);
              }
            }
            , function (error) {
              console.error(`Authentication failed: ${error}`);
              $scope.alerts = [];
              return $scope.alerts.push({
                msg: _t('wrong_email_or_password'),
                type: 'danger'
              });
            });
          };
          // handle modal behaviors. The provided reason will be used to define the following actions
          $scope.dismiss = function () { $uibModalInstance.dismiss('cancel'); };

          $scope.openSignup = function (e) {
            e.preventDefault();
            return $uibModalInstance.dismiss('signup');
          };

          return $scope.openResetPassword = function (e) {
            e.preventDefault();
            return $uibModalInstance.dismiss('resetPassword');
          };
        }]
      }).result['finally'](null).then(function (user) {
        // what to do when the modal is closed

        // authentication succeeded, set the session, gather the notifications and redirect
        $scope.setCurrentUser(user);

        if ((toState !== null) && (toParams !== null)) {
          return $state.go(toState, toParams);
        }
      }, function (reason) {
        // authentication did not ended successfully
        if (reason === 'signup') {
          // open signup modal
          $scope.signup();
        } else if (reason === 'resetPassword') {
          // open the 'reset password' modal
          return $uibModal.open({
            templateUrl: '<%= asset_path "shared/passwordNewModal.html" %>',
            size: 'sm',
            controller: ['$scope', '$uibModalInstance', '$http', function ($scope, $uibModalInstance, $http) {
              $scope.user = { email: '' };
              return $scope.sendReset = function () {
                $scope.alerts = [];
                return $http.post('/users/password.json', { user: $scope.user }).success(function () { $uibModalInstance.close(); }).error(function () {
                  $scope.alerts.push({
                    msg: _t('your_email_address_is_unknown'),
                    type: 'danger'
                  });
                });
              };
            }]
          }).result['finally'](null).then(function () { growl.info(_t('you_will_receive_in_a_moment_an_email_with_instructions_to_reset_your_password')); });
        }
      });
    };

    // otherwise the user just closed the modal
    <% end %>

    /**
     * Detect if the current page (tab/window) is active of put as background.
     * When the status changes, the callback is triggered with the new status as parameter
     * Inspired by http://stackoverflow.com/questions/1060008/is-there-a-way-to-detect-if-a-browser-window-is-not-currently-active#answer-1060034
     */
    var onPageVisible = function (callback) {
      let hidden = 'hidden';

      const onchange = function (evt) {
        const v = 'visible';
        const h = 'hidden';
        const evtMap = {
          focus: v,
          focusin: v,
          pageshow: v,
          blur: h,
          focusout: h,
          pagehide: h
        };
        evt = evt || window.event;
        if (evt.type in evtMap) {
          if (typeof callback === 'function') { callback(evtMap[evt.type]); }
        } else {
          if (typeof callback === 'function') { callback(this[hidden] ? 'hidden' : 'visible'); }
        }
      };

      // Standards:
      if (hidden in document) {
        document.addEventListener('visibilitychange', onchange);
      } else if ((hidden = 'mozHidden') in document) {
        document.addEventListener('mozvisibilitychange', onchange);
      } else if ((hidden = 'webkitHidden') in document) {
        document.addEventListener('webkitvisibilitychange', onchange);
      } else if ((hidden = 'msHidden') in document) {
        document.addEventListener('msvisibilitychange', onchange);
        // IE 9 and lower
      } else if ('onfocusin' in document) {
        document.onfocusin = (document.onfocusout = onchange);
        // All others
      } else {
        window.onpageshow = (window.onpagehide = (window.onfocus = (window.onblur = onchange)));
      }
      // set the initial state (but only if browser supports the Page Visibility API)
      if (document[hidden] !== undefined) {
        return onchange({ type: document[hidden] ? 'blur' : 'focus' });
      }
    };

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