import { HttpStatus, HttpException, Logger } from '@nestjs/common';
import { RpcException } from '@nestjs/microservices';

import ErrorCodes from './errorCodes';

function enrichErrorCode(code: string) {
  switch (code) {
    case ErrorCodes.AUTH.WRONG_CREDENTIALS:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Usuário ou senha incorretos',
        code,
      };

    case ErrorCodes.AUTH.WRONG_PASSWORD_CONFIRMATION:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Senha incorreta',
        message: 'Confirmação de senha incorreta',
        code,
      };

    case ErrorCodes.AUTH.TOTP_NOT_ENABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator não está habilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_ALREADY_ENABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator já está habilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_ALREADY_DISABLED:
      return {
        statusCode: HttpStatus.PRECONDITION_FAILED,
        error: 'Não permitido',
        message: 'A autenticação multifator já está desabilitada',
        code,
      };

    case ErrorCodes.AUTH.TOTP_REQUIRED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Informe o token de autenticação multifator',
        code,
      };

    case ErrorCodes.AUTH.CODE_MISMATCH:
    case ErrorCodes.AUTH.CODE_ALREADY_USED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'Token de autenticação multifator inválido',
        code,
      };

    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_EXPIRED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não permitido',
        message: 'Token para recuperar senha expirado',
        code,
      };

    case ErrorCodes.AUTH.RESET_PASSWORD_CODE_INVALID:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não permitido',
        message: 'Token para recuperar senha inválido',
        code,
      };

    case ErrorCodes.AUTH.WEAK_NEW_PASSWORD:
      return {
        statusCode: HttpStatus.BAD_REQUEST,
        error: 'Não permitido',
        message: 'Senha muito fraca. Escolha uma senha mais forte',
        code,
      };

    case ErrorCodes.RATE_LIMIT:
      return {
        statusCode: HttpStatus.TOO_MANY_REQUESTS,
        error: 'Limite excedido',
        message:
          'Você tentou realizar essa operação muitas vezes. Tente novamente mais tarde',
        code,
      };

    case ErrorCodes.AUTH.UNAUTHORIZED:
      return {
        statusCode: HttpStatus.UNAUTHORIZED,
        error: 'Não autenticado',
        message: 'É necessário estar logado para realizar essa operação',
        code,
      };

    case ErrorCodes.AUTH.FORBIDDEN:
      return {
        statusCode: HttpStatus.FORBIDDEN,
        error: 'Não autorizado',
        message:
          'Você não tem permissões suficientes para realizar essa operação',
        code,
      };

    case ErrorCodes.INTERNAL:
    case ErrorCodes.UNKNOWN:
    default:
      return {
        statusCode: HttpStatus.INTERNAL_SERVER_ERROR,
        error: 'Desconhecido',
        message:
          'Erro desconhecido. Tente novamente ou entre em contato com o suporte',
        code: ErrorCodes.UNKNOWN,
      };
  }
}

const logger = new Logger();

export default class ErrorBuilder extends HttpException {
  code: string;

  constructor(code: string | RpcException) {
    if (typeof code !== 'string') {
      logger.log(code.stack);
      code = (code as any).details as string;
    } else {
      logger.log(code);
    }

    const { statusCode, message, error, code: rCode } = enrichErrorCode(code);
    super({ statusCode, message, error, code: rCode }, statusCode);
    this.code = code;
  }
}