const mongoose = require("mongoose");
const bcrypt = require("bcryptjs");
const jwt = require("jsonwebtoken");

const { sendVerifyMail } = require("./../helpers/nodemailerHelper");
const { hashSalt } = require("./../helpers/bcryptHelper");

module.exports = (mongoose) => {
  const userSchema = new mongoose.Schema({
    email: {
      lowercase: true,
      required: true,
      type: String,
      uniuqe: true
    },
    password: {
      required: true,
      type: String
    },
    username: {
      required: true,
      type: String,
      unique: true
    },
    verified: {
      default: false,
      type: Boolean
    }
  });

  userSchema.pre("save", function (next) {
    this.password = hashSalt(this.password);
    next();
  });


  userSchema.statics.init = (username, email, password) => {
    return new Promise((resolve, reject) => {
      User.find().or([{ username }, { email }]).then(async(users) => {
        if (users.length) return reject(new Error("Username or email is already in use"));

        const newUser = await new User({
          username, email, password
        }).save();

        resolve(newUser);
      });
    });
  };

  userSchema.statics.authenticate = (username, password) => {
    return new Promise(async(resolve, reject) => {
      const existingUser = await User.findOne({
        username
      });

      if (!existingUser) {
        return reject(new Error("User not found"));
      }

      const res = bcrypt.compareSync(password, existingUser.password);

      if (res) resolve(existingUser);
      else reject(new Error("Wrong password"));
    });
  };

  userSchema.statics.verify = (token) => {
    return new Promise((resolve, reject) => {
      jwt.verify(token, process.env.SECRET, async(err, decoded) => {
        if (err) return reject(err);

        const { uid } = decoded;

        const { verified } = await User.findById(uid);
        if (verified) return reject(new Error("User is already verified"));

        const updatedUser = await User.findByIdAndUpdate(uid, {
          isVerified: true
        });

        resolve(updatedUser);
      });
    })
  };

  const User = mongoose.model("User", userSchema);
};