'use strict';

// //////////////////////////////////////////////////////////////////////////////
// / @brief Foxx Authentication
// /
// / @file
// /
// / DISCLAIMER
// /
// / Copyright 2013 triagens GmbH, Cologne, Germany
// /
// / Licensed under the Apache License, Version 2.0 (the "License")
// / you may not use this file except in compliance with the License.
// / You may obtain a copy of the License at
// /
// /     http://www.apache.org/licenses/LICENSE-2.0
// /
// / Unless required by applicable law or agreed to in writing, software
// / distributed under the License is distributed on an "AS IS" BASIS,
// / WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// / See the License for the specific language governing permissions and
// / limitations under the License.
// /
// / Copyright holder is triAGENS GmbH, Cologne, Germany
// /
// / @author Jan Steemann, Lucas Dohmen
// / @author Copyright 2013, triAGENS GmbH, Cologne, Germany
// //////////////////////////////////////////////////////////////////////////////

var db = require('@arangodb').db,
  crypto = require('@arangodb/crypto'),
  internal = require('internal'),
  is = require('@arangodb/is'),
  _ = require('lodash'),
  errors = internal.errors,
  defaultsFor = {};

function createAuthenticationMiddleware (auth, applicationContext) {
  return function (req) {
    var users = new Users(applicationContext),
      authResult = auth.authenticate(req);

    if (authResult.errorNum === errors.ERROR_NO_ERROR.code) {
      req.currentSession = authResult.session;
      req.user = users.get(authResult.session.identifier);
    } else {
      req.currentSession = null;
      req.user = null;
    }
  };
}

function createSessionUpdateMiddleware () {
  return function (req) {
    var session = req.currentSession;

    if (is.existy(session)) {
      session.update();
    }
  };
}

function createAuthObject (applicationContext, opts) {
  var sessions,
    cookieAuth,
    auth,
    options = opts || {};

  checkAuthenticationOptions(options);

  sessions = new Sessions(applicationContext, options);
  cookieAuth = new CookieAuthentication(applicationContext, options);
  auth = new Authentication(applicationContext, sessions, cookieAuth);

  return auth;
}

function checkAuthenticationOptions (options) {
  if (options.type !== 'cookie') {
    throw new Error('Currently only the following auth types are supported: cookie');
  }
  if (is.falsy(options.cookieLifetime)) {
    throw new Error('Please provide the cookieLifetime');
  }
  if (is.falsy(options.sessionLifetime)) {
    throw new Error('Please provide the sessionLifetime');
  }
}

defaultsFor.login = {
  usernameField: 'username',
  passwordField: 'password',

  onSuccess: function (req, res) {
    res.json({
      user: req.user.identifier,
      key: req.currentSession._key
    });
  },

  onError: function (req, res) {
    res.status(401);
    res.json({
      error: 'Username or Password was wrong'
    });
  }
};

function createStandardLoginHandler (auth, users, opts) {
  var options = _.defaults(opts || {}, defaultsFor.login);

  return function (req, res) {
    var username = req.body()[options.usernameField],
      password = req.body()[options.passwordField];

    if (users.isValid(username, password)) {
      req.currentSession = auth.beginSession(req, res, username, {});
      req.user = users.get(req.currentSession.identifier);
      options.onSuccess(req, res);
    } else {
      options.onError(req, res);
    }
  };
}

defaultsFor.logout = {
  onSuccess: function (req, res) {
    res.json({
      notice: 'Logged out!'
    });
  },

  onError: function (req, res) {
    res.status(401);
    res.json({
      error: 'No session was found'
    });
  }
};

function createStandardLogoutHandler (auth, opts) {
  var options = _.defaults(opts || {}, defaultsFor.logout);

  return function (req, res) {
    if (is.existy(req.currentSession)) {
      auth.endSession(req, res, req.currentSession._key);
      req.user = null;
      req.currentSession = null;
      options.onSuccess(req, res);
    } else {
      options.onError(req, res);
    }
  };
}

defaultsFor.registration = {
  usernameField: 'username',
  passwordField: 'password',
  acceptedAttributes: [],
  defaultAttributes: {},

  onSuccess: function (req, res) {
    res.json({
      user: req.user
    });
  },

  onError: function (req, res) {
    res.status(401);
    res.json({
      error: 'Registration failed'
    });
  }
};

function createStandardRegistrationHandler (auth, users, opts) {
  var options = _.defaults(opts || {}, defaultsFor.registration);

  return function (req, res) {
    var username = req.body()[options.usernameField],
      password = req.body()[options.passwordField],
      data = _.defaults({}, options.defaultAttributes);

    options.acceptedAttributes.forEach(function (attributeName) {
      var val = req.body()[attributeName];
      if (is.existy(val)) {
        data[attributeName] = val;
      }
    });

    if (users.exists(username)) {
      throw new UserAlreadyExistsError();
    }

    req.user = users.add(username, password, true, data);
    req.currentSession = auth.beginSession(req, res, username, {});
    options.onSuccess(req, res);
  };
}

defaultsFor.changePassword = {
  passwordField: 'password',

  onSuccess: function (req, res) {
    res.json({
      notice: 'Changed password!'
    });
  },

  onError: function (req, res) {
    res.status(401);
    res.json({
      error: 'No session was found'
    });
  }
};

function createStandardChangePasswordHandler (users, opts) {
  var options = _.defaults(opts || {}, defaultsFor.changePassword);

  return function (req, res) {
    var password = req.body()[options.passwordField],
      successfull = false;

    if (is.existy(req.currentSession)) {
      successfull = users.setPassword(req.currentSession.identifier, password);
      if (successfull) {
        options.onSuccess(req, res);
      } else {
        options.onError(req, res);
      }
    } else {
      options.onError(req, res);
    }
  };
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function generateToken () {
  return internal.genRandomAlphaNumbers(32);
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief deep-copies a document
// //////////////////////////////////////////////////////////////////////////////

function cloneDocument (obj) {
  var copy, a;

  if (obj === null || typeof obj !== 'object') {
    return obj;
  }

  if (Array.isArray(obj)) {
    copy = [];
    obj.forEach(function (i) {
      copy.push(cloneDocument(i));
    });
  } else if (obj instanceof Object) {
    copy = {};
    for (a in obj) {
      if (obj.hasOwnProperty(a)) {
        copy[a] = cloneDocument(obj[a]);
      }
    }
  }

  return copy;
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief checks whether the plain text password matches the encoded one
// //////////////////////////////////////////////////////////////////////////////

function checkPassword (plain, encoded) {
  var salted = encoded.substr(3, 8) + plain,
    hex = crypto.sha256(salted);

  return (encoded.substr(12) === hex);
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief encodes a password
// //////////////////////////////////////////////////////////////////////////////

function encodePassword (password) {
  var salt,
    encoded,
    random;

  random = crypto.rand();
  if (random === undefined) {
    random = 'time:' + internal.time();
  } else {
    random = 'random:' + random;
  }

  salt = crypto.sha256(random);
  salt = salt.substr(0, 8);

  encoded = '$1$' + salt + '$' + crypto.sha256(salt + password);

  return encoded;
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function Users (applicationContext, options) {
  this._options = options || {};
  this._collection = null;

  if (this._options.hasOwnProperty('collectionName')) {
    this._collectionName = this._options.collectionName;
  } else {
    this._collectionName = applicationContext.collectionName('users');
  }
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief returns the collection
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.storage = function () {
  if (this._collection === null) {
    this._collection = db._collection(this._collectionName);

    if (!this._collection) {
      throw new Error('users collection not found');
    }
  }

  return this._collection;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief validate a user identifier
// //////////////////////////////////////////////////////////////////////////////

Users.prototype._validateIdentifier = function (identifier, allowObject) {
  if (allowObject) {
    if (typeof identifier === 'object' && identifier.hasOwnProperty('identifier')) {
      identifier = identifier.identifier;
    }
  }

  if (typeof identifier !== 'string') {
    throw new TypeError("invalid type for 'identifier'");
  }

  if (identifier.length === 0) {
    throw new Error('invalid user identifier');
  }

  return identifier;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief sets up the users collection
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.setup = function (options) {
  var journalSize,
    createOptions;

  if (typeof options === 'object' && options.hasOwnProperty('journalSize')) {
    journalSize = options.journalSize;
  }

  createOptions = {
    journalSize: journalSize || 2 * 1024 * 1024
  };

  if (!db._collection(this._collectionName)) {
    db._create(this._collectionName, createOptions);
  }

  this.storage().ensureIndex({ type: 'hash', fields: [ 'identifier' ], sparse: true });
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief tears down the users collection
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.teardown = function () {
  var c = db._collection(this._collectionName);

  if (c) {
    c.drop();
  }
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief flushes all users
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.flush = function () {
  this.storage().truncate();
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief add a user
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.add = function (identifier, password, active, data) {
  var c = this.storage(),
    user;

  identifier = this._validateIdentifier(identifier, false);

  if (typeof password !== 'string') {
    throw new TypeError("invalid type for 'password'");
  }

  if (active !== undefined && typeof active !== 'boolean') {
    throw new TypeError("invalid type for 'active'");
  }
  if (active === undefined) {
    active = true;
  }

  user = {
    identifier: identifier,
    password: encodePassword(password),
    active: active,
    data: data || {}
  };

  db._executeTransaction({
    collections: {
      write: c.name()
    },
    action: function (params) {
      var c = db._collection(params.cn),
        u = c.firstExample({ identifier: params.user.identifier });

      if (u === null) {
        c.save(params.user);
      } else {
        c.replace(u._key, params.user);
      }
    },
    params: {
      cn: c.name(),
      user: user
    }
  });

  delete user.password;

  return user;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief update a user
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.updateData = function (identifier, data) {
  var c = this.storage();

  identifier = this._validateIdentifier(identifier, true);

  db._executeTransaction({
    collections: {
      write: c.name()
    },
    action: function (params) {
      var c = db._collection(params.cn),
        u = c.firstExample({ identifier: params.identifier });

      if (u === null) {
        throw new Error('user not found');
      }
      c.update(u._key, params.data, true, false);
    },
    params: {
      cn: c.name(),
      identifier: identifier,
      data: data || {}
    }
  });

  return true;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief set activity flag
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.setActive = function (identifier, active) {
  var c = this.storage(),
    user,
    doc;

  identifier = this._validateIdentifier(identifier, true);

  user = c.firstExample({ identifier: identifier });

  if (user === null) {
    return false;
  }

  // must clone because shaped json cannot be modified
  doc = cloneDocument(user);
  doc.active = active;
  c.update(doc._key, doc, true, false);

  return true;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief set password
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.setPassword = function (identifier, password) {
  var c = this.storage(),
    user,
    doc;

  identifier = this._validateIdentifier(identifier, true);

  if (typeof password !== 'string') {
    throw new TypeError("invalid type for 'password'");
  }

  user = c.firstExample({ identifier: identifier });

  if (user === null) {
    return false;
  }

  doc = cloneDocument(user);
  doc.password = encodePassword(password);
  c.update(doc._key, doc, true, false);

  return true;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief remove a user
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.remove = function (identifier) {
  var c = this.storage(),
    user;

  identifier = this._validateIdentifier(identifier, true);

  user = c.firstExample({ identifier: identifier });

  if (user === null) {
    return false;
  }

  try {
    c.remove(user._key);
  } catch (err) {}

  return true;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief returns a user
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.get = function (identifier) {
  var c = this.storage(),
    user;

  identifier = this._validateIdentifier(identifier, true);

  user = c.firstExample({ identifier: identifier });

  if (user === null) {
    throw new Error('user not found');
  }

  delete user.password;

  return user;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief checks if a user exists
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.exists = function (identifier) {
  var c = this.storage(),
    user;

  identifier = this._validateIdentifier(identifier, true);
  user = c.firstExample({ identifier: identifier });
  return (user !== null);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief check whether a user is valid
// //////////////////////////////////////////////////////////////////////////////

Users.prototype.isValid = function (identifier, password) {
  var c = this.storage(),
    user;

  identifier = this._validateIdentifier(identifier, false);

  user = c.firstExample({ identifier: identifier });

  if (user === null) {
    return false;
  }

  if (!user.active) {
    return false;
  }

  if (!checkPassword(password, user.password)) {
    return false;
  }

  delete user.password;

  return user;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function Sessions (applicationContext, options) {
  this._applicationContext = applicationContext;
  this._options = options || {};
  this._collection = null;

  if (!this._options.hasOwnProperty('minUpdateResoultion')) {
    this._options.minUpdateResolution = 10;
  }

  if (this._options.hasOwnProperty('collectionName')) {
    this._collectionName = this._options.collectionName;
  } else {
    this._collectionName = applicationContext.collectionName('sessions');
  }
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief create a session object from a document
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype._toObject = function (session) {
  var that = this;

  return {
    _changed: false,
    _key: session._key,
    identifier: session.identifier,
    expires: session.expires,
    data: session.data,

    set: function (key, value) {
      this.data[key] = value;
      this._changed = true;
    },

    get: function (key) {
      return this.data[key];
    },

    update: function () {
      var oldExpires, newExpires;

      if (!this._changed) {
        oldExpires = this.expires;
        newExpires = internal.time() + that._options.sessionLifetime;

        if (newExpires - oldExpires > that._options.minUpdateResolution) {
          this.expires = newExpires;
          this._changed = true;
        }
      }

      if (this._changed) {
        that.update(this._key, this.data);
        this._changed = false;
      }
    }
  };
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief sets up the sessions
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.setup = function (options) {
  var journalSize,
    createOptions;

  if (typeof options === 'object' && options.hasOwnProperty('journalSize')) {
    journalSize = options.journalSize;
  }

  createOptions = {
    journalSize: journalSize || 4 * 1024 * 1024
  };

  if (!db._collection(this._collectionName)) {
    db._create(this._collectionName, createOptions);
  }

  this.storage().ensureIndex({ type: 'hash', fields: ['identifier']});
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief tears down the sessions
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.teardown = function () {
  var c = db._collection(this._collectionName);

  if (c) {
    c.drop();
  }
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief return the collection
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.storage = function () {
  if (this._collection === null) {
    this._collection = db._collection(this._collectionName);

    if (!this._collection) {
      throw new Error('sessions collection not found');
    }
  }

  return this._collection;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief generate a new session
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.generate = function (identifier, data) {
  var storage, token, session;

  if (typeof identifier !== 'string' || identifier.length === 0) {
    throw new TypeError("invalid type for 'identifier'");
  }

  if (!this._options.hasOwnProperty('sessionLifetime')) {
    throw new Error("no value specified for 'sessionLifetime'");
  }

  storage = this.storage();

  if (!this._options.allowMultiple) {
    // remove previous existing sessions
    storage.byExample({ identifier: identifier }).toArray().forEach(function (s) {
      storage.remove(s);
    });
  }

  while (true) {
    token = generateToken();
    session = {
      _key: token,
      expires: internal.time() + this._options.sessionLifetime,
      identifier: identifier,
      data: data || {}
    };

    try {
      storage.save(session);
      return this._toObject(session);
    } catch (err) {
      // we might have generated the same key again
      if (err.hasOwnProperty('errorNum') &&
        err.errorNum === internal.errors.ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED.code) {
        // duplicate key, try again
        continue;
      }

      throw err;
    }
  }
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief update a session
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.update = function (token, data) {
  this.storage().update(token, {
    expires: internal.time() + this._options.sessionLifetime,
    data: data
  }, true, false);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief terminate a session
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.terminate = function (token) {
  try {
    this.storage().remove(token);
  } catch (err) {
    // some error, e.g. document not found. we don't care
  }
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief get an existing session
// //////////////////////////////////////////////////////////////////////////////

Sessions.prototype.get = function (token) {
  var storage = this.storage(),
    session;

  try {
    session = storage.document(token);

    if (session.expires >= internal.time()) {
      // session still valid

      return {
        errorNum: internal.errors.ERROR_NO_ERROR.code,
        session: this._toObject(session)
      };
    }

    // expired
    return {
      errorNum: internal.errors.ERROR_SESSION_EXPIRED.code
    };
  } catch (err) {
    // document not found etc.
  }

  return {
    errorNum: internal.errors.ERROR_SESSION_UNKNOWN.code
  };
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function CookieAuthentication (applicationContext, options) {
  options = options || {};

  this._applicationContext = applicationContext;

  this._options = {
    name: options.name || this._applicationContext.name + '-session',
    cookieLifetime: options.cookieLifetime || 3600,
    path: options.path || '/',
    domain: options.domain || undefined,
    secure: options.secure || false,
    httpOnly: options.httpOnly || false
  };

  this._collectionName = applicationContext.collectionName('sessions');
  this._collection = null;
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief get a cookie from the request
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.getTokenFromRequest = function (req) {
  if (!req.hasOwnProperty('cookies')) {
    return null;
  }

  if (!req.cookies.hasOwnProperty(this._options.name)) {
    return null;
  }

  return req.cookies[this._options.name];
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief register a cookie in the request
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.setCookie = function (res, value) {
  var name = this._options.name,
    cookie,
    i,
    n;

  cookie = {
    name: name,
    value: value,
    lifeTime: (value === null || value === '') ? 0 : this._options.cookieLifetime,
    path: this._options.path,
    secure: this._options.secure,
    domain: this._options.domain,
    httpOnly: this._options.httpOnly
  };

  if (!res.hasOwnProperty('cookies')) {
    res.cookies = [];
  }

  if (!Array.isArray(res.cookies)) {
    res.cookies = [ res.cookies ];
  }

  n = res.cookies.length;
  for (i = 0; i < n; ++i) {
    if (res.cookies[i].name === name) {
      // found existing cookie. overwrite it
      res.cookies[i] = cookie;
      return;
    }
  }

  res.cookies.push(cookie);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief check whether the request contains authentication data
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.getAuthenticationData = function (req) {
  var token = this.getTokenFromRequest(req);

  if (token === null) {
    return null;
  }

  return {
    token: token
  };
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief generate authentication data
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.beginSession = function (req, res, token) {
  this.setCookie(res, token);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief delete authentication data
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.endSession = function (req, res) {
  this.setCookie(res, '');
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief update authentication data
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.updateSession = function (req, res, session) {
  // update the cookie (expire date)
  this.setCookie(res, session._key);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief check whether the authentication handler is responsible
// //////////////////////////////////////////////////////////////////////////////

CookieAuthentication.prototype.isResponsible = function () {
  return true;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function Authentication (applicationContext, sessions, authenticators) {
  this._applicationContext = applicationContext;
  this._sessions = sessions;

  if (!Array.isArray(authenticators)) {
    authenticators = [ authenticators ];
  }

  this._authenticators = authenticators;
}

// //////////////////////////////////////////////////////////////////////////////
// / @brief runs the authentication
// //////////////////////////////////////////////////////////////////////////////

Authentication.prototype.authenticate = function (req) {
  var i,
    n = this._authenticators.length,
    authenticator,
    data,
    session;

  for (i = 0; i < n; ++i) {
    authenticator = this._authenticators[i];

    data = authenticator.getAuthenticationData(req);

    if (data !== null) {
      session = this._sessions.get(data.token);

      if (session) {
        return session;
      }
    }
  }

  return {
    errorNum: internal.errors.ERROR_SESSION_UNKNOWN.code
  };
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief begin a session
// //////////////////////////////////////////////////////////////////////////////

Authentication.prototype.beginSession = function (req, res, identifier, data) {
  var session = this._sessions.generate(identifier, data),
    i,
    n = this._authenticators.length,
    authenticator;

  for (i = 0; i < n; ++i) {
    authenticator = this._authenticators[i];

    if (authenticator.isResponsible(req) &&
      authenticator.beginSession) {
      authenticator.beginSession(req, res, session._key, identifier, data);
    }
  }

  return session;
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief terminate a session
// //////////////////////////////////////////////////////////////////////////////

Authentication.prototype.endSession = function (req, res, token) {
  var i,
    n = this._authenticators.length,
    authenticator;

  for (i = 0; i < n; ++i) {
    authenticator = this._authenticators[i];

    if (authenticator.isResponsible(req) &&
      authenticator.endSession) {
      authenticator.endSession(req, res);
    }
  }

  this._sessions.terminate(token);
};

// //////////////////////////////////////////////////////////////////////////////
// / @brief update a session
// //////////////////////////////////////////////////////////////////////////////

Authentication.prototype.updateSession = function (req, res, session) {
  var i,
    n = this._authenticators.length,
    authenticator;

  for (i = 0; i < n; ++i) {
    authenticator = this._authenticators[i];

    if (authenticator.isResponsible(req) &&
      authenticator.updateSession) {
      authenticator.updateSession(req, res, session);
    }
  }

  session.update();
};

// http://stackoverflow.com/questions/783818/how-do-i-create-a-custom-error-in-javascript

// //////////////////////////////////////////////////////////////////////////////
// / @brief constructor
// //////////////////////////////////////////////////////////////////////////////

function UserAlreadyExistsError (message) {
  this.message = message || 'User already exists';
  this.statusCode = 400;
}

UserAlreadyExistsError.prototype = new Error();

function UnauthorizedError (message) {
  this.message = message || 'Unauthorized';
  this.statusCode = 401;
}

UnauthorizedError.prototype = new Error();

exports.Users = Users;
exports.Sessions = Sessions;
exports.CookieAuthentication = CookieAuthentication;
exports.Authentication = Authentication;
exports.UnauthorizedError = UnauthorizedError;
exports.UserAlreadyExistsError = UserAlreadyExistsError;
exports.createStandardLoginHandler = createStandardLoginHandler;
exports.createStandardLogoutHandler = createStandardLogoutHandler;
exports.createStandardRegistrationHandler = createStandardRegistrationHandler;
exports.createStandardChangePasswordHandler = createStandardChangePasswordHandler;
exports.createAuthenticationMiddleware = createAuthenticationMiddleware;
exports.createSessionUpdateMiddleware = createSessionUpdateMiddleware;
exports.createAuthObject = createAuthObject;