import { Injectable } from '@angular/core';
import { MatDialog, MatDialogRef } from '@angular/material/dialog';
import { ErrorTranslationService } from './error-translation.service';
import { ErrorModalComponent, ErrorModalData } from '../../components/error-modal/error-modal.component';
import { SnackNotifyService } from '../../components/snack-notify/snack-notify.service';

@Injectable({
  providedIn: 'root'
})
export class ErrorModalService {

  constructor(
    private dialog: MatDialog,
    private errorTranslation: ErrorTranslationService,
    private snackNotify: SnackNotifyService
  ) {}

  /**
   * 🎯 Método principal para lidar com erros HTTP
   */
  handleHttpError(error: any): void {
    console.log('🚨 [ErrorModal] Tratando erro HTTP:', error);

    const errorCode = error?.status || error?.error?.statusCode || 0;
    const errorResponse = error?.error || error;

    // 🔄 Classificar tipo de erro e decidir como exibir
    if (this.shouldShowModal(errorCode, errorResponse)) {
      this.showValidationModal(errorResponse, errorCode);
    } else if (this.shouldShowSnack(errorCode, errorResponse)) {
      this.showErrorSnack(errorResponse, errorCode);
    } else {
      // Log para erros não tratados
      console.warn('⚠️ [ErrorModal] Erro não tratado:', error);
    }
  }

  /**
   * 🎯 Exibe modal para erros de validação (400, 422)
   */
  showValidationModal(errorResponse: any, errorCode: number = 400): MatDialogRef<ErrorModalComponent> {
    console.log('📋 [ErrorModal] Exibindo modal de validação');
    
    // Traduzir mensagens de erro
    const translatedMessages = this.errorTranslation.translateValidationErrors(errorResponse);
    
    const modalData: ErrorModalData = {
      title: 'Erro de Validação',
      messages: translatedMessages,
      errorCode: errorCode,
      technicalError: errorResponse,
      showRetryButton: false,
      showCancelButton: true
    };

    return this.dialog.open(ErrorModalComponent, {
      data: modalData,
      width: '600px',
      maxWidth: '95vw',
      disableClose: false,
      autoFocus: true,
      restoreFocus: true
    });
  }

  /**
   * 🎯 Exibe modal para erros de servidor (500+)
   */
  showServerErrorModal(errorResponse: any, errorCode: number = 500): MatDialogRef<ErrorModalComponent> {
    console.log('🔥 [ErrorModal] Exibindo modal de erro do servidor');
    
    const modalData: ErrorModalData = {
      title: 'Erro do Servidor',
      messages: ['Ocorreu um problema interno no servidor. Tente novamente em alguns instantes.'],
      errorCode: errorCode,
      technicalError: errorResponse,
      showRetryButton: true,
      showCancelButton: true
    };

    return this.dialog.open(ErrorModalComponent, {
      data: modalData,
      width: '500px',
      maxWidth: '95vw',
      disableClose: false,
      autoFocus: true,
      restoreFocus: true
    });
  }

  /**
   * 🎯 Exibe modal para erros de autenticação (401, 403)
   */
  showAuthErrorModal(errorResponse: any, errorCode: number = 401): MatDialogRef<ErrorModalComponent> {
    console.log('🔐 [ErrorModal] Exibindo modal de erro de autenticação');
    
    const title = errorCode === 401 ? 'Sessão Expirada' : 'Acesso Negado';
    const message = errorCode === 401 
      ? 'Sua sessão expirou. Faça login novamente para continuar.'
      : 'Você não tem permissão para realizar esta ação.';
    
    const modalData: ErrorModalData = {
      title: title,
      messages: [message],
      errorCode: errorCode,
      technicalError: errorResponse,
      showRetryButton: false,
      showCancelButton: false
    };

    return this.dialog.open(ErrorModalComponent, {
      data: modalData,
      width: '450px',
      maxWidth: '95vw',
      disableClose: true, // Forçar ação do usuário
      autoFocus: true,
      restoreFocus: true
    });
  }

  /**
   * 🎯 Exibe snackbar para erros simples
   */
  showErrorSnack(errorResponse: any, errorCode: number): void {
    console.log('📱 [ErrorModal] Exibindo snack de erro simples');
    
    let message = 'Ocorreu um erro inesperado.';
    
    if (errorCode === 404) {
      message = 'Recurso não encontrado.';
    } else if (errorCode === 409) {
      message = 'Conflito de dados. Verifique se o registro não existe.';
    } else if (errorResponse?.message && typeof errorResponse.message === 'string') {
      message = errorResponse.message;
    }

    this.snackNotify.show(message, 'error', {
      duration: 5000
    });
  }

  /**
   * 🎯 Decide se deve mostrar modal baseado no tipo de erro
   */
  private shouldShowModal(errorCode: number, errorResponse: any): boolean {
    // Erros de validação (400, 422) → Modal
    if (errorCode === 400 || errorCode === 422) {
      return true;
    }
    
    // Erros de autenticação (401, 403) → Modal
    if (errorCode === 401 || errorCode === 403) {
      return true;
    }
    
    // Erros de servidor (500+) → Modal
    if (errorCode >= 500) {
      return true;
    }
    
    // Erros com múltiplas mensagens → Modal
    if (Array.isArray(errorResponse?.message) && errorResponse.message.length > 1) {
      return true;
    }
    
    return false;
  }

  /**
   * 🎯 Decide se deve mostrar snackbar
   */
  private shouldShowSnack(errorCode: number, errorResponse: any): boolean {
    // Erros simples (404, 409, etc.) → Snack
    if (errorCode === 404 || errorCode === 409) {
      return true;
    }
    
    // Mensagem única e simples → Snack
    if (typeof errorResponse?.message === 'string' && errorResponse.message.length < 100) {
      return true;
    }
    
    return false;
  }

  /**
   * 🎯 Método de conveniência para mostrar erro customizado
   */
  showCustomError(title: string, messages: string[], options?: Partial<ErrorModalData>): MatDialogRef<ErrorModalComponent> {
    console.log('⚙️ [ErrorModal] Exibindo erro customizado:', title);
    
    const modalData: ErrorModalData = {
      title: title,
      messages: messages,
      errorCode: 0,
      showRetryButton: false,
      showCancelButton: true,
      ...options
    };

    return this.dialog.open(ErrorModalComponent, {
      data: modalData,
      width: '500px',
      maxWidth: '95vw',
      disableClose: false,
      autoFocus: true,
      restoreFocus: true
    });
  }

  /**
   * 🎯 Fechar todos os modais de erro abertos
   */
  closeAllErrorModals(): void {
    console.log('🚪 [ErrorModal] Fechando todos os modais de erro');
    this.dialog.closeAll();
  }
} 