/**
 * 登录
 * @author: Bi Kai<kai.bi@yoho.cn>
 * @date: 2016/05/09
 */
'use strict';

const _ = require('lodash');
const Fn = require('lodash/fp');
const Promise = require('bluebird');
const qs = require('querystring');

const passport = require('passport');
const uuid = require('uuid');
const cookie = global.yoho.cookie;
const helpers = global.yoho.helpers;
const log = global.yoho.logger;
const config = global.yoho.config;
const cache = global.yoho.cache;
const LoginService = require('../models/login-service');
const referWhiteListService = require('../models/refer-service');
const PassportHelper = require('../models/passport-helper');
const simpleHeaderModel = require('../../../doraemon/models/simple-header');
const loginPage = `${config.siteUrl}/signin.html`;
const bind3party = require('../../home/controllers/3party-bind');

const SIGNIN_LEFT_BANNER_CODE = 'db350894e01e90eac55cd3a13ad77331';

// 第三方登录回调
function doPassportCallback(req, res, user) {
    let shoppingKey = cookie.getShoppingKey(req);
    let refer = cookie.getRefer(req, config.siteUrl);

    // 第三方登录不能正确跳转：把需要跳转的链接拿出来
    // 形如：http://www.yohobuy.com/signin.html?refer=http://item.yohobuy.com/
    //       product/pro_550930_682618/CLING6970071800516ZhiNengXinLvYunDongShouHuanVOC.html?from=search-s-CLING_1_8'
    if (_.includes(refer, 'refer=')) {
        refer = refer.split('refer=')[1];
    }

    if (referWhiteListService(refer)) {
        if (/sign|login|reg|passport/.test(refer)) {
            refer = config.siteUrl;
        }
    } else {
        refer = config.siteUrl;
    }

    if (user.openId) {
        user.nickname = _.trim(user.nickname);

        if (user.sourceType === 'wechat') {
            // PC 的微信登录使用unionId
            user.openId = user.unionId;
        }

        return req.ctx(LoginService).signinByOpenID(user.nickname, user.openId, user.sourceType, shoppingKey)
            .then((result) => {
                if (result.code !== 200) {
                    return res.redirect(config.siteUrl);
                }
                if (result.data['is_bind'] && result.data['is_bind'] === 'N') { //eslint-disable-line
                    return helpers.urlFormat('/passport/thirdlogin/index', {
                        openId: user.unionId || user.openId,
                        sourceType: user.sourceType,
                        refer: refer
                    });
                } else if (result.data['is_bind'] === 'Y' && result.data.uid) {//eslint-disable-line

                    return req.ctx(LoginService).syncUserSession(result.data, req, res).then(() => {
                        return refer;
                    });
                }
            })
            .then((redirectTo) => {
                return res.redirect(redirectTo);
            });
    } else {
        return Promise.resolve(res.redirect(loginPage));
    }
}

const common = {
    beforeLogin: (req, res, next) => {
        let refer = req.query.refer || req.get('Referer');

        refer && res.cookie('refer', encodeURI(refer), {
            domain: config.cookieDomain
        });
        next();
    },
    needCaptcha: (req, res, next) => {
        let account = _.trim(req.query.account);
        let result = {code: 400, message: '', data: ''};

        if (account) {
            let errorLoginKey = 'account_errorlogin_' + account;

            cache.get(errorLoginKey).then(errloginTimes => {
                errloginTimes = parseInt(errloginTimes, 0) || 0;
                if (!isNaN(errloginTimes) && errloginTimes >= 1) {
                    result.data = {needCaptcha: true};
                }
                return res.json(result);
            }).catch(next);
        } else {
            return res.json(result);
        }
    }
};

const local = {
    loginPage: (req, res) => {
        // 清除cookie
        res.clearCookie('_UID', {
            domain: config.cookieDomain
        });
        res.clearCookie('_TOKEN', {
            domain: config.cookieDomain
        });

        res.clearCookie('_SESSION_KEY', {
            domain: config.cookieDomain
        });

        let bindMobile = _.trim(req.query.bindMobile || '');
        let bindArea = '+' + _.trim(req.query.bindArea || '86');
        let areaArr = PassportHelper.getCountry();
        let areaName = '';

        if (bindArea) {
            let area = areaArr.find((a) => {
                return a.areaCode === bindArea;
            });

            areaName = area ? area.name : '';
        }

        let refer = req.query.refer || req.cookies.refer || req.get('Referer');

        PassportHelper.getLeftBannerAsync(SIGNIN_LEFT_BANNER_CODE).then(cover => {
            res.render('login', {
                loginPage: true,
                simpleHeader: simpleHeaderModel.setSimpleHeaderData(),
                passport: {
                    coverHref: cover.url,
                    coverImg: cover.img,
                    countryCode: bindArea,
                    countryName: areaName,
                    countryList: areaArr,
                    forgetPwd: helpers.urlFormat('/passport/back/index'),
                    fastReg: helpers.urlFormat('/reg.html', {refer: refer}),
                    weixinLogin: helpers.urlFormat('/passport/autosign/wechat'),
                    qqLogin: helpers.urlFormat('/passport/autosign/qq'),
                    weiboLogin: helpers.urlFormat('/passport/autosign/sina'),
                    alipayLogin: helpers.urlFormat('/passport/autosign/alipay'),
                    doubanLogin: helpers.urlFormat('/passport/autosign/douban'),
                    renrenLogin: helpers.urlFormat('/passport/autosign/renren'),
                    bindMobile: bindMobile
                },
                module: 'passport',
                page: 'login',
                title: '用户登录'
            });
        });
    },
    login: (req, res, next) => {
        passport.authenticate('local', (err, user) => {
            if (err) {
                return res.json({
                    code: 400,
                    message: err.message,
                    data: {
                        needCaptcha: err.needCaptcha,
                        type: err.type
                    }
                });
            }

            if (_.get(req.body, 'isRemember', 'false') === 'true') {
                req.ctx(LoginService).rememberAccount({
                    area: req.body.areaCode || '86',
                    account: req.body.account,
                    password: req.body.password
                }, req, res);
            }

            let refer = (function() {
                let referUrl = _.get(req.cookies, 'refer', '');

                if (referWhiteListService(referUrl)) {
                    if (/sign|login|reg|passport/.test(referUrl)) {
                        return `${config.siteUrl}/home`;
                    } else {
                        return decodeURIComponent(req.cookies.refer);
                    }
                } else {
                    return `${config.siteUrl}/home`;
                }
            }());

            req.ctx(LoginService).syncUserSession(user, req, res).then((noCertTip) => {
                // 弱密码
                if (user.code === 510) {
                    refer = `${config.siteUrl}/passport/back/weak?refer=${refer}`;
                } else if (noCertTip === true) {
                    refer = `${config.siteUrl}/passport/cert/tip?refer=${refer}`;
                }

                return res.json({
                    code: 200,
                    data: {
                        session: refer,
                        href: refer
                    }
                });
            }).catch(next);
        })(req, res, next);
    },
    logout: (req, res) => {
        req.session.reset();

        res.clearCookie('_UID', {
            domain: config.cookieDomain
        });

        res.clearCookie('_TOKEN', {
            domain: config.cookieDomain
        });

        res.clearCookie('_SPK', {
            domain: config.cookieDomain
        });

        res.clearCookie('_g', {
            domain: config.cookieDomain
        });

        res.clearCookie('isRemember', {
            domain: config.cookieDomain
        });

        res.clearCookie('remem', {
            domain: config.cookieDomain
        });

        res.clearCookie('_SESSION_KEY', {
            domain: config.cookieDomain
        });

        res.clearCookie('isStudent', {
            domain: config.cookieDomain
        });

        let refer = req.get('Referer') || config.siteUrl;

        return res.redirect(refer);
    },
    sms: {
        send: (req, res, next) => {
            let area = req.body.area || '86';
            let mobile = req.body.mobile || '';

            if (!mobile) {
                return res.json({
                    code: 400,
                    message: '格式错误'
                });
            }

            req.ctx(LoginService).sendPasswordBySMS(area, mobile).then((result) => {
                return res.json(result);
            }).then(() => {
                req.session.captcha = 'yoho4946abcdef#$%&!@';
            }).catch(next);
        },
        auth: (req, res, next) => {
            let area = req.body.area || '86';
            let mobile = req.body.mobile || '';
            let code = req.body.code || '';

            if (!area || !mobile || !code) {
                return res.json({
                    code: 400,
                    message: '格式错误'
                });
            }

            req.ctx(LoginService).verifyPasswordBySMS(area, mobile, code).then((result) => {
                if (_.get(result, 'code', 200) !== 200) {
                    return res.json(result);
                }

                let pass = _.get(result, 'data.is_pass', 'N');

                if (pass === 'Y') {
                    return res.json({
                        token: _.get(result, 'data.code', ''),
                        code: 200
                    });
                } else {
                    return res.json({
                        code: 400
                    });
                }
            }).catch(next);
        },
        checkUser: (req, res, next) => {
            let area = req.body.area || '86';
            let mobile = req.body.mobile || '';

            if (!area || !mobile) {
                return res.json({
                    code: 400,
                    message: '格式错误'
                });
            }

            req.ctx(LoginService).checkUserExitBySMS(area, mobile).then((result) => {
                if (_.get(result, 'code') !== 200) {
                    return Promise.reject('check user by sms error');
                }

                if (_.get(result, 'data.is_register', 'N') === 'Y') {
                    return next();
                } else {
                    return res.json({
                        code: 402,
                        message: '手机号尚未注册，请核对后重新输入或<a href="/reg.html?' +
                        qs.stringify({mobile: mobile, area: (area ? '+' + area : '+86') || '+86'}) +
                        '" >注册</a>'
                    });
                }
            }).catch(next);
        }
    },
    qrcode: {
        refresh: (req, res, next) => {
            req.ctx(LoginService).fetchByQrCode().then((result) => {
                if (result.code === 200) {
                    return res.json({
                        code: 200,
                        data: {
                            qrcode: `http://m.yohobuy.com/signin.html?qr=${result.data.code}`
                        }
                    });
                } else {
                    return res.json({
                        code: 400,
                        message: '生成二维码错误'
                    });
                }
            }).catch(next);
        },
        check: (req, res, next) => {
            let qrcode = req.body.qrcode || '';

            if (!qrcode) {
                return res.json({
                    code: 400,
                    message: '输入错误，请重新刷新二维码'
                });
            }

            if (!_.includes(qrcode, '=')) {
                return res.json({
                    code: 400,
                    message: '输入错误，请重新刷新二维码'
                });
            }

            let token = decodeURIComponent(qrcode.substring(qrcode.indexOf('=') + 1));

            req.ctx(LoginService).checkByQrCode(token).then((result) => {
                if (_.isEmpty(result)) {
                    return res.json({
                        code: 400,
                        message: '输入错误，请重新刷新二维码'
                    });
                }

                if (result.code === 402) {
                    return res.json({
                        code: 402,
                        message: '二维码为空'
                    });
                }

                if (result.code === 403) {
                    return res.json({
                        code: 403,
                        message: '二维码未失效，不可登录'
                    });
                }

                if (result.code === 404) {
                    return res.json({
                        code: 404,
                        message: '二维码失效，需要重新刷新'
                    });
                }

                if (result.code === 200) {
                    return res.json({
                        code: 200,
                        message: '可以登录'
                    });
                }

                return res.json({
                    code: 400,
                    message: '服务器问题'
                });
            }).catch(next);
        }
    }
};

const wechat = {
    login: (req, res, next) => {
        req.session.authState = uuid.v4();
        return passport.authenticate('wechat', {
            state: req.session.authState
        })(req, res, next);
    },
    callback: (req, res, next) => {
        if (req.session && req.session.authState && req.session.authState === req.query.state) {
            passport.authenticate('wechat', (err, user) => {
                if (err) {
                    log.error(`wechat authenticate error : ${JSON.stringify(err)}`);
                    return res.redirect(loginPage);
                } else {
                    doPassportCallback(req, res, {
                        openId: user._json.openid,
                        unionId: user._json.unionid || user.id,
                        nickname: user._json.nickname || user.displayName,
                        sourceType: 'wechat',
                        rawUser: user
                    }).catch(next);
                }
            })(req, res, next);
        } else {
            return next(new Error('Wechat Auth State Mismatch'));
        }
    }
};

const sina = {
    login: (req, res, next) => {
        req.session.authState = uuid.v4();
        return passport.authenticate('sina', {
            state: req.session.authState
        })(req, res, next);
    },
    callback: (req, res, next) => {
        if (req.session && req.session.authState && req.session.authState === req.query.state) {
            passport.authenticate('sina', (err, user) => {
                if (err) {
                    log.error(`sina authenticate error : ${JSON.stringify(err)}`);
                    return res.redirect(loginPage);
                }
                let nickname = _.trim(user.screen_name);
                let openId = user.id;

                doPassportCallback(req, res, {
                    openId: openId,
                    nickname: nickname,
                    sourceType: 'sina'
                }).catch(next);
            })(req, res, next);
        } else {
            return next(new Error('Sina Auth State Mismatch'));
        }
    }
};

const qq = {
    login: (req, res, next) => {
        let type = req.query.type || 'yohobuy';
        let authState = req.session.authState = (req.query.state || uuid.v4()) + '::' + type;

        return passport.authenticate('qq', {
            state: authState
        })(req, res, next);
    },
    callback: (req, res, next) => {
        let auth = Fn.compose(Fn.head, Fn.split('::'))(req.query.state);
        let type = Fn.compose(Fn.nth(1), Fn.split('::'))(req.query.state);

        if (req.session && req.session.authState && req.session.authState === req.query.state) {
            passport.authenticate('qq', (err, user) => {
                if (err) {
                    log.error(`qq authenticate error : ${JSON.stringify(err)}`);
                    return res.redirect(loginPage);
                }
                let nickname = _.trim(user.nickname);
                let openId = user.id;

                if (type === 'yohoblk') {
                    return res.redirect('//www.yohoblk.com/passport/login/qq/callback?' +
                        qs.stringify({openid: openId, nickname: nickname, state: auth}));
                } else {
                    doPassportCallback(req, res, {
                        openId: openId,
                        nickname: nickname,
                        sourceType: 'qq'
                    }).catch(next);
                }
            })(req, res, next);
        } else {
            return next(new Error('QQ Auth State Mismatch'));
        }
    }
};

const alipay = {
    login: (req, res, next) => {
        return passport.authenticate('alipay')(req, res, next);
    },
    callback: (req, res, next) => {
        passport.authenticate('alipay', (err, user) => {
            if (err) {
                log.error(`alipay authenticate error : ${JSON.stringify(err)}`);
                return res.redirect(loginPage);
            }
            let nickname = _.trim(user.realName);
            let openId = user.userId;

            doPassportCallback(req, res, {
                openId: openId,
                nickname: nickname,
                sourceType: 'alipay'
            }).catch(next);
        })(req, res, next);
    }
};

const douban = {
    login: (req, res, next) => {
        req.session.authState = uuid.v4();
        return passport.authenticate('douban', {
            state: req.session.authState
        })(req, res, next);
    },
    callback: (req, res, next) => {
        passport.authenticate('douban', (err, user) => {

            let callbackType = Fn.compose(Fn.nth(1), Fn.split('::'))(req.query.state);

            if (callbackType === 'bind') {   // 个人中心，第三方账号绑定

                if (err) {
                    log.error(`douban authenticate error : ${JSON.stringify(err)}`);
                    return bind3party.bindFail(res, '豆瓣登录失败，请稍后再试！', 'douban');
                }

                let nickname = _.trim(user.displayName);
                let openId = user.id;

                return bind3party.bind3party(req, res, {
                    openId: openId,
                    nickname: nickname,
                    sourceType: 'douban'
                });
            }

            if (err) {
                log.error(`douban authenticate error : ${JSON.stringify(err)}`);
                return res.redirect(loginPage);
            }

            let nickname = _.trim(user.displayName);
            let openId = user.id;

            doPassportCallback(req, res, {
                openId: openId,
                nickname: nickname,
                sourceType: 'douban'
            }).catch(next);
        })(req, res, next);
    }
};

const renren = {
    login: (req, res, next) => {
        req.session.authState = uuid.v4();
        return passport.authenticate('renren', {
            state: req.session.authState
        })(req, res, next);
    },
    callback: (req, res, next) => {
        passport.authenticate('renren', (err, user) => {
            if (err) {
                log.error(`renren authenticate error : ${JSON.stringify(err)}`);
                return res.redirect(loginPage);
            }

            let nickname = _.trim(user.displayName);
            let openId = user.id;

            doPassportCallback(req, res, {
                openId: openId,
                nickname: nickname,
                sourceType: 'renren'
            }).catch(next);
        })(req, res, next);
    }
};

module.exports = {
    common: common,
    wechat: wechat,
    local: local,
    sina: sina,
    qq: qq,
    alipay: alipay,
    douban: douban,
    renren: renren
};