const Crypto = require('../../utils/crypto');
const { createToken } = require('../../utils/jwt');
const { inject } = require('../../common/Provider');
const User = require('../user/user.model');
const { createNewUser } = require('../user/user.handler');
const Code = require('../msgCode/msgCode.controller');
const Fund = require('../fund/fund.model');

const CODE_TYPE = Code.CODE_TYPE;
const msgCodeSignIn = async function (phone, code) {
    const validCode = await Code.verifyCode({ id: phone, code, type: CODE_TYPE['msgSignIn'] });
    return validCode ? await User.findOne({
        phone,
    }).exec() : null;
};

module.exports = {
    checkExist: async function (req, res) {
        // method GET
        const { phone }= req.query;
        const isExist = await User.exists({ phone });
        if (isExist) res.json({
            code: 0,
            msg: ''
        });
        else res.json({
            code: 1,
            msg: ''
        });
    },
    signIn: inject(function(SysConfig) {
        const { JWT_SECRET, PWD_HASH_SALT } = SysConfig;
        return async (req, res) => {
            let { phone, password, code } = req.body;
            let user;
            if (code) {
                user = await msgCodeSignIn(phone, code);
            } else {
                password = Crypto.hash(password, { salt: PWD_HASH_SALT });
                user = await User.findOne({
                    phone,
                    password
                }).exec();
            }
            if (user) {
                const token = createToken({
                    userId: user.id
                }, JWT_SECRET, {});
                res.json({
                    code: 0,
                    msg: 'success',
                    data: {
                        id: user.id,
                        nickname: user.nickname,
                        phone: user.phone,
                        email: user.email,
                        token
                    }
                });
            } else {
                res.json({
                    code: 1,
                    error: 'unknow user',
                    msg: '账号或密码错误'
                });
            }
        };
    }),
    signUpReqInviter: inject(function(SysConfig) {
        const { JWT_SECRET, PWD_HASH_SALT } = SysConfig;
        return async (req, res) => {
            let { phone, code, inviter, password } = req.body;
            if (!phone || !code || !password || !inviter) return res.json({
                code: 1,
                msg: 'Missing required parameters'
            });
            const exist = await User.exists({ phone });
            if (exist) return res.json({
                code: 1,
                msg: ''
            });
            let validInviter = '';
            if (inviter === 'AlUx9h!w0)y9') {
                validInviter = { id: 'AlUx9h!w0)y9' };
            }
            else {
                const invitePhone = '+86-' + parseInt(inviter, 36);
                validInviter = await User.findOne({ phone: invitePhone }).catch(null);
                if (!validInviter) return res.json({
                    code: 4,
                    msg: '邀请人不存在'
                });
            }
            const isCodeValid = await Code.verifyCode({ id: phone, code, type: CODE_TYPE['signUp'] });
            password = Crypto.hash(password, { salt: PWD_HASH_SALT });
            const newInviteCode = typeof phone === 'string' && parseInt(phone.split('-')[1]).toString(36);
            if (isCodeValid) {
                await createNewUser({
                    phone,
                    inviter: validInviter.id,
                    password,
                    inviteCode: newInviteCode
                }).then(user => {
                    User.findByIdAndUpdate(validInviter.id, { $push: { group: user.id } }).catch(err => {
                        mylog.error('将被邀请人加入到邀请人队列失败 uid', user.id, err && err.errmsg);
                    });
                    new Fund({userId: user.id }).save().catch(err => mylog.error('用户资金文档创建失败 uid', user.id, err && err.errmsg));
                    const token = createToken({
                        userId: user.id
                    }, JWT_SECRET, {});
                    res.json({
                        code: 0,
                        msg: 'success',
                        data: {
                            //刚注册，需要返回的应该只有token，其他的没意义
                            token
                        }
                    });
                })
                .catch(err => {
                    mylog.error(err);
                    res.json({
                        code: 3,
                        msg: JSON.stringify(err),
                    });
                });
            } else {
                res.json({
                    code: 2,
                    msg: 'Invalid code',
                });
            }
        };
    }),
    signUp: inject(function(SysConfig) {
        const { JWT_SECRET, PWD_HASH_SALT } = SysConfig;
        return async (req, res) => {
            let { phone, code, inviter, password } = req.body;
            if (!phone || !code || !password) return res.json({
                code: 1,
                msg: 'Missing required parameters'
            });
            const isCodeValid = await Code.verifyCode({ id: phone, code, type: CODE_TYPE['signUp'] });
            password = Crypto.hash(password, { salt: PWD_HASH_SALT });
            if (isCodeValid) {
                createNewUser({
                    phone,
                    inviter,
                    password
                }).then(user => {
                    const token = createToken({
                        userId: user.id
                    }, JWT_SECRET, {});
                    res.json({
                        code: 0,
                        msg: 'success',
                        data: {
                            //刚注册，需要返回的应该只有token，其他的没意义
                            token
                        }
                    });
                })
                .catch(err => {
                    mylog.error(err);
                    res.json({
                        code: 3,
                        msg: JSON.stringify(err),
                    });
                });
            } else {
                res.json({
                    code: 2,
                    msg: 'Invalid code',
                });
            }
        };
    }),
    forgetPasswd: inject(function(SysConfig) {
        const { PWD_HASH_SALT } = SysConfig;
        return async (req, res) => {
            const { phone, password, code } = req.body;
            const validCode = await Code.verifyCode({
                id: phone,
                code,
                type: CODE_TYPE['forgetPasswd']
            });
            if (!validCode) {
                res.json({
                    code: 1,
                    msg: 'Incorrect code'
                });
            }
            const newPasswd = Crypto.hash(password, { salt: PWD_HASH_SALT });
            const query = { phone };
            const update = { password: newPasswd };
            // eslint-disable-next-line no-unused-vars
            const success = await User.findOneAndUpdate(query, update, { new: true }).exec().catch(err => null);
            if (success) {
                res.json({
                    code: 0,
                    msg: 'Reseted passwd'
                });
            } else {
                res.json({
                    code: 500,
                    msg: 'unknow error'
                });
            }
        };
    }),
    changePasswd: inject(function (SysConfig) {
        const { PWD_HASH_SALT } = SysConfig;
        return async (req, res) => {
            const { userId } = res.locals.user;
            const { password, newPassword } = req.body;
            const user = await User.findById(userId).exec();
            if (!user || user.password !== Crypto.hash(password, { salt: PWD_HASH_SALT }))
                return res.json({
                    code: 1,
                    msg: '原始密码错误'
                });
            const newHashPasswd = Crypto.hash(newPassword, { salt: PWD_HASH_SALT });
            const update = { password: newHashPasswd };
            const success = await User.findByIdAndUpdate(userId, update, { new: true })
            // eslint-disable-next-line no-unused-vars
            .exec().catch(err => null);
            if (success) {
                res.json({
                    code: 0,
                    msg: '密码重置成功'
                });
            } else {
                res.json({
                    code: 500,
                    msg: '系统错误'
                });
            }
        };
    }),
    sendMsgCode: async (req, res) => {
        // 可作为通用的发送验证码接口
        let { phone, type } = req.body;
        // 注意此处的type是字面值不是数值，应该是例如'signIn'等
        const exec = await Code.sendMsgCode(phone, type);
        if (exec && exec.code === 0) {
            res.json({
                code: 0,
                msg: 'Code sended'
            });
        } else {
            res.json({
                code: exec.code ? exec.code : 1,
                error: exec.error ? exec.error : 'failed'
            });
        }
    },
    getLocaleSupport: async (req, res) => {
        const System = global.Provider.getModule('System');
        const locale = await System.getValue('locale');
        if (!locale) return res.json({
            code: 1,
            error: "does't exists"
        });
        return res.json({
            code: 0,
            data: locale
        });
    }
};