const sha512 = require('js-sha512');
const iplocation = require("iplocation").default;
const crypto = require('crypto');

module.exports = function (db, Sequelize, app)
{
    let User = db.define('user',
    {
        id: {
            type: Sequelize.UUID,
            defaultValue: Sequelize.UUIDV1,
            unique: true,
            primaryKey: true
        },
        country: {
            type: Sequelize.STRING,
            allowNull: true
        },
        nickname: {
            type: Sequelize.STRING,
            allowNull: false,
            unique: true,
            validate: {
                len: {
                    args: [3, 16],
                    msg: "The nickname must be between 3 and 16 characters in length"
                }
            }
        },
        email: {
            type: Sequelize.STRING,
            allowNull: false,
            unique: true,
            validate: {
                len: {
                    args: [6, 128],
                    msg: "Email address must be between 6 and 128 characters in length"
                },
                isEmail: {
                    msg: "Email address must be valid"
                }
            }
        },
        password: {
            type: Sequelize.STRING,
            allowNull: false,
            validate: {
                len: {
                    args: 6
                }
            }
        },
        activated: {
            type: Sequelize.BOOLEAN,
            defaultValue: 0
        },
        ban: {
            type: Sequelize.BOOLEAN,
            defaultValue: 0
        },
        ban_start: {
            type: Sequelize.DATE,
            allowNull: true
        },
        ban_end: {
            type: Sequelize.DATE,
            allowNull: true
        },
        role: {
            type: Sequelize.ENUM('user', 'admin')
        },
        passwordAt: {
            type: Sequelize.DATE,
            allowNull: true
        },
        lastSeen: {
            type: Sequelize.DATE,
            allowNull: true
        },
        activatedAt: {
            type: Sequelize.DATE,
            allowNull: true
        },
        resetAt: {
            type: Sequelize.DATE,
            allowNull: true
        },
        resetKey: {
            type: Sequelize.STRING
        },
        activationKey:
        {
            type: Sequelize.STRING
        }
    });

    User.associate = function (models) {
        User.hasMany(models.character);
    }

    User.login = function (payload)
    {
        return new Promise((resolve, reject) => {
            // Check errors
            let errors = [];

            if (typeof payload.email == 'undefined' || payload.email.length == 0)
                errors.push("The email can't be empty");
            else if (typeof payload.password == 'undefined' || payload.password.length == 0)
                errors.push("The password can't be empty");

            if (Object.keys(errors).length == 0) {
                return app.models.user.findOne({
                    where: {
                        email: payload.email,
                        password: sha512(payload.password)
                    }
                }).then(user => {
                    if (user == null) reject("Authentication failed");
                    else if (user.activated == 0) reject("Please activate your account.")
                    else resolve(user);
                }).catch(error => reject(error));
            } else {
                reject(errors);
            }
        });
    }

    User.register = function (socket, payload)
    {
        return new Promise((resolve, reject) =>
        {
            // Check errors
            let errors = [];

            if (typeof payload.nickname == 'undefined' || payload.nickname.length == 0)
                errors.push("The nickname can't be empty");
            else if (typeof payload.email == 'undefined' || payload.email.length == 0)
                errors.push("The email can't be empty");
            else if (typeof payload.password == 'undefined' || payload.password.length == 0)
                errors.push("The password can't be empty");
            else if (payload.password.length < 6)
                errors.push("The password should be at least 6 characters");

            if (Object.keys(errors).length == 0)
            {
                let defaultDate = '1000-01-01 00:00:00';
                let now = new Date();
                let location = null;

                // Get Ip location
                return iplocation(socket.handshake.address, [], (error, res) =>
                {
                    if (!error)
                        location = res.country;

                    // Generate activation key
                    return User.generateActionKey().then(activationKey =>
                    {
                        // Insert user into database
                        return app.models.user.create({
                            nickname      : payload.nickname,
                            email         : payload.email,
                            password      : sha512(payload.password),
                            country       : location,
                            activated     : 0,
                            ban           : 0,
                            ban_start     : defaultDate,
                            ban_end       : defaultDate,
                            role          : 'user',
                            passwordAt    : defaultDate,
                            lastSeen      : defaultDate,
                            activatedAt   : defaultDate,
                            resetAt       : defaultDate,
                            resetKey      : null,
                            activationKey : activationKey,
                            createdAt     : now,
                            updatedAt     : defaultDate
                        })
                        .then(user => {
                            resolve(user);
                        })
                        .catch(error => reject(error));
                    }).catch(error => reject(error));
                });
            }
            else
                reject(errors);
        });
    }

    User.resetPassword = payload => {
        return new Promise((resolve, reject) => {
            let errors = [];

            if (typeof payload.email == 'undefined' || payload.email.length == 0)
                errors.push("The email can't be empty");

            if (Object.keys(errors).length == 0) {
                return app.models.user.findOne({
                    where: {
                        email: payload.email
                    }
                }).then(user => {
                    if (user == null) reject('Account not found')
                    else if (user.activated == 0) reject('Please first activate your account')
                    else if (user.resetKey != null) reject('A password reset process is already pending.')
                    else {
                        return User.generateActionKey().then(key => {
                            return User.update({ resetKey: key }, { where: { email: user.email } }).then(reset => {
                                resolve(true);
                            }).catch(error => reject(error));
                        }).catch(error => reject(error));
                    }
                }).catch(error => reject(error))
            }
            else {
                reject(errors);
            }
        });
    }

    User.generateActionKey = (size = 48) => {
        return new Promise((res, rej) => {
            return crypto.randomBytes(size, (err, buffer) => {
                if (err) rej(err);
                else res(buffer.toString('hex'));
            });
        })
    }

    User.activate = token => {

    }

    return User;
};