import {
  InvalidUsernameFormatError,
  WeakPasswordError,
} from "../errors/AccountErrors";
import {
  MAX_USERNAME_LENGTH,
  MIN_PASSWORD_LENGTH,
  MIN_USERNAME_LENGTH,
} from "../validation/AccountValidation";

export class AccountEntity {
  constructor(
    public readonly id: number,
    public readonly username: string,
    private password: string,
    public readonly roleId: number,
    public readonly createdAt: Date,
    public readonly updatedAt: Date,
  ) {}

  private static validatePassword(password: string): void {
    if (password.length < MIN_PASSWORD_LENGTH) {
      throw new WeakPasswordError();
    }
  }

  private static validateUsername(username: string): void {
    if (
      username.length < MIN_USERNAME_LENGTH ||
      username.length > MAX_USERNAME_LENGTH
    ) {
      throw new InvalidUsernameFormatError(username);
    }
  }

  public async verifyPassword(plainPassword: string): Promise<boolean> {
    return await Bun.password.verify(plainPassword, this.password);
  }

  public get hashedPassword(): string {
    return this.password;
  }

  static async create(
    username: string,
    password: string,
  ): Promise<CreateAccountEntity> {
    AccountEntity.validatePassword(password);
    AccountEntity.validateUsername(username);

    const hashedPassword = await Bun.password.hash(password);

    return {
      username,
      hashedPassword,
      roleId: 1,
    };
  }
}

export type CreateAccountEntity = Omit<
  AccountEntity,
  "id" | "verifyPassword" | "createdAt" | "updatedAt"
>;