import { Injectable } from '@angular/core';

interface ValidationError {
  field: string;
  message: string;
  values?: string[];
}

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

  // 🗺️ MAPEAMENTO DE CAMPOS TÉCNICOS → NOMES AMIGÁVEIS
  private readonly FIELD_TRANSLATIONS: { [key: string]: string } = {
    // Veículos
    'type': 'Tipo de Veículo',
    'status': 'Status do Veículo',
    'fuel': 'Tipo de Combustível',
    'transmission': 'Transmissão',
    'body_type': 'Tipo de Carroceria',
    'license_plate': 'Placa',
    'brand': 'Marca',
    'model': 'Modelo',
    'color': 'Cor',
    'model_year': 'Ano do Modelo',
    'manufacture_year': 'Ano de Fabricação',
    'vin': 'VIN/Chassi',
    'number_renavan': 'RENAVAM',
    'engine': 'Motor',
    'number_doors': 'Número de Portas',
    'number_seats': 'Número de Assentos',
    'last_odometer': 'Quilometragem',
    'current_location': 'Localização Atual',
    
    // Motoristas
    'name': 'Nome',
    'email': 'E-mail',
    'phone': 'Telefone',
    'cpf': 'CPF',
    'cnh': 'CNH',
    'cnh_category': 'Categoria CNH',
    'birth_date': 'Data de Nascimento',
    'hire_date': 'Data de Contratação',
    
    // Empresas
    'cnpj': 'CNPJ',
    'company_name': 'Razão Social',
    'fantasy_name': 'Nome Fantasia',
    'address': 'Endereço',
    'city': 'Cidade',
    'state': 'Estado',
    'zip_code': 'CEP',
    
    // Rotas
    'origin': 'Origem',
    'destination': 'Destino',
    'route_type': 'Tipo de Rota',
    'priority': 'Prioridade',
    'scheduled_departure': 'Saída Programada',
    'scheduled_arrival': 'Chegada Programada'
  };

  // 🗺️ MAPEAMENTO DE VALORES TÉCNICOS → LABELS AMIGÁVEIS
  private readonly VALUE_TRANSLATIONS: { [key: string]: string } = {
    // Tipos de veículo (backend values)
    'CAMIONETA': 'Caminhonete',
    'AUTOMOVEL': 'Automóvel',
    'CAMINHAO': 'Caminhão',
    'MOTOCICLETA': 'Motocicleta',
    'VAN': 'Van',
    'ONIBUS': 'Ônibus',
    'CAMINHONETE': 'Caminhonete',
    'SEMI-REBOQUE': 'Semi-Reboque',
    'TruckTrailer': 'Caminhão com Carreta',
    'UTILITARIO': 'Utilitário',
    'NAO IDENTIFICADO': 'Não Identificado',
    'OTHER': 'Outro',
    'MICRO ONIBUS': 'Micro Ônibus',
    'MOTONETA': 'Motoneta',
    'CICLOMOTOR': 'Ciclomotor',
    'TRICICLO': 'Triciclo',
    
    // Frontend values (já traduzidos)
    'CAR': 'Carro',
    'TRUCK': 'Caminhão',
    'MOTORCYCLE': 'Motocicleta',
    'BUS': 'Ônibus',
    'TRAILER': 'Carreta',
    'SEMI_TRUCK': 'Semi-Reboque',
    'PICKUP_TRUCK': 'Caminhonete',
    'TRUCK_TRAILER': 'Caminhão com Carreta',
    'MINIBUS': 'Micro Ônibus',
    'MOTOR_SCOOTER': 'Motoneta',
    'MOPED': 'Ciclomotor',
    'TRICYCLE': 'Triciclo',
    'UNIDENTIFIED': 'Não identificado',
    'UTILITY': 'Utilitário',
    
    // Status de veículo
    'available': 'Disponível',
    'in_use': 'Em uso',
    'under_maintenance': 'Em Manutenção',
    'out_of_service': 'Fora de serviço',
    'broken': 'Quebrado',
    'sold': 'Vendido',
    'for_sale': 'Em venda',
    'inactive': 'Inativo',
    'training': 'Em treinamento',
    'under_review': 'Em revisão',
    'rented': 'Alugado',
    'stolen': 'Roubado',
    'crashed': 'Sinistrado',
    'scraped': 'Sucateado',
    'reserved': 'Reservado',
    'under_repair': 'Em reparo',
    
    // Combustíveis
    'Gasoline': 'Gasolina',
    'Ethanol': 'Etanol',
    'Diesel': 'Diesel',
    'Flex': 'Flex',
    'Electric': 'Elétrico',
    'Hybrid': 'Híbrido',
    'Hydrogen': 'Hidrogênio',
    'NaturalGas': 'Gás Natural',
    'Propane': 'Propano',
    'BioDiesel': 'Bio Diesel',
    'FlexFuel': 'Flex Fuel',
    'FlexElectric': 'Flex/Elétrico',
    'FlexGNV': 'Flex/GNV',
    'GasolineElectric': 'Gasolina/Elétrico',
    'GNV': 'GNV',
    
    // Transmissões
    'Manual': 'Manual',
    'Automatic': 'Automática',
    'Automated': 'Automátizado',
    'CVT': 'CVT',
    'DualClutch': 'Dupla Embreagem',
    'TipTronic': 'TipTronic',
    'SemiAutomatic': 'Semi-automática',
    'ReductionGear': 'Redução de Marchas',
    
    // Carrocerias
    'Sedan': 'Sedan',
    'Hatchback': 'Hatchback',
    'Suv': 'SUV',
    'Pickup': 'Pickup',
    'Wagon': 'Wagon/Perua',
    'Coupe': 'Cupê',
    'Convertible': 'Conversível',
    'ChassisCab': 'Chassis Cabine'
  };

  /**
   * 🎯 Método principal para traduzir erros de validação
   */
  translateValidationErrors(errorResponse: any): string[] {
    console.log('🔄 [ErrorTranslation] Traduzindo erros:', errorResponse);
    
    if (!errorResponse?.message) {
      return ['Erro de validação não especificado.'];
    }

    // Se message é string, converter para array
    const messages = Array.isArray(errorResponse.message) 
      ? errorResponse.message 
      : [errorResponse.message];

    const translatedMessages = messages.map((msg: string) => this.transformValidationMessage(msg));
    
    console.log('✅ [ErrorTranslation] Mensagens traduzidas:', translatedMessages);
    return translatedMessages;
  }

  /**
   * 🔄 Transforma uma mensagem técnica em amigável
   */
  private transformValidationMessage(message: string): string {
    console.log('🔧 [ErrorTranslation] Transformando:', message);

    // 🎯 PADRÃO 1: "field must be one of the following values: value1, value2..."
    const enumMatch = message.match(/(\w+) must be one of the following values: (.+)/);
    if (enumMatch) {
      return this.handleEnumValidation(enumMatch[1], enumMatch[2]);
    }

    // 🎯 PADRÃO 2: "field should not be empty"
    const emptyMatch = message.match(/(\w+) should not be empty/);
    if (emptyMatch) {
      return this.handleRequiredField(emptyMatch[1]);
    }

    // 🎯 PADRÃO 3: "field must be a string/number/boolean"
    const typeMatch = message.match(/(\w+) must be a (\w+)/);
    if (typeMatch) {
      return this.handleTypeValidation(typeMatch[1], typeMatch[2]);
    }

    // 🎯 PADRÃO 4: "field must not be less than X"
    const minMatch = message.match(/(\w+) must not be less than (\d+)/);
    if (minMatch) {
      return this.handleMinValidation(minMatch[1], minMatch[2]);
    }

    // 🎯 PADRÃO 5: "field must not be greater than X"
    const maxMatch = message.match(/(\w+) must not be greater than (\d+)/);
    if (maxMatch) {
      return this.handleMaxValidation(maxMatch[1], maxMatch[2]);
    }

    // 🎯 FALLBACK: Retorna mensagem original se não conseguir traduzir
    console.warn('⚠️ [ErrorTranslation] Padrão não reconhecido:', message);
    return message;
  }

  /**
   * 🎯 Trata validação de valores enum (ex: tipo de veículo)
   */
  private handleEnumValidation(fieldName: string, valuesString: string): string {
    const friendlyFieldName = this.FIELD_TRANSLATIONS[fieldName] || fieldName;
    
    // Extrair e traduzir valores
    const values = valuesString.split(', ').map(value => value.trim());
    const friendlyValues = values.map(value => 
      this.VALUE_TRANSLATIONS[value] || value
    );

    // Se muitos valores, mostrar só alguns
    if (friendlyValues.length > 8) {
      const firstValues = friendlyValues.slice(0, 6).join(', ');
      return `O campo '${friendlyFieldName}' deve ser um dos valores: ${firstValues} e outros.`;
    } else {
      return `O campo '${friendlyFieldName}' deve ser um dos valores: ${friendlyValues.join(', ')}.`;
    }
  }

  /**
   * 🎯 Trata campo obrigatório vazio
   */
  private handleRequiredField(fieldName: string): string {
    const friendlyFieldName = this.FIELD_TRANSLATIONS[fieldName] || fieldName;
    return `O campo '${friendlyFieldName}' é obrigatório e não pode estar vazio.`;
  }

  /**
   * 🎯 Trata validação de tipo de dados
   */
  private handleTypeValidation(fieldName: string, expectedType: string): string {
    const friendlyFieldName = this.FIELD_TRANSLATIONS[fieldName] || fieldName;
    const typeTranslations: { [key: string]: string } = {
      'string': 'texto',
      'number': 'número',
      'boolean': 'verdadeiro/falso',
      'array': 'lista',
      'object': 'objeto'
    };
    
    const friendlyType = typeTranslations[expectedType] || expectedType;
    return `O campo '${friendlyFieldName}' deve ser do tipo ${friendlyType}.`;
  }

  /**
   * 🎯 Trata validação de valor mínimo
   */
  private handleMinValidation(fieldName: string, minValue: string): string {
    const friendlyFieldName = this.FIELD_TRANSLATIONS[fieldName] || fieldName;
    return `O campo '${friendlyFieldName}' deve ter valor mínimo de ${minValue}.`;
  }

  /**
   * 🎯 Trata validação de valor máximo
   */
  private handleMaxValidation(fieldName: string, maxValue: string): string {
    const friendlyFieldName = this.FIELD_TRANSLATIONS[fieldName] || fieldName;
    return `O campo '${friendlyFieldName}' deve ter valor máximo de ${maxValue}.`;
  }

  /**
   * 🎯 Método público para traduzir um campo específico
   */
  translateFieldName(fieldName: string): string {
    return this.FIELD_TRANSLATIONS[fieldName] || fieldName;
  }

  /**
   * 🎯 Método público para traduzir um valor específico
   */
  translateValue(value: string): string {
    return this.VALUE_TRANSLATIONS[value] || value;
  }
} 