//maplyful/server/index.js

//sign in existing users

const salt = bcrypt.genSaltSync(10);

app.post('/signin', (req, res) => {
  const { emailOrUsername, password } = req.body;

  if (!userValidity.allFormFieldsFilledIn(req.body)) {
    return res.status(422).json({ message: 'All fields are required.' });
  }
    knex('users').where('email', emailOrUsername)
    .orWhere('username', emailOrUsername)
    .then((user) => {
      if (!user[0]) {
        return res.status(401).json({ message: 'The email or username you entered is incorrect.' });
      }
      if (verifyPassword(password, user[0].salt, user[0].password)) {
        const { first_name, last_name, id, bio, image, username, token, email } = user[0];
        return res.status(200).json({
          first_name,
          last_name,
          id,
          bio,
          image,
          username,
          token,
          email
        });
      }
      return res.status(401).json({ message: 'The password you entered is incorrect.' });
    });
});

//sign up new users, encrypt their passwords

app.post('/signup', (req, res) => {
  const user = req;
  const { password, email, username } = req.body;
  const passwordToSave = bcrypt.hashSync(password, salt);
  const token = uuidV1();
  const userValidityCheck = userValidity.signUpValidity(user);

  if (userValidityCheck.isInvalid) {
    return res.status(userValidityCheck.status).json({ message: userValidityCheck.message });
  }

  //check to see if username or email is already taken, if not create user

  knex('users').where('email', email).then((user) => {
    if (user.length > 0) {
       return res.status(409)
       .json({ message: 'That email address is already on file. Try signing in.' });
    }
  });

  knex('users').where('username', username).then((user) => {
    if (user.length > 0) {
      return res.status(409).json({ message: 'Username is already taken.' });
    }
    knex.insert({
      first_name: req.body.first_name,
      last_name: req.body.last_name,
      email: req.body.email,
      username: req.body.username,
      password: passwordToSave,
      salt,
      token
    }).into('users')
    .then(() => knex('users').where('username', req.body.username)
      .then((user) => {
        const { first_name, last_name, id, bio, image, username, token, email } = user[0];
        return res.status(201).json({
          first_name,
          last_name,
          id,
          bio,
          image,
          username,
          token,
          email
        });
      })).catch(err => {
        console.error(err);
        return res.sendStatus(500);
    });
  });
});


//keep users logged in

app.get('/find/cookie/:token', (req, res) => {
  const { token } = req.params;
  knex('users')
    .where('token', token)
    .then(user => {
      if (!user[0]) {
        res.status(404).json({ message: 'User not found' });
      } else {
        const { first_name, last_name, id, bio, image, username, token, email } = user[0];
          return res.status(200).json({
            first_name,
            last_name,
            id,
            bio,
            image,
            username,
            token,
            email
        });
      }
    });
});


//maplyful/server/handlers/user_handlers/verify_password.js

import bcrypt from 'bcryptjs';

const verifyPassword = (candidatePassword, salt, encryptedPassword) => {
  candidatePassword = bcrypt.hashSync(candidatePassword, salt);
  return candidatePassword === encryptedPassword;
};

export default verifyPassword;

//maplyful/server/handlers/user_handlers/sign_up_validity.js

const validEmail = email => {
    const re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
    return re.test(email);
};

export const allFormFieldsFilledIn = request => {
 for (const field in request) {
   if (request[field] === '') {
     return false;
   }
 }
 return true;
};

 const passwordMeetsRequirements = password => {
  const symbol = /[!@#$%^&*-_=+-{}\\?.()]/;
  const digit = /\d+/g;

  if (password.length < 6) {
    return false;
  } else if (!password.match(digit)) {
    return false;
  } else if (!password.match(symbol)) {
    return false;
  }
  return true;
};

export const signUpValidity = (req) => {
  let { password, email, confirmed_password } = req.body;
  password = password.trim();
  confirmed_password = confirmed_password.trim();
  email = email.trim();

  if (!allFormFieldsFilledIn(req.body)) {
     return {
      isInvalid: true,
      status: 422,
      message: 'All fields are required.'
    };
  }

  if (!validEmail(email)) {
    return {
      isInvalid: true,
      status: 422,
      message: 'A valid email address is required.'
    };
  }

  if (password !== confirmed_password) {
    return {
      isInvalid: true,
      status: 422,
      message: 'Passwords do not match.'
    };
  }

  if (!passwordMeetsRequirements(password)) {
     return {
      isInvalid: true,
      status: 422,
      message: 'Passwords must contain 6 characters, including 1 number and 1 symbol.'
    };
  }

  return {
    isInvalid: false
  };
};