import { Component, Inject, OnInit } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormBuilder, FormGroup, Validators, ReactiveFormsModule } from '@angular/forms';
import { MatDialogRef, MAT_DIALOG_DATA, MatDialogModule } from '@angular/material/dialog';
import { MatButtonModule } from '@angular/material/button';
import { MatFormFieldModule } from '@angular/material/form-field';
import { MatInputModule } from '@angular/material/input';
import { MatSelectModule } from '@angular/material/select';
import { MatIconModule } from '@angular/material/icon';

import { VehiclesService } from '../../vehicles.service';
import { PersonService } from '../../../../shared/services/person.service';
import { SnackNotifyService } from '../../../../shared/components/snack-notify/snack-notify.service';
import { Vehicle } from '../../vehicle.interface';
import { RemoteSelectComponent } from '../../../../shared/components/remote-select/remote-select.component';
import { RemoteSelectConfig } from '../../../../shared/components/remote-select/interfaces/remote-select.interface';
import { SupplierService } from '../../../supplier/supplier.service';
import { CustomerService } from '../../../customer/customer.service';

/**
 * 🚗 VehicleStatusModalComponent - Modal para Alteração de Status de Veículos
 * 
 * ✨ Funcionalidades:
 * - Alteração de status para múltiplos veículos
 * - Campos dinâmicos baseados no tipo de status
 * - Validações de transição de status
 * - Integração com PersonService para remote-selects
 * - Remoção individual de veículos da lista
 * - Feedback detalhado de resultados
 */
@Component({
  selector: 'app-vehicle-status-modal',
  standalone: true,
  imports: [
    CommonModule,
    ReactiveFormsModule,
    MatDialogModule,
    MatButtonModule,
    MatFormFieldModule,
    MatInputModule,
    MatSelectModule,
    MatIconModule,
    RemoteSelectComponent
  ],
  templateUrl: './vehicle-status-modal.component.html',
  styleUrl: './vehicle-status-modal.component.scss'
})
export class VehicleStatusModalComponent implements OnInit {

  statusForm: FormGroup;
  selectedVehicles: Vehicle[] = [];
  isLoading = false;

  // Tipos de status/ocorrência disponíveis
  statusOptions = [
    { value: 'maintenance', label: 'Enviar para Manutenção', icon: 'fa-wrench', newStatus: 'under_maintenance' },
    { value: 'for_sale', label: 'Enviar para Venda', icon: 'fa-tag', newStatus: 'for_sale' },
    { value: 'sold', label: 'Confirmar Venda', icon: 'fa-dollar-sign', newStatus: 'sold' },
    { value: 'rented', label: 'Registrar Locação', icon: 'fa-home', newStatus: 'rented' },
    { value: 'stolen', label: 'Informar Roubo', icon: 'fa-exclamation-triangle', newStatus: 'stolen' },
    { value: 'under_review', label: 'Enviar para Revisão', icon: 'fa-search', newStatus: 'under_review' },
    { value: 'available', label: 'Disponibilizar Veículo', icon: 'fa-check-circle', newStatus: 'available' },
    { value: 'in_use', label: 'Colocar em uso', icon: 'fa-check-circle', newStatus: 'in_use' },
    { value: 'in_auction', label: 'Enviar para Leilão', icon: 'fa-tag', newStatus: 'in_auction' },
  ];

  // Configurações para remote-selects
  personRemoteConfig: RemoteSelectConfig = {
    service: this.personService,
    searchField: 'name',
    displayField: 'name',
    valueField: 'id',
    placeholder: 'Digite o nome do responsável...',
    minLength: 2,
    debounceTime: 300
  };

  clienteRemoteConfig: RemoteSelectConfig = {
    service: this.customerService,
    searchField: 'name',
    displayField: 'name',
    valueField: 'id',
    placeholder: 'Digite o nome do cliente...',
    minLength: 2,
    debounceTime: 300
  };

  fornecedorRemoteConfig: RemoteSelectConfig = {
    service: this.supplierService,
    searchField: 'name',
    displayField: 'name',
    valueField: 'id',
    placeholder: 'Digite o nome da oficina...',
    minLength: 2,
    debounceTime: 300,
    filters: {
      segment: ['officine']
    }
  };

  constructor(
    private fb: FormBuilder,
    private vehiclesService: VehiclesService,
    private personService: PersonService,
    private customerService: CustomerService,
    private supplierService: SupplierService,
    private snackNotifyService: SnackNotifyService,
    private dialogRef: MatDialogRef<VehicleStatusModalComponent>,
    @Inject(MAT_DIALOG_DATA) public data: { selectedVehicles: Vehicle[] }
  ) {
    this.selectedVehicles = [...data.selectedVehicles];
    this.statusForm = this.createForm();
  }

  ngOnInit(): void {
    // Foco automático no select de status quando o modal abrir
    setTimeout(() => {
      const statusSelect = document.getElementById('status_select');
      if (statusSelect) {
        statusSelect.focus();
      }
    }, 100);
  }

  /**
   * 🎯 Cria o formulário reativo com validações
   */
  private createForm(): FormGroup {
    return this.fb.group({
      status: ['', Validators.required],
      tipo_ocorrencia: [''],
      data_ocorrencia: [new Date().toISOString().split('T')[0], Validators.required],
      local_ocorrencia: [''],
      descricao_ocorrencia: [''],
      person_id: [null],
      cliente_id: [null],
      fornecedor_id: [null]
    });
  }

  /**
   * 🎯 Manipula mudança de status e configura campos dinâmicos
   */
  onStatusChange(status: string): void {
    this.resetConditionalFields();
    
    // Definir tipo_ocorrencia baseado no status
    this.statusForm.patchValue({ tipo_ocorrencia: status });
    
    // Configurar validações condicionais
    this.setupConditionalValidations(status);
    
    // Carregar dados para remote-selects se necessário
    this.loadRemoteSelectData(status);
  }

  /**
   * 🎯 Reseta campos condicionais
   */
  private resetConditionalFields(): void {
    this.statusForm.patchValue({
      person_id: null,
      cliente_id: null,
      fornecedor_id: null
    });
  }

  /**
   * 🎯 Configura validações condicionais baseadas no status
   */
  private setupConditionalValidations(status: string): void {
    const personControl = this.statusForm.get('person_id');
    const clienteControl = this.statusForm.get('cliente_id');
    const fornecedorControl = this.statusForm.get('fornecedor_id');
    const localControl = this.statusForm.get('local_ocorrencia');

    // Limpar validações anteriores
    [personControl, clienteControl, fornecedorControl, localControl].forEach(control => {
      control?.clearValidators();
      control?.updateValueAndValidity();
    });

    // Aplicar validações baseadas no status
    switch (status) { 
      case 'for_sale':
        personControl?.setValidators([Validators.required]);
        break;
      case 'in_use':
        personControl?.setValidators([Validators.required]);
        break;
      case 'available':
        personControl?.setValidators([Validators.required]);
        break;
      case 'rented':
        clienteControl?.setValidators([Validators.required]);
        break;
      case 'under_review':
        fornecedorControl?.setValidators([Validators.required]);
        break;
      case 'stolen':
        localControl?.setValidators([Validators.required]);
        break;
        case 'sold':
          clienteControl?.setValidators([Validators.required]);
          break;
    }

    // Atualizar validações
    [personControl, clienteControl, fornecedorControl, localControl].forEach(control => {
      control?.updateValueAndValidity();
    });
  }

  /**
   * 🎯 Configura filtros e placeholders para remote-selects baseado no status
   */
  private loadRemoteSelectData(status: string): void {
    // Configurar placeholders específicos para cada tipo de status
    switch (status) {
      case 'for_sale':
        this.personRemoteConfig = {
          ...this.personRemoteConfig,
          placeholder: 'Digite o nome do local de venda...'
        };
        break;
      case 'in_use':
        this.personRemoteConfig = {
          ...this.personRemoteConfig,
          placeholder: 'Digite o nome do local de uso...'
        };
        break;
      case 'available':
        this.personRemoteConfig = {
          ...this.personRemoteConfig,
          placeholder: 'Digite o nome do local de operação...'
        };
        break;
      case 'rented':
        this.clienteRemoteConfig = {
          ...this.clienteRemoteConfig,
          placeholder: 'Digite o nome do cliente...'
        };
        break;
      case 'under_review':
        this.fornecedorRemoteConfig = {
          ...this.fornecedorRemoteConfig,
          placeholder: 'Digite o nome da oficina...'
        };
        break;
        case 'sold':
          this.clienteRemoteConfig = {
            ...this.clienteRemoteConfig,
            placeholder: 'Digite o nome do cliente...'
          };
          break;        
    }
  }

  /**
   * 🎯 Remove veículo da lista de selecionados
   */
  removeVehicle(vehicleId: number): void {
    this.selectedVehicles = this.selectedVehicles.filter(v => v.id !== vehicleId);
    
    if (this.selectedVehicles.length === 0) {
      this.snackNotifyService.info('Nenhum veículo selecionado. Fechando modal.', { duration: 3000 });
      this.dialogRef.close({ action: 'cancelled' });
    }
  }

  /**
   * 🎯 Processa o envio do formulário
   */
  onSubmit(): void {
    if (this.statusForm.valid && this.selectedVehicles.length > 0) {
      this.updateVehiclesStatus();
    } else {
      this.markFormGroupTouched();
    }
  }

  /**
   * 🎯 Marca todos os campos como touched para exibir erros
   */
  private markFormGroupTouched(): void {
    Object.keys(this.statusForm.controls).forEach(key => {
      const control = this.statusForm.get(key);
      control?.markAsTouched();
    });
  }

  /**
   * 🎯 Atualiza status dos veículos selecionados
   */
  private async updateVehiclesStatus(): Promise<void> {
    this.isLoading = true;
    const formData = this.statusForm.value;
    const results: { vehicle: Vehicle, success: boolean, error?: string }[] = [];

    // Encontrar o novo status baseado na seleção
    const selectedOption = this.statusOptions.find(opt => opt.value === formData.status);
    const newStatus = selectedOption?.newStatus || formData.status;

    for (const vehicle of this.selectedVehicles) {
      try {
        // Validar se a transição de status é permitida
        const canTransition = this.validateStatusTransition(vehicle, newStatus);
        if (!canTransition.valid) {
          results.push({ 
            vehicle, 
            success: false, 
            error: canTransition.message 
          });
          continue;
        }

        // Preparar dados para atualização
        const updateData: any = {
          status: newStatus
        };

        // Definir location_person_id baseado nos campos preenchidos
        if (formData.person_id) {
          updateData.location_person_id = formData.person_id;
        } else if (formData.cliente_id) {
          updateData.location_person_id = formData.cliente_id;
        } else if (formData.fornecedor_id) {
          updateData.location_person_id = formData.fornecedor_id;
        }

        // Construir notes apenas com valores existentes
        const notesArray: string[] = [];
        
        if (vehicle.description && vehicle.description.trim()) {
          notesArray.push(`Descrição: ${vehicle.description.trim()}`);
        }
        
        if (formData.descricao_ocorrencia && formData.descricao_ocorrencia.trim()) {
          notesArray.push(`Descrição da Ocorrência: ${formData.descricao_ocorrencia.trim()}`);
        }
        
        if (formData.local_ocorrencia && formData.local_ocorrencia.trim()) {
          notesArray.push(`Local da Ocorrência: ${formData.local_ocorrencia.trim()}`);
        }
        
        if (formData.tipo_ocorrencia && formData.tipo_ocorrencia.trim()) {
          notesArray.push(`Tipo de Ocorrência: ${formData.tipo_ocorrencia.trim()}`);
        }
        
        if (formData.data_ocorrencia) {
          notesArray.push(`Data da Ocorrência: ${formData.data_ocorrencia}`);
        }

        // Adicionar notes apenas se houver conteúdo
        if (notesArray.length > 0) {
          updateData.notes = notesArray.join('\n');
        }

        // Atualizar status do veículo
        await this.vehiclesService.update(vehicle.id, updateData).toPromise();
        results.push({ vehicle, success: true });

      } catch (error: any) {
        results.push({ 
          vehicle, 
          success: false, 
          error: error?.error?.message || error?.message || 'Erro desconhecido' 
        });
      }
    }

    this.isLoading = false;
    this.showResults(results);
  }

  /**
   * 🎯 Valida se a transição de status é permitida
   */
  private validateStatusTransition(vehicle: Vehicle, newStatus: string): { valid: boolean, message?: string } {
    const currentStatus = vehicle.status?.toLowerCase();
    
    // Regras de validação de transição de status
    if (currentStatus === 'sold' && newStatus !== 'sold') {
      return { 
        valid: false, 
        message: `${vehicle.license_plate}: Veículos vendidos não podem ter status alterado` 
      };
    }
    
    if (currentStatus === 'stolen' && !['under_review', 'stolen'].includes(newStatus)) {
      return { 
        valid: false, 
        message: `${vehicle.license_plate}: Veículos roubados só podem ir para revisão` 
      };
    }

    if (currentStatus === 'crashed' && ['available', 'rented'].includes(newStatus)) {
      return { 
        valid: false, 
        message: `${vehicle.license_plate}: Veículos sinistrados precisam de manutenção antes de ficarem disponíveis` 
      };
    }

    return { valid: true };
  }

  /**
   * 🎯 Exibe resultados da operação
   */
  private showResults(results: { vehicle: Vehicle, success: boolean, error?: string }[]): void {
    const successful = results.filter(r => r.success);
    const failed = results.filter(r => !r.success);

    if (successful.length > 0) {
      this.snackNotifyService.success(
        `Status atualizado com sucesso para ${successful.length} veículo(s)!`,
        { duration: 4000 }
      );
    }

    if (failed.length > 0) {
      const errorMessages = failed.map(f => f.error).join('\n');
      this.snackNotifyService.error(
        `Erro em ${failed.length} veículo(s):\n${errorMessages}`,
        { duration: 8000 }
      );
    }

    this.dialogRef.close({ 
      action: 'updated', 
      successful: successful.length,
      failed: failed.length,
      results: results
    });
  }

  /**
   * 🎯 Cancela e fecha o modal
   */
  onCancel(): void {
    this.dialogRef.close({
      action: 'cancelled'
    });
  }

  /**
   * 🎯 Verifica se deve mostrar campo person_id
   */
  get showPersonField(): boolean {
    const status = this.statusForm.get('status')?.value;
    return ['for_sale', 'in_use'].includes(status);
  }

  /**
   * 🎯 Verifica se deve mostrar campo cliente_id
   */
  get showClienteField(): boolean {
    const status = this.statusForm.get('status')?.value;
    return status === 'rented' || status === 'sold';
  }

  /**
   * 🎯 Verifica se deve mostrar campo fornecedor_id
   */
  get showFornecedorField(): boolean {
    const status = this.statusForm.get('status')?.value;
    return status === 'under_review';
  }

  /**
   * 🎯 Verifica se deve mostrar campo local_ocorrencia
   */
  get showLocalField(): boolean {
    const status = this.statusForm.get('status')?.value;
    return status === 'stolen' ;
  }

  /**
   * 🎯 Retorna o label dinâmico para o campo Person baseado no status
   */
  get personFieldLabel(): string {
    const status = this.statusForm.get('status')?.value;
    switch (status) {
      case 'for_sale':
        return 'Local de Venda';
      case 'in_use':
        return 'Local de Operação';
      case 'available':
        return 'Local de Operação';      
      default:
        return 'Responsável';
    }
  }

  /**
   * 🎯 Verifica se o formulário tem erros para exibir
   */
  hasFieldError(fieldName: string): boolean {
    const field = this.statusForm.get(fieldName);
    return !!(field?.errors && field?.touched);
  }

  /**
   * 🎯 Retorna a mensagem de erro do campo
   */
  getFieldErrorMessage(fieldName: string): string {
    const field = this.statusForm.get(fieldName);
    
    if (field?.errors?.['required']) {
      return 'Este campo é obrigatório';
    }
    
    return '';
  }

  /**
   * 🎯 Retorna o ícone do status selecionado
   */
  get selectedStatusIcon(): string {
    const status = this.statusForm.get('status')?.value;
    const option = this.statusOptions.find(opt => opt.value === status);
    return option?.icon || 'fa-exchange-alt';
  }

  /**
   * 🎯 TrackBy function para otimizar performance da lista de veículos
   */
  trackByVehicleId(index: number, vehicle: Vehicle): number {
    return vehicle.id;
  }

  /**
   * 🎯 Mapeia o status atual do veículo para o label correspondente
   */
  getStatusLabel(status: string): string {
    if (!status) return 'N/A';
    
    // Mapeamento de status para labels amigáveis
    const statusMap: { [key: string]: string } = {
      'active': 'Ativo',
      'available': 'Disponível',
      'under_maintenance': 'Em Manutenção',
      'for_sale': 'À Venda',
      'sold': 'Vendido',
      'rented': 'Locado',
      'stolen': 'Roubado',
      'under_review': 'Em Revisão',
      'crashed': 'Sinistrado',
      'inactive': 'Inativo',
      'reserved': 'Reservado',
      'training': 'Em Treinamento',
      'in_use': 'Em Uso',
      'out_of_service': 'Fora de Serviço',
      'broken': 'Quebrado',
      'in_auction': 'Em Leilão',
      'under_repair': 'Em Reparo',
      'UNIDENTIFIED': 'Não identificado',      
    }; 

    return statusMap[status.toLowerCase()] || status;
  }

  /**
   * 🎯 Retorna o ícone correspondente ao status atual do veículo
   */
  getStatusIcon(status: string): string {
    if (!status) return 'fa-question-circle';
    
    // Mapeamento de status para ícones
    const iconMap: { [key: string]: string } = {
      'active': 'fa-play-circle',
      'available': 'fa-check-circle',
      'under_maintenance': 'fa-wrench',
      'for_sale': 'fa-tag',
      'sold': 'fa-dollar-sign',
      'rented': 'fa-home',
      'stolen': 'fa-exclamation-triangle',
      'under_review': 'fa-search',
      'crashed': 'fa-car-crash',
      'inactive': 'fa-pause-circle',
      'reserved': 'fa-bookmark',
      'training': 'fa-graduation-cap',
      'in_use': 'fa-car',
      'out_of_service': 'fa-times-circle',
      'broken': 'fa-exclamation-triangle',
      'in_auction': 'fa-gavel',
      'under_repair': 'fa-tools',     
      'UNIDENTIFIED': 'fa-question-circle',
    };

    return iconMap[status.toLowerCase()] || 'fa-circle';
  }
}
 