'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createReducer = exports.reducer = undefined;

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

var _actions = require('../actions');

var _index = require('../index');

var _settings = require('../actions/settings');

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

var SCREENS = {
  LOGIN: 'login',
  SIGNUP: 'signup',
  FORGOTPASSWORD: 'forgotpassword'
};

var reducer = exports.reducer = function reducer() {
  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _index.empty;
  var action = arguments[1];

  var error = void 0;
  var valid = void 0;

  switch (action.type) {
    case _actions.ActionTypes.LOAD_USER:
      return _extends({}, state, {
        auth: _extends({}, state.auth, {
          error: {},
          loading: true
        })
      });
    case _actions.ActionTypes.USER_LOADED:
      return _extends({}, state, {
        data: action.user,
        auth: _extends({}, state.auth, {
          loading: false
        })
      });
    case _actions.ActionTypes.USER_LOAD_FAILED:
      return _extends({}, state, {
        data: {}, // clear data
        auth: _extends({}, state.auth, {
          error: action.error,
          loading: false
        })
      });
    case _actions.ActionTypes.LOAD_BRANDING_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, action.branding)
      });
    case _settings.SettingsActionTypes.SAVE_BRANDING_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, action.branding, {
          tileBackground: action.branding.tileBackground || false
        })
      });
    case _settings.SettingsActionTypes.SAVE_TILE_BACKGROUND:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          tileBackground: action.data.tileBackground || false
        })
      });
    case _settings.SettingsActionTypes.SAVE_TILE_BACKGROUND_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, action.branding, {
          tileBackground: action.branding.tileBackground || false
        })
      });
    case _settings.SettingsActionTypes.SAVE_BACKGROUND_COLOR:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          backgroundColor: action.data.backgroundColor
        })
      });
    case _settings.SettingsActionTypes.SAVE_BACKGROUND_COLOR_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, action.branding, {
          tileBackground: action.branding.tileBackground || false
        })
      });
    case _settings.SettingsActionTypes.UPLOAD_LOGO_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          logoUrl: action.payload.url
        })
      });
    case _settings.SettingsActionTypes.UPLOAD_BACKGROUND_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          backgroundUrl: action.payload.url
        })
      });
    case _settings.SettingsActionTypes.REMOVE_LOGO_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          logoUrl: ''
        })
      });
    case _settings.SettingsActionTypes.REMOVE_BACKGROUND_SUCCESS:
      return _extends({}, state, {
        branding: _extends({}, state.branding, {
          backgroundUrl: ''
        })
      });
    case _actions.ActionTypes.CHANGE_LOGIN_EMAIL:
      switch (true) {
        case action.email.length === 0:
          valid = false;
          error = 'missing';
          break;
        case action.email.indexOf('@') <= 0:
          valid = false;
          error = 'invalid';
          break;
        default:
          valid = true;
          break;
      }

      return _extends({}, state, {
        login: _extends({}, state.login, {
          errors: {},
          email: { value: action.email, valid: valid, error: error },
          password: _extends({}, state.login.password, { valid: true, error: undefined })
        })
      });

    case _actions.ActionTypes.CHANGE_LOGIN_PASSWORD:
      switch (true) {
        case action.password.length === 0:
          valid = false;
          error = 'missing';
          break;
        case action.password.length < 4:
          valid = false;
          error = 'too-short';
          break;
        case action.password.length > 255:
          valid = false;
          error = 'too-long';
          break;
        default:
          valid = true;
          break;
      }
      return _extends({}, state, {
        login: _extends({}, state.login, {
          errors: {},
          email: _extends({}, state.login.email, { valid: true, error: undefined }),
          password: { value: action.password, valid: valid, error: error }
        })
      });

    case _actions.ActionTypes.LOGIN:
      return _extends({}, state, {
        login: _extends({}, state.login, {
          loading: true
        })
      });
    case _actions.ActionTypes.LOGIN_SUCCEEDED:
      return _extends({}, state, {
        login: _extends({}, state.login, {
          errors: {},
          password: {
            value: ''
          },
          loading: false
        })
      });
    case _actions.ActionTypes.LOGIN_FAILED:
      return _extends({}, state, {

        login: {
          loading: false,
          errors: {
            user: action.errors.user,
            api: action.errors.api
          },
          email: _extends({}, state.login.email, { error: action.errors.email, valid: !action.errors.email }),
          password: _extends({}, state.login.password, { error: action.errors.password, valid: !action.errors.password })
        },
        resendActivation: _extends({}, state.resendActivation, {
          info: false,
          email: action.errors.user === 'not-activated' ? state.login.email.value : state.resendActivation.email,
          password: action.errors.user === 'not-activated' ? state.login.password.value : state.resendActivation.password
        }),
        auth: _extends({}, state.auth, {
          loggedIn: false
        })
      });

    case _actions.ActionTypes.CHANGE_SIGNUP_NAME:
      switch (true) {
        case action.name.length === 0:
          valid = false;
          error = 'missing';
          break;

        case action.name.length > 255:
          valid = false;
          error = 'too-long';
          break;
        default:
          valid = true;
          break;
      }
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          errors: {},
          name: { value: action.name, valid: valid, error: error }
        })
      });

    case _actions.ActionTypes.CHANGE_SIGNUP_EMAIL:
      switch (true) {
        case action.email.length === 0:
          valid = false;
          error = 'missing';
          break;
        case !(action.email.length > action.email.indexOf('@') + 1 && action.email.indexOf('@') > 0):
          valid = false;
          error = 'invalid';
          break;
        default:
          valid = true;
          break;
      }
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          errors: {},
          email: { value: action.email, valid: valid, error: error },
          password: _extends({}, state.signup.password, { valid: true, error: undefined })
        })
      });

    case _actions.ActionTypes.CHANGE_SIGNUP_PASSWORD:
      switch (true) {
        case action.password.length === 0:
          valid = false;
          error = 'missing';
          break;
        case action.password.length < 4:
          valid = false;
          error = 'too-short';
          break;
        case action.password.length > 1024:
          valid = false;
          error = 'too-long';
          break;
        default:
          valid = true;
          break;
      }
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          errors: {},
          email: _extends({}, state.signup.email, { valid: true, error: undefined }),
          password: { value: action.password, valid: valid, error: error }
        })
      });

    case _actions.ActionTypes.SIGNUP:
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          errors: {},
          loading: true
        })
      });
    case _actions.ActionTypes.SIGNUP_SUCCEEDED:
      return _extends({}, state, {
        data: action.user,
        signup: _extends({}, state.signup, {
          errors: {},
          loading: false
        }),
        resendActivation: _extends({}, state.resendActivation, {
          email: state.signup.email.value,
          password: state.signup.password.value,
          info: true
        }),
        forgotPassword: _extends({}, state.forgotPassword, {
          success: false
        })
      });
    case _actions.ActionTypes.SIGNUP_FAILED:
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          loading: false,
          errors: {
            user: action.errors.user,
            api: action.errors.api
          },
          name: _extends({}, state.signup.name, { error: action.errors.name, valid: !action.errors.name }),
          email: _extends({}, state.signup.email, { error: action.errors.email, valid: !action.errors.email }),
          password: _extends({}, state.signup.password, { error: action.errors.password, valid: !action.errors.password })
        })
      });

    case _actions.ActionTypes.LOGIN_GOOGLE:
      return _extends({}, state, {
        google: _extends({}, state.google, {
          loading: true
        })
      });

    case _actions.ActionTypes.LOGIN_GOOGLE_SUCCEEDED:
      return _extends({}, state, {
        google: _extends({}, state.google, {
          loading: false
        })
      });

    case _actions.ActionTypes.LOGIN_GOOGLE_FAILED:
      return _extends({}, state, {
        google: _extends({}, state.google, {
          errors: _extends({}, action.errors),
          loading: false
        })
      });
    case _actions.ActionTypes.GOOGLE_API_LOADED:
      return _extends({}, state, {
        google: _extends({}, state.google, {
          apiReady: true
        })
      });

    case _actions.ActionTypes.CLEAR_GOOGLE_ERRORS:
      return _extends({}, state, {
        google: _extends({}, state.google, {
          errors: {}
        })
      });

    case _actions.ActionTypes.LOGIN_FACEBOOK:
      return _extends({}, state, {
        facebook: _extends({}, state.facebook, {
          loading: true
        })
      });

    case _actions.ActionTypes.LOGIN_FACEBOOK_SUCCEEDED:
      return _extends({}, state, {
        facebook: _extends({}, state.facebook, {
          loading: false
        })
      });

    case _actions.ActionTypes.LOGIN_FACEBOOK_FAILED:
      return _extends({}, state, {
        facebook: _extends({}, state.facebook, {
          errors: _extends({}, action.errors),
          loading: false
        })
      });

    case _actions.ActionTypes.FACEBOOK_API_LOADED:
      return _extends({}, state, {
        facebook: _extends({}, state.facebook, {
          apiReady: true
        })
      });

    case _actions.ActionTypes.CLEAR_FACEBOOK_ERRORS:
      return _extends({}, state, {
        facebook: _extends({}, state.facebook, {
          errors: {}
        })
      });

    case _actions.ActionTypes.LOGOUT:
      return _extends({}, state, {
        data: {},
        branding: _extends({}, _index.empty.branding),
        login: _extends({}, state.login, { password: { value: '' } })
      });

    case _actions.ActionTypes.RESEND_ACTIVATIONMAIL:
      return _extends({}, state, {
        resendActivation: _extends({}, state.resendActivation, {
          enabled: false,
          loading: true,
          error: false
        })
      });

    case _actions.ActionTypes.RESEND_ACTIVATIONMAIL_SUCCEEDED:
      return _extends({}, state, {
        resendActivation: _extends({}, state.resendActivation, {
          loading: false,
          error: false
        })
      });
    case _actions.ActionTypes.RESEND_ACTIVATIONMAIL_ENABLED:
      return _extends({}, state, {
        resendActivation: _extends({}, state.resendActivation, {
          enabled: true
        })
      });

    case _actions.ActionTypes.RESEND_ACTIVATIONMAIL_FAILED:
      return _extends({}, state, {
        resendActivation: _extends({}, state.resendActivation, {
          loading: false,
          enabled: true,
          error: true
        })
      });

    case _actions.ActionTypes.DISMISS_SIGNUP_API_ERROR:
      return _extends({}, state, {
        signup: _extends({}, state.signup, {
          errors: {}
        })
      });

    case _actions.ActionTypes.DISMISS_LOGIN_API_ERROR:
      return _extends({}, state, {
        login: _extends({}, state.login, {
          errors: {
            user: state.login.errors.user
          }
        })
      });

    case _actions.ActionTypes.DISMISS_LOGIN_USER_ERROR:
      return _extends({}, state, {
        login: _extends({}, state.login, {
          errors: {
            api: state.login.errors.api
          }
        })
      });

    case _actions.ActionTypes.DISMISS_SIGNUP_SUCCESS_INFO:
      return _extends({}, state, {
        resendActivation: _extends({}, state.resendActivation, {
          info: false
        })
      });

    case _actions.ActionTypes.CHANGE_FORGOTPASSWORD_EMAIL:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          email: action.email,
          valid: action.email.indexOf('@') > 0 && action.email.length > action.email.indexOf('@')
        })
      });

    case _actions.ActionTypes.SEND_FORGOTPASSWORD_INSTRUCTIONS:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          loading: true,
          errors: {}
        })
      });

    case _actions.ActionTypes.SEND_FORGOTPASSWORD_INSTRUCTIONS_SUCCEEDED:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          email: '',
          loading: false,
          errors: {},
          success: true
        })
      });

    case _actions.ActionTypes.SEND_FORGOTPASSWORD_INSTRUCTIONS_FAILED:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          loading: false,
          errors: action.errors,
          valid: false,
          success: false
        })
      });

    case _actions.ActionTypes.DISMISS_FORGOTPASSWORD_ERROR:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          errors: {}
        })
      });

    case _actions.ActionTypes.DISMISS_FORGOTPASSWORD_SUCCESS:
      return _extends({}, state, {
        forgotPassword: _extends({}, state.forgotPassword, {
          success: false
        })
      });

    case _actions.ActionTypes.SHOW_LOGIN_DIALOG:
      return _extends({}, state, {
        login: _extends({}, _index.empty.login, {
          email: { value: action.email || '' }
        }),
        google: _index.empty.google,
        facebook: _index.empty.facebook,
        dialog: {
          show: true,
          screen: SCREENS.LOGIN,
          drawer: 'signup-benefits'
        }
      });

    case _actions.ActionTypes.SHOW_SIGNUP_DIALOG:
      return _extends({}, _index.empty, { // clear state, *except*:
        signup: _extends({}, _index.empty.signup, {
          email: _extends({}, _index.empty.signup.email, {
            value: action.email || ''
          })
        }),
        data: state.data, // always keep user data
        dialog: {
          show: true,
          screen: SCREENS.SIGNUP,
          drawer: 'signup-benefits'
        }
      });

    case _actions.ActionTypes.SHOW_ACTIVATION_DIALOG:
      return _extends({}, _index.empty, { // clear state, *except*:
        data: state.data, // always keep user data
        dialog: {
          show: true,
          screen: 'activation'
        }
      });

    case _actions.ActionTypes.SHOW_FORGOTPASSWORD_DIALOG:
      return _extends({}, _index.empty, { // clear state, *except*:
        data: state.data, // always keep user data
        dialog: {
          show: true,
          screen: 'forgotpassword'
        },
        forgotPassword: _extends({}, state.forgotPassword, {
          email: state.login.email.value,
          errors: {},
          loading: false,
          success: false
        })
      });

    case _actions.ActionTypes.HIDE_AUTHENTICATION_DIALOG:
      var keepResendActivationData = action.keepResendActivationData;

      if (keepResendActivationData) {
        return _extends({}, _index.empty, { // clear state, *except*:
          resendActivation: _extends({}, state.resendActivation, {
            loading: false,
            error: false,
            info: false
          }),
          data: state.data, // always keep user data
          dialog: _extends({}, state.dialog, {
            show: false
          })
        });
      }
      return _extends({}, _index.empty, { // clear state, *except*:
        data: state.data, // always keep user data
        dialog: _extends({}, state.dialog, {
          show: false
        })
      });

    default:
      return state;
  }
};

/**
 * Creates a reducer that can be used with [`combineReducer`](http://redux.js.org/docs/api/combineReducers.html)
 * @param {Object} options Reducer options
 * @param {string} options.domain For mounting this reducer under a different key in redux. Default: `user`.
 *
 * @example
 * // reducer.js
 * import { createReducer as createUserReducer } from '@doodle/users-api-connector';
 * import { combineReducers } from 'redux';
 *
 * export default combineReducers({
 *   ...createUserReducer(), // providing the reducer under the `domain` key
 * })
 */
var createReducer = exports.createReducer = function createReducer() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  return _defineProperty({}, options.domain || 'user', reducer);
};