// ROUTER

router.route("/").post(authRouter);

async function authRouter(req, res) {
  let authData = req.body;
  let body;
  const myLogger = new MyLogger(req.reqId, fileName);
  try {
    myLogger.log("Авторизация: " + authData.email);
    const authLogic = new AuthLogic(authData, req.reqId, res.locals.role);
    const token = await authLogic.getToken();
    myLogger.log("Успешаня авторизация: " + authData.email);
    body = requester.createBody({ token });
  } catch (error) {
    myLogger.myErrorLogger(error);
    body = requester.createError(error);
  }

  res.json(body);
}

module.exports = router;

//LOGIC
/**
 *
 * @param authData
 * @param logId
 * @param role
 */
class AuthLogic {
  constructor(authData, logId, role) {
    this.authData = authData;
    this.myLogger = new MyLogger(logId, this.constructor.name);
    this.role = role;
  }

  validate() {
    try {
      this.myLogger.debug("validate");
      const isEmail = validator.isEmail(this.authData.email);
      const isEmailLength = validator.isLength(this.authData.email, {
        min: myConstants.MIN_EMAIL_LENGTH,
        max: myConstants.MAX_EMAIL_LENGTH
      });

      const isPasswordLength = validator.isLength(this.authData.password, {
        min: myConstants.MIN_PASSWORD_LENGTH,
        max: myConstants.MAX_PASSWORD_LENGTH
      });
      if (!isEmail || !isEmailLength || !isPasswordLength) {
        throw new MyError(
          errorCodes.INVALID_DATA,
          this.authData.email +
            " isEmail:" +
            isEmail +
            " isEmailLength:" +
            isEmailLength +
            " isPasswordLength:" +
            isPasswordLength
        );
      }
    } catch (e) {
      if (e.message === "Expected string but received a number.") {
        e = new MyError(errorCodes.INVALID_DATA, e.message);
      }
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  async checkIsUserExist() {
    try {
      this.myLogger.debug("checkIsUserExist");
      const dbUser = await db_helper.getUserByEmail(this.authData.email);
      if (!dbUser) {
        console.log("Не существует юзера", this.authData.email);
        throw new MyError(
          errorCodes.INVALID_USER_OR_PASSWORD,
          this.authData.email
        );
      }
      this.user = myParser.parseUser(dbUser);
    } catch (e) {
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  checkRole() {
    this.myLogger.debug("checkRole");
    if (this.user.role !== this.role) {
      const e = new MyError(
        errorCodes.INVALID_USER_ROLE,
        "role:" + this.user.role
      );
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  async comparePassword() {
    try {
      this.myLogger.debug("comparePassword");
      const isSuccess = await bcrypt.compare(
        this.authData.password,
        this.user.password
      );
      if (!isSuccess) {
        throw new MyError(
          errorCodes.INVALID_USER_OR_PASSWORD,
          "isSuccess:" + isSuccess
        );
      }
    } catch (e) {
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  async updateLastEnter() {
    try {
      this.myLogger.debug("updateLastEnter");
      const dbUser = await db_helper.updateUserIdentity(this.user.id);
      this.user = myParser.parseUser(dbUser);
    } catch (e) {
      this.myLogger.myErrorLogger(e);
      throw e;
    }
  }

  async getToken() {
    this.myLogger.debug("getToken");
    this.validate();
    await this.checkIsUserExist();
    this.checkRole();
    await this.comparePassword();
    await this.updateLastEnter();
    return tokenGenerator.getToken(this.user);
  }
}

module.exports = AuthLogic;