/**
 * 用户数据模型
 *
 * @author CaiAoLin
 * @date 2017/6/9
 * @version
 */
let mongoose = require("mongoose");
let dbm = require("../../../config/db/db_manager");
let Request = require("request");

class UserModel {

    /**
     * 模型
     *
     * @var {object}
     */
    model = null;

    /**
     * 默认结构
     *
     * @var {object}
     */
    defaultSchema = {
        username: {
            type: String,
            required: true
        },
        email: {
            type: String,
            required: true
        },
        mobile: {
            type: String,
            required: true,
            validate: {
                validator: function(v) {
                    return /^1([34578]\d)\d{8}$/.test(v);
                },
                message: '{VALUE} is not a valid phone number!'
            },
        }
    };

    /**
     * 保存用户详情结构
     *
     * @var {object}
     */
    saveInfoSchema = {
        real_name: {
            type: String,
            required: true
        },
        company: {
            type: String,
            required: true
        },
        province: {
            type: String,
            required: true
        },
        area: {
            type: Number,
            required: true
        },
        company_type: Number,
        company_scale: Number,
        last_login: Number,
        create_time: Number
    };

    /**
     * 构造函数
     *
     * @param {string} scene
     * @return {void}
     */
    constructor(scene = 'default') {
        let umDB = dbm.getCfgConnection("scConstruct");
        let schema = {};
        switch (scene) {
            case 'saveInfo':
                schema = this.saveInfoSchema;
                break;
            default:
                schema = this.defaultSchema;
                break;
        }
        let usersSchema = new mongoose.Schema(schema);
        this.model = umDB.model('users', usersSchema);
    }

    /**
     * 企业所在地区
     *
     * @var {object}
     */
    province = ['广东省', '北京市'];

    /**
     * 企业类型
     *
     * @var
     */
    companyType = ['设计', '施工'];

    /**
     * 企业类型
     *
     * @var
     */
    companyScale = ['1-20', '20-50', '50-100', '100+'];

    /**
     * 根据用户名密码调用SSO接口获取信息
     *
     * @param {string} username
     * @param {string} password
     * @return {object}
     */
    async getInfoFromSSO(username, password) {
        let postData = {
            url: 'http://sso.smartcost.com.cn/api/jzlogin',
            form: {username: username, userpasswd: password},
            encoding: 'utf8'
        };
        return new Promise(function (resolve, reject) {
            try {
                // 请求接口
                Request.post(postData, function (err, postResponse, body) {
                    if (err) {
                        throw '请求错误';
                    }
                    if (postResponse.statusCode !== 200) {
                        throw '通行证验证失败！';
                    }
                    resolve(body);
                });
            } catch (error) {
                reject([]);
            }
        });
    }

    /**
     * 标记用户
     *
     * @param {object} userData
     * @return {Promise}
     */
    async markUser(userData) {
        let userDataFromDb = await this.findDataByName(userData.username);
        let result = false;
        // 信息是否补全
        let info = false;
        if (userDataFromDb.length <= 0) {
            // 不存在用户则入库
            result = await this.addUser(userData);
        } else {
            // 存在则更新用户信息
            let updateData = {last_login: new Date().getTime()};
            let condition = {email: userData.email};
            result = await this.updateUser(condition, updateData);

            userDataFromDb = userDataFromDb[0];
            info = userDataFromDb.real_name !== undefined && userDataFromDb.real_name !== '';
            result = result.ok === 1;
        }

        return [result, info];
    }

    /**
     * 根据用户名查找数据
     *
     * @param {string} username
     * @return {object}
     */
    findDataByName(username) {
        let self = this;
        return new Promise(function (resolve, reject) {
            self.model.find({username: username}, function (error, data) {
                if (error) {
                    console.log(error);
                    reject([]);
                } else {
                    resolve(data);
                }
            });
        });
    }

    /**
     * 新增用户
     *
     * @param {object} userData
     * @return {Promise}
     */
    addUser(userData) {
        let insertData = {
            username: userData.username,
            email: userData.email,
            mobile: userData.mobile,
            real_name: '',
            company: '',
            province: -1,
            company_type: -1,
            company_scale: -1,
            last_login: 0,
            create_time: new Date().getTime()
        };
        let userModel = new this.model(insertData);
        return new Promise(function (resolve, reject) {
            userModel.save(function (error) {
                if (error) {
                    console.log(error);
                    reject(false);
                } else {
                    resolve(true);
                }
            });
        });
    }

    /**
     * 更新用户数据
     *
     * @param {object} updateData
     * @return {Promise}
     */
    updateUser(condition, updateData) {
        if (Object.keys(condition).length <= 0 || Object.keys(updateData).length <= 0) {
            return null;
        }
        let userModel = new this.model();
        return new Promise(function(resolve, reject) {
            let validationError = userModel.validateSync();
            if (validationError) {
                reject(validationError);
            }
            userModel.update(condition, {$set: updateData}, function(error, result) {
                if (error) {
                    reject(error);
                } else {
                    resolve(result);
                }
            });
        });
    }

}

module.exports = UserModel;