import { Response } from "express";
import { UserD, UserModel } from "../models/user.model";
import { MyRequest } from "../types/Express";
import { ErrorResponse, SuccessResponse } from "../utils/Response";
import authLogs, { authLogger, IAuthLogs } from "../services/auth/auth.logs";
import { generateToken } from "../utils/Jwt";
import { formatString } from "../utils/Strings";
import { HttpCodes } from "../config/Errors";

export const SignIn = async (req: MyRequest<UserD>, res: Response) => {
  const { email, password, stay = false } = req.body;
  try {
    const user = await UserModel.findOne({ email });
    if (user) {
      const isPasswordMatch = await user.comparePasswords(password);

      if (isPasswordMatch) {
        const token = generateToken(res, { _id: user._id.toString() });
        const resp: ICode<IAuthLogs> = authLogs.LOGIN_SUCCESS;
        const msg = formatString(resp.message, user.toObject());
        authLogger.info(msg, { type: resp.type });

        return SuccessResponse(
          res,
          HttpCodes.Accepted.code,
          { ...user.Optimize(), token: token },
          msg
        );
      }
      const msg = formatString(
        authLogs.LOGIN_ERROR_INCORRECT_PASSWORD_FOUND.message,
        { email }
      );
      authLogger.error(msg);
      return ErrorResponse(res, HttpCodes.BadRequest.code, msg);
    }
    const msg = formatString(authLogs.LOGIN_ERROR_EMAIL_NOT_FOUND.message, {
      email,
    });
    authLogger.error(msg);
    return ErrorResponse(res, HttpCodes.BadRequest.code, msg);
  } catch (err) {
    const msg = formatString(authLogs.LOGIN_ERROR_GENERIC.message, {
      error: (err as Error)?.message || "",
      email,
    });
    authLogger.error(msg, err as Error);
    return ErrorResponse(res, HttpCodes.InternalServerError.code, msg, err);
  }
};

export const SignUp = async (req: MyRequest<UserD>, res: Response) => {
  const { email, password, firstName, lastName } = req.body;
  try {
    const userExist = await UserModel.findOne({
      email,
    });
    if (userExist) {
      const msg = formatString(authLogs.REGISTER_ERROR_EMAIL_EXIST.message, {
        email,
      });
      authLogger.error(msg);
      return ErrorResponse(res, HttpCodes.BadRequest.code, msg);
    }
    const user = new UserModel({
      email,
      password,
      firstName,
      lastName,
    });
    const savedUser = await user.save();
    const token = generateToken(res, { _id: savedUser._id.toString() });
    const resp: ICode<IAuthLogs> = authLogs.REGISTER_SUCCESS;
    const msg = formatString(resp.message, savedUser.toObject());
    authLogger.info(msg, { type: resp.type });
    return SuccessResponse(
      res,
      HttpCodes.Created.code,
      { ...savedUser.Optimize(), token: token },
      msg
    );
  } catch (err) {
    const msg = formatString(authLogs.REGISTER_ERROR_GENERIC.message, {
      error: (err as Error)?.message || "",
      email,
    });
    authLogger.error(msg, err as Error);
    return ErrorResponse(res, HttpCodes.InternalServerError.code, msg, err);
  }
};

export const AuthBack = async (req: MyRequest<UserD>, res: Response) => {
  const user = req.user as UserD;
  const resp = authLogs.AUTH_BACK;

  const msg = formatString(resp.message, {
    email: user.email,
    username: user.firstName + " " + user.lastName,
  });
  authLogger.info(msg, { type: resp.type });

  return SuccessResponse(
    res,
    HttpCodes.Accepted.code,
    user.Optimize(),
    msg,
    authLogs.AUTH_BACK.type
  );
};