import { dataSource } from "../data-source";
import { refresh } from "../entity/refresh";
import { REFRESH_EXPIRATION } from "../env.defaults";
import InternalException from "../exceptions/internalException";
import { JWTHelper } from "../helpers/jwtHelper";
import { StringHelper } from "../helpers/stringHelper";
import UserService from "../service/userService";
import { JWTRefresh } from "../type/jwtTypes";
import { CreateRefreshCommand, DeleteRefreshCommand } from "./refreshCommand";
import ms from "ms";

export default abstract class RefreshCommandHandler {
  /**
   * @description create and save refreshToken to user
   * @param CreateRefreshCommand
   * @returns {Promise<string>}
   */
  static async create(createRefresh: CreateRefreshCommand): Promise<string> {
    // let createRefreshToken: JWTRefresh = {
    //   userId: createRefresh.userId,
    // };
    // const refreshToken = await JWTHelper.create(createRefreshToken);
    const refreshToken = StringHelper.random(32);

    return await dataSource
      .createQueryBuilder()
      .insert()
      .into(refresh)
      .values({
        token: refreshToken,
        user: await UserService.getById(createRefresh.userId),
        expiry: new Date(Date.now() + ms(REFRESH_EXPIRATION)),
      })
      .execute()
      .then((result) => {
        return refreshToken;
      })
      .catch((err) => {
        throw new InternalException("Failed saving refresh token");
      });
  }

  /**
   * @description delete refresh by user and token
   * @param DeleteRefreshCommand
   * @returns {Promise<any>}
   */
  static async deleteByToken(deleteRefresh: DeleteRefreshCommand): Promise<any> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(refresh)
      .where("refresh.token = :token", { token: deleteRefresh.token })
      .andWhere("refresh.userId = :userId", { userId: deleteRefresh.userId })
      .execute()
      .then((res) => {})
      .catch((err) => {
        throw new InternalException("failed refresh removal");
      });
  }

  /**
   * @description delete expired
   * @returns {Promise<any>}
   */
  static async deleteExpired(): Promise<any> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(refresh)
      .where("refresh.expiry < :expiry", { expiry: new Date() })
      .execute()
      .then((res) => {})
      .catch((err) => {
        throw new InternalException("failed expired refresh removal");
      });
  }
}