var userpool = {
  actions: {
    getCurrentUser: function getCurrentUser(commit) {

      return new Promise(function (resolve, reject) {
        var cognitoUser = cognitoUserPool.getCurrentUser();

        if (!cognitoUser) {
          reject({
            message: "Can't retrieve the current user"
          });
          return;
        }

        cognitoUser.getSession(function (err, session) {
          if (err) {
            reject(err);
            return;
          }
          // Call AUTHENTICATE because it's utterly the same
          commit('AUTHENTICATE', constructUser(cognitoUser, session));
          resolve();
        });
      });
    },
    authenticateUser: function authenticateUser(commit, payload) {

      var authDetails = new _amazonCognitoIdentityJs.AuthenticationDetails({
        Username: payload.username,
        Password: payload.password
      });

      var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
        Pool: cognitoUserPool,
        Username: payload.username
      });

      return new Promise(function (resolve, reject) {
        return cognitoUser.authenticateUser(authDetails, {
          onFailure: function onFailure(err) {
            reject(err);
          },
          onSuccess: function onSuccess(session, userConfirmationNecessary) {
            commit('AUTHENTICATE', constructUser(cognitoUser, session));
            resolve({ userConfirmationNecessary: userConfirmationNecessary });
          }
        });
      });
    },
    signUp: function signUp(commit, userInfo) {

      /* userInfo: { username, password, attributes } */
      var userAttributes = Object.keys(userInfo.attributes || {}).map(function (key) {
        return new _amazonCognitoIdentityJs.CognitoUserAttribute({
          Name: key,
          Value: userInfo.attributes[key]
        });
      });

      return new Promise(function (resolve, reject) {
        cognitoUserPool.signUp(userInfo.username, userInfo.password, userAttributes, null, function (err, data) {
          if (!err) {
            commit('AUTHENTICATE', {
              username: data.user.getUsername(),
              tokens: null, // no session yet
              attributes: {}
            });
            resolve({ userConfirmationNecessary: !data.userConfirmed });
            return;
          }
          reject(err);
        });
      });
    },
    confirmRegistration: function confirmRegistration(state, payload) {

      var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
        Pool: cognitoUserPool,
        Username: payload.username
      });

      return new Promise(function (resolve, reject) {
        cognitoUser.confirmRegistration(payload.code, true, function (err) {
          if (!err) {
            resolve();
            return;
          }
          reject(err);
        });
      });
    },
    resendConfirmationCode: function resendConfirmationCode(commit, payload) {

      var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
        Pool: cognitoUserPool,
        Username: payload.username
      });

      return new Promise(function (resolve, reject) {
        cognitoUser.resendConfirmationCode(function (err) {
          if (!err) {
            resolve();
            return;
          }
          reject(err);
        });
      });
    },
    forgotPassword: function forgotPassword(commit, payload) {

      var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
        Pool: cognitoUserPool,
        Username: payload.username
      });

      return new Promise(function (resolve, reject) {
        return cognitoUser.forgotPassword({
          onSuccess: function onSuccess() {
            resolve();
          },
          onFailure: function onFailure(err) {
            reject(err);
          }
        });
      });
    },
    confirmPassword: function confirmPassword(commit, payload) {

      var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
        Pool: cognitoUserPool,
        Username: payload.username
      });

      return new Promise(function (resolve, reject) {
        cognitoUser.confirmPassword(payload.code, payload.newPassword, {
          onFailure: function onFailure(err) {
            reject(err);
          },
          onSuccess: function onSuccess() {
            resolve();
          }
        });
      });
    },


    // Only for authenticated users
    changePassword: function changePassword(state, payload) {

      return new Promise(function (resolve, reject) {
        // Make sure the user is authenticated
        if (state.user === null || state.user && state.user.tokens === null) {
          reject({
            message: 'User is unauthenticated'
          });
          return;
        }

        var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
          Pool: cognitoUserPool,
          Username: state.user.username
        });

        // Restore session without making an additional call to API
        cognitoUser.signInUserSession = cognitoUser.getCognitoUserSession(state.user.tokens);

        cognitoUser.changePassword(payload.oldPassword, payload.newPassword, function (err) {
          if (!err) {
            resolve();
            return;
          }
          reject(err);
        });
      });
    },


    // Only for authenticated users
    updateAttributes: function updateAttributes(context, payload) {
      var commit = context.commit,
        state = context.state;

      return new Promise(function (resolve, reject) {
        // Make sure the user is authenticated
        if (state.user === null || state.user && state.user.tokens === null) {
          reject({
            message: 'User is unauthenticated'
          });
          return;
        }

        var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
          Pool: cognitoUserPool,
          Username: state.user.username
        });

        // Restore session without making an additional call to API
        cognitoUser.signInUserSession = cognitoUser.getCognitoUserSession(state.user.tokens);

        var attributes = Object.keys(payload || {}).map(function (key) {
          return new _amazonCognitoIdentityJs.CognitoUserAttribute({
            Name: key,
            Value: payload[key]
          });
        });

        cognitoUser.updateAttributes(attributes, function (err) {
          if (!err) {
            resolve();
            return;
          }
          reject(err);
        });
      });
    },


    // Only for authenticated users
    getUserAttributes: function getUserAttributes(context) {
      var commit = context.commit,
        state = context.state;

      return new Promise(function (resolve, reject) {
        // Make sure the user is authenticated
        if (state.user === null || state.user && state.user.tokens === null) {
          reject({
            message: 'User is unauthenticated'
          });
          return;
        }

        var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
          Pool: cognitoUserPool,
          Username: state.user.username
        });

        // Restore session without making an additional call to API
        cognitoUser.signInUserSession = cognitoUser.getCognitoUserSession(state.user.tokens);

        cognitoUser.getUserAttributes(function (err, attributes) {
          if (err) {
            reject(err);
            return;
          }

          var attributesMap = (attributes || []).reduce(function (accum, item) {
            accum[item.Name] = item.Value;
            return accum;
          }, {});

          commit('ATTRIBUTES', attributesMap);
          resolve(attributesMap);
        });
      });
    },


    // Only for authenticated users
    signOut: function signOut(context) {
      var commit = context.commit,
        state = context.state;

      return new Promise(function (resolve, reject) {
        // Make sure the user is authenticated
        if (state.user === null || state.user && state.user.tokens === null) {
          reject({
            message: 'User is unauthenticated'
          });
          return;
        }

        var cognitoUser = new _amazonCognitoIdentityJs.CognitoUser({
          Pool: cognitoUserPool,
          Username: state.user.username
        });

        cognitoUser.signOut();
        commit('SIGNOUT');
        resolve();
      });
    }
  },
  mutations: {
    ATTRIBUTES: function(state, attributesMap) {
      state.user.attributes = attributesMap;
    },
    SIGNOUT: function(state) {
      state.user = null;
    },
    AUTHENTICATE: function(state, user) {
      state.user = user;
    }
  }
}

function constructUser(cognitoUser, session) {
  return {
    username: cognitoUser.getUsername(),
    tokens: {
      IdToken: session.getIdToken().getJwtToken(),
      AccessToken: session.getAccessToken().getJwtToken(),
      RefreshToken: session.getRefreshToken().getToken()
    },
    attributes: {}
  };
}