/**
 * Utilitário para traduzir erros HTTP em mensagens amigáveis ao usuário
 * Sem expor detalhes técnicos ou códigos do servidor
 */

/**
 * Traduz um erro HTTP em uma mensagem amigável ao usuário
 * @param {Error} error - Objeto de erro do Axios ou erro genérico
 * @returns {string} Mensagem amigável ao usuário
 */
export const getFriendlyErrorMessage = (error) => {
  // Se o erro não tiver resposta (erro de rede, timeout, etc.)
  if (!error.response) {
    if (error.code === 'ECONNABORTED' || error.message?.includes('timeout')) {
      return 'A operação está demorando mais que o esperado. Por favor, tente novamente.';
    }
    if (error.message?.includes('Network Error') || error.message?.includes('ERR_NETWORK')) {
      return 'Não foi possível conectar ao servidor. Verifique sua conexão com a internet.';
    }
    return 'Não foi possível completar a operação. Por favor, tente novamente.';
  }

  const status = error.response?.status;
  const errorData = error.response?.data;

  // Tenta usar mensagem do backend se for amigável
  if (errorData?.message && typeof errorData.message === 'string') {
    // Verifica se a mensagem não contém códigos técnicos
    const technicalPatterns = [
      /^HTTP \d{3}/,
      /^Error \d{3}/,
      /status code/i,
      /status: \d{3}/i,
      /\[.*\]/,
      /at .*\.js/,
      /line \d+/i,
      /stack trace/i
    ];
    
    const isTechnical = technicalPatterns.some(pattern => pattern.test(errorData.message));
    if (!isTechnical) {
      return errorData.message;
    }
  }

  // Traduz códigos de status HTTP em mensagens amigáveis
  switch (status) {
    case 400:
      // Bad Request - Dados inválidos
      if (errorData?.errors && Array.isArray(errorData.errors)) {
        const errors = errorData.errors.map(e => e.message || e).join(', ');
        return `Verifique os dados informados: ${errors}`;
      }
      return 'Os dados informados estão incorretos. Por favor, verifique e tente novamente.';
    
    case 401:
      // Unauthorized - Não autorizado
      return 'Sua sessão expirou. Por favor, faça login novamente.';
    
    case 403:
      // Forbidden - Acesso negado
      return 'Você não tem permissão para realizar esta operação.';
    
    case 404:
      // Not Found - Recurso não encontrado
      return 'A informação solicitada não foi encontrada.';
    
    case 409:
      // Conflict - Conflito
      return 'Já existe um registro com essas informações. Verifique os dados e tente novamente.';
    
    case 422:
      // Unprocessable Entity - Erro de validação
      if (errorData?.errors && Array.isArray(errorData.errors)) {
        const errors = errorData.errors.map(e => e.message || e).join(', ');
        return `Dados inválidos: ${errors}`;
      }
      return 'Os dados informados não são válidos. Verifique e tente novamente.';
    
    case 500:
      // Internal Server Error
      return 'Ocorreu um erro no servidor. Nossa equipe foi notificada. Por favor, tente novamente em alguns instantes.';
    
    case 502:
      // Bad Gateway
      return 'O servidor está temporariamente indisponível. Tente novamente em alguns instantes.';
    
    case 503:
      // Service Unavailable
      return 'O serviço está temporariamente indisponível. Tente novamente em alguns instantes.';
    
    case 504:
      // Gateway Timeout
      return 'A operação está demorando mais que o esperado. Por favor, tente novamente.';
    
    default:
      // Outros erros HTTP
      if (status >= 500) {
        return 'Ocorreu um erro no servidor. Por favor, tente novamente mais tarde.';
      }
      if (status >= 400) {
        return 'Não foi possível processar sua solicitação. Verifique os dados e tente novamente.';
      }
      return 'Ocorreu um erro inesperado. Por favor, tente novamente.';
  }
};

/**
 * Extrai uma mensagem de erro amigável, priorizando mensagens do backend
 * mas garantindo que sejam amigáveis
 * @param {Error} error - Objeto de erro
 * @returns {string} Mensagem amigável
 */
export const extractFriendlyMessage = (error) => {
  // Se já temos uma mensagem amigável do backend, usa ela
  if (error.response?.data?.message && typeof error.response.data.message === 'string') {
    const msg = error.response.data.message;
    // Verifica se não é uma mensagem técnica
    if (!msg.match(/^(HTTP|Error|status|\[|at |line )/i)) {
      return msg;
    }
  }
  
  // Caso contrário, usa a tradução baseada no status
  return getFriendlyErrorMessage(error);
};



