'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});

var _config = require('config');

var _config2 = _interopRequireDefault(_config);

var _debug = require('debug');

var _debug2 = _interopRequireDefault(_debug);

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _passport = require('passport');

var _passport2 = _interopRequireDefault(_passport);

var _phpass = require('phpass');

var _phpass2 = _interopRequireDefault(_phpass);

var _passportFacebook = require('passport-facebook');

var _passportFacebook2 = _interopRequireDefault(_passportFacebook);

var _passportGoogleOauth = require('passport-google-oauth');

var _passportGoogleOauth2 = _interopRequireDefault(_passportGoogleOauth);

var _passportLocal = require('passport-local');

var _passportLocal2 = _interopRequireDefault(_passportLocal);

var _user = require('../modules/user');

var _user2 = _interopRequireDefault(_user);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var debug = (0, _debug2.default)('touchto:authentication');

var FacebookStrategy = _passportFacebook2.default.Strategy;
var GoogleStrategy = _passportGoogleOauth2.default.OAuth2Strategy;
var LocalStrategy = _passportLocal2.default.Strategy;

var OAuthRead = void 0;
var createPasswordHash = void 0;

// General Authentication Config

if (_config2.default.has('auth.enabled') && _config2.default.get('auth.enabled')) {
    _passport2.default.serializeUser = function (user, req, done) {
        return done('null', user.id);
    };
    _passport2.default.deserializeUser = function (id, req, done) {
        _user2.default.Model.findById(id).exec().then(function (user) {
            return done(null, user);
        }).catch(function (err) {
            console.error(err.stack);
            return done(err);
        });
    };
    var passwordhash = new _phpass2.default.PasswordHash();
    createPasswordHash = function createPasswordHash(password) {
        return passwordhash.hashPassword(password);
    };
    OAuthRead = function OAuthRead(token, tokenSecret, profile, done) {
        var username = profile.name.givenName.trim()[0];
        username += profile.name.familyName.trim();
        username = username.toLowerCase().trim();

        var provider = {
            id: profile.id,
            name: profile.provider,
            profile: profile,
            access_token: token
        };
        var doc = {
            username: username,
            name: profile.displayName,
            first_name: profile.name.givenName,
            last_name: profile.name.familyName,
            mail: profile.emails[0].value.toLowerCase().trim()
        };

        doc[profile.provider] = provider;
        if (profile.photos.length > 0) doc.photo = profile.photos[0].value;

        var providercriteria = {};
        providercriteria[profile.provider + '.id'] = profile.id;
        providercriteria[profile.provider + '.name'] = profile.provider;

        var criteria = {};
        criteria.$or = [providercriteria, {
            mail: profile.emails[0].value.toLowerCase().trim()
        }];

        _user2.default.Model.findAndUpdate(criteria, doc).then(function (user) {
            if (user === null) {
                done(null, false);
            } else {
                done(null, user);
            }
        }).catch(function () {
            _user2.default.Model.createFromOAuth(doc).then(function (user) {
                if (user === null) {
                    done(null, false);
                } else {
                    done(null, user);
                }
            }).catch(function () {
                done(null, false);
            });
        });
    };
}

/** Auth Methods **/

/** *** GOOGLE *** **/

if (_config2.default.has('auth.google.enabled') && _config2.default.get('auth.google.enabled') === true) {
    var GOOGLE_CONSUMER_ID = _config2.default.get('auth.google.GOOGLE_CONUSMER_ID');
    var GOOGLE_CONSUMER_SECRET = _config2.default.get('auth.google.GOOGLE_CONSUMER_SECRET');
    var GOOGLE_RETURN_URL = _config2.default.get('auth.google.GOOGLE_RETURN_URL');

    _passport2.default.use(new GoogleStrategy({
        clientID: GOOGLE_CONSUMER_ID,
        clientSecret: GOOGLE_CONSUMER_SECRET,
        callbackURL: GOOGLE_RETURN_URL
    }, OAuthRead));
}

/** *** FACEBOOK *** **/

if (_config2.default.has('auth.facebook.enabled') && _config2.default.get('auth.facebook.enabled') === true) {
    var FACEBOOK_APP_ID = _config2.default.get('auth.facebook.FACEBOOK_APP_ID');
    var FACEBOOK_APP_SECRET = _config2.default.get('auth.facebook.FACEBOOK_APP_SECRET');
    var FACEBOOK_APP_CALLBACK = _config2.default.get('auth.facebook.FACEBOOK_APP_CALLBACK');
    var FACEBOOK_APP_SIGNUP_CALLBACK = _config2.default.get('auth.facebook.FACEBOOK_APP_SIGNUP_CALLBACK');

    _passport2.default.use(new FacebookStrategy({
        clientID: FACEBOOK_APP_ID,
        clientSecret: FACEBOOK_APP_SECRET,
        callbackURL: FACEBOOK_APP_CALLBACK,
        profileFields: ['id', 'displayName', 'email', 'first_name', 'last_name', 'picture']
    }, OAuthRead));

    _passport2.default.use('facebookregister', new FacebookStrategy({
        clientID: FACEBOOK_APP_ID,
        clientSecret: FACEBOOK_APP_SECRET,
        callbackURL: FACEBOOK_APP_SIGNUP_CALLBACK,
        profileFields: ['id', 'displayName', 'email', 'first_name', 'last_name', 'picture']
    }, OAuthRead));
}

/** *** LOCAL *** **/

if (_config2.default.has('auth.local.enabled') && _config2.default.get('auth.local.enabled') === true) {
    _passport2.default.use(new LocalStrategy(function (username, password, done) {
        var criteria = {
            mail: username
        };
        _user2.default.Model.findOne(criteria).select('+passwd').exec().then(function (user) {
            // No user came up
            if (user === null) done(null, false, { message: 'Invalid credentials' });

            // Check for successful auth
            if (user.checkhash(password)) {
                user.set('last_login', Date.now());
                user.save(function (err) {
                    if (err) {
                        console.error(err.stack);
                        done(err);
                    } else {
                        _user2.default.Model.findById(user.get('_id')).exec().then(function (updUser) {
                            done(null, updUser);
                        }).catch(function (error) {
                            done(error);
                        });
                    }
                });
            } else {
                done(null, false, { message: 'Invalid credentials' });
            }
        }).catch(function (err) {
            console.error(err.stack);
            done(null, false, { message: 'Invalid credentials' });
        });
    }));
}

var isAuthenticated = function isAuthenticated(req, res, next) {
    if (req.isAuthenticated()) {
        return next();
    } else if (req.xhr) {
        return res.status(401).end();
    }
    var error = new Error();
    error.status = 401;
    throw error;
};

exports.default = {
    isAuthed: isAuthenticated,
    hasher: _phpass2.default.PasswordHash,
    createPasswordHash: createPasswordHash // WONT NECESSARILY HAVE A VALUE
};
module.exports = exports['default'];