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 { MatIconModule } from '@angular/material/icon';

import { VehiclesService } from '../../vehicles.service';
import { SnackNotifyService } from '../../../../shared/components/snack-notify/snack-notify.service';
import { IntegrationService } from '../../../integration/services/integration.service';

/**
 * 🚗 VehicleCreateModalComponent - Modal para Cadastro Rápido de Veículo
 * 
 * ✨ Funcionalidades:
 * - Cadastro rápido com apenas a placa
 * - Validação de formato de placa brasileira
 * - Criação do veículo e integração automática com BrasilCredit
 * - Redirecionamento para edição com dados completos
 * - Design moderno com ícone e animações
 */
@Component({
  selector: 'app-vehicle-create-modal',
  standalone: true,
  imports: [
    CommonModule,
    ReactiveFormsModule,
    MatDialogModule,
    MatButtonModule,
    MatFormFieldModule,
    MatInputModule,
    MatIconModule
  ],
  templateUrl: './vehicle-create-modal.component.html',
  styleUrl: './vehicle-create-modal.component.scss'
})
export class VehicleCreateModalComponent implements OnInit {

  vehicleForm: FormGroup;
  isLoading = false;

  constructor(
    private fb: FormBuilder,
    private vehiclesService: VehiclesService,
    private integrationService: IntegrationService,
    private snackNotifyService: SnackNotifyService,
    private dialogRef: MatDialogRef<VehicleCreateModalComponent>,
    @Inject(MAT_DIALOG_DATA) public data: any
  ) {
    this.vehicleForm = this.createForm();
  }

  ngOnInit(): void {
    // Foco automático no campo de placa quando o modal abrir
    setTimeout(() => {
      const plateInput = document.getElementById('license_plate');
      if (plateInput) {
        plateInput.focus();
      }
    }, 100);
  }

  /**
   * 🎯 Cria o formulário de cadastro rápido
   */
  private createForm(): FormGroup {
    return this.fb.group({
      license_plate: ['', [
        Validators.required,
        Validators.minLength(7),
        Validators.maxLength(8),
        this.plateValidator
      ]]
    });
  }

  /**
   * 🎯 Validador customizado para formato de placa brasileira
   * Aceita formatos: ABC1234 ou ABC1D23 (Mercosul)
   */
  private plateValidator(control: any) {
    if (!control.value) return null;
    
    const plate = control.value.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
    

    if (plate.length < 7) {
      return null;
    }
    
    // Formato antigo: 3 letras + 4 números (ABC1234)
    const oldFormat = /^[A-Z]{3}[0-9]{4}$/;
    
    // Formato Mercosul: 3 letras + 1 número + 1 letra + 2 números (ABC1D23)
    const mercosulFormat = /^[A-Z]{3}[0-9]{1}[A-Z]{1}[0-9]{2}$/;
    
    // Aceitar se tem 7 ou 8 caracteres e corresponde a um dos formatos
    if ((plate.length === 7 || plate.length === 8) && (oldFormat.test(plate) || mercosulFormat.test(plate))) {
      return null;
    }
    
    return { invalidPlate: true };
  }

  /**
   * 🎯 Formata a placa conforme o usuário digita
   */
  onPlateInput(event: any): void {
    let value = event.target.value.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
    
    // Limitar o tamanho máximo
    if (value.length > 8) {
      value = value.substring(0, 8);
    }
    
    // Formatação progressiva
    if (value.length > 3) {
      // Se tem 7+ caracteres, pode ser Mercosul (ABC1D23)
      if (value.length >= 7) {
        const firstThree = value.substring(0, 3);
        const fourth = value.substring(3, 4);
        const fifth = value.substring(4, 5);
        const rest = value.substring(5);
        
        // Verificar se é formato Mercosul (4º char é número, 5º é letra)
        if (/[0-9]/.test(fourth) && /[A-Z]/.test(fifth)) {
          // Formato Mercosul: ABC-1D23
          value = `${firstThree}-${fourth}${fifth}${rest}`;
        } else {
          // Formato antigo: ABC-1234
          value = `${firstThree}-${value.substring(3)}`;
        }
      } else {
        // Ainda digitando, formato padrão
        value = `${value.substring(0, 3)}-${value.substring(3)}`;
      }
    }
    
    this.vehicleForm.patchValue({ license_plate: value });
  }

  /**
   * 🎯 Processa o cadastro do veículo
   */
  onSubmit(): void {
    if (this.vehicleForm.valid && !this.isLoading) {
      this.createVehicle();
    }
  }

  /**
   * 🎯 Cria o veículo com dados mínimos e atualiza via BrasilCredit
   */
  private createVehicle(): void {
    this.isLoading = true;
    
    const plateValue = this.vehicleForm.get('license_plate')?.value;
    const cleanPlate = plateValue.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
    
    const vehicleData = {
      license_plate: cleanPlate,
      type: "TRAILER",
      body_type: "Sedan",
      fuel: "Gasoline",
      transmission: "Automatic",
      status: "active",
      number_renavan: "string",
      vin: "string",
      number_crv: "string",
      doc_year: 0,
      model: "string",
      model_year: 0,
      version: "string",
      manufacture_year: 0,
      brand: "string",
      mark: "string",
      group: "string",
      color: {
        name: "string",
        code: "string"
      },
      number_seats: 0,
      number_doors: 0,
      number_large_bags: 0,
      number_small_bags: 0,
      engine_number: "string",
      engine_power: 0,
      cylinders_number: 0,
      axles_number: 0,
      volume_engine: 0,
      volume_tank: 0,
      consumption: 0,
      options: [
            {
            id: 0,
            name: "string"
            }
        ],
      min_price: 0,
      price: 0,
      description: "string",
      last_latitude: 0,
      last_longitude: 0,
      last_address_cep: "string",
      last_address_city: "string",
      last_address_uf: "string",
      last_address_street: "string",
      last_address_number: "string",
      last_address_complement: "string",
      last_address_neighborhood: "string",
      last_speed: 0,
      last_fuel_level: 0,
      last_odometer: 0,
      last_engine_hours: 0,
      registered_at_city: "string",
      registered_at_uf: "string",
      alienation_price: 0,
      alienation_payment_method: "string",
      alienation_payment_installment: 0,
      alienation_payment_installment_value: 0,
      alienation_payment_installment_total: 0,
      license_documents: [],
      salesPhotoIds: [],
      price_sale: 0,
      alienation_payment_installment_payment: 0
    };

    // Etapa 1: Criar veículo básico
    this.vehiclesService.create(vehicleData).subscribe({
      next: (response: any) => {
        
        let vehicle = response;
        
        if (response && response.data) {
          vehicle = response.data;
        }
        
        if (!vehicle || (!vehicle.id && !vehicle.ID)) {
          this.isLoading = false;
          this.snackNotifyService.error('Erro: Veículo criado mas sem ID válido', { duration: 6000 });
          return;
        }
        
        if (!vehicle.id && vehicle.ID) {
          vehicle.id = vehicle.ID;
        }
        
        this.updateVehicleFromBrasilCredit(vehicle);
      },
      error: (error) => {
        this.isLoading = false;
        let errorMessage = 'Erro ao criar veículo. Tente novamente.';
        
        if (error?.error?.message) {
          errorMessage = error.error.message;
        } else if (error?.message) {
          errorMessage = error.message;
        }
        
        if (errorMessage.toLowerCase().includes('placa') || 
            errorMessage.toLowerCase().includes('license_plate') ||
            errorMessage.toLowerCase().includes('duplicate')) {
          errorMessage = `A placa ${plateValue} já está cadastrada no sistema.`;
        }
        
        this.snackNotifyService.error(errorMessage, { duration: 6000 });
      }
    });
  }

  /**
   * 🎯 Atualiza dados do veículo via integração BrasilCredit
   */
  private updateVehicleFromBrasilCredit(vehicle: any): void {
    let vehicleId = vehicle?.id || vehicle?.ID;
    
    if (!vehicleId) {
      this.isLoading = false;
      this.snackNotifyService.error('Erro: ID do veículo não encontrado para integração', { duration: 6000 });
      return;
    }
    
    this.integrationService.getIntegrationsByType('BrasilCredit').subscribe({
      next: (response: any) => {
        if (response?.data?.length > 0) {
          const integration = response.data[0];
          if (!integration?.id) {
            this.isLoading = false;
            this.snackNotifyService.error('Erro: ID da integração não encontrado', { duration: 6000 });
            return;
          }
          
          const vehicleIdNum = parseInt(vehicleId.toString());
          const integrationIdNum = parseInt(integration.id.toString());
          
            if (isNaN(vehicleIdNum) || isNaN(integrationIdNum)) {
            this.isLoading = false;
            this.snackNotifyService.error('Erro: IDs inválidos para integração', { duration: 6000 });
            return;
          }
          
          this.vehiclesService.updateFromIntegration(
            vehicleIdNum, 
            integrationIdNum, 
            [vehicle]
          ).subscribe({
            next: (updatedVehicle) => {
              this.isLoading = false;
              this.snackNotifyService.success(
                `Veículo ${vehicle.license_plate} criado e atualizado com sucesso!`, 
                { duration: 4000 }
              );
              
              this.dialogRef.close({
                action: 'created',
                vehicle: updatedVehicle || vehicle
              });
            },
            error: (integrationError) => {
              this.isLoading = false;
              this.snackNotifyService.warning(
                `Veículo ${vehicle.license_plate} criado, mas não foi possível atualizar dados via BrasilCredit.`, 
                { duration: 6000 }
              );
              
              this.dialogRef.close({
                action: 'created',
                vehicle: vehicle
              });
            }
          });
        } else {
          this.isLoading = false;
          
          this.snackNotifyService.warning(
            `Veículo ${vehicle.license_plate} criado, mas integração BrasilCredit não está disponível.`, 
            { duration: 6000 }
          );
          
          this.dialogRef.close({
            action: 'created',
            vehicle: vehicle
          });
        }
      },
      error: (error) => {
        this.isLoading = false;
        
        this.snackNotifyService.warning(
          `Veículo ${vehicle.license_plate} criado, mas não foi possível conectar com BrasilCredit.`, 
          { duration: 6000 }
        );
        
        this.dialogRef.close({
          action: 'created',
          vehicle: vehicle
        });
      }
    });
  }

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

  /**
   * 🎯 Verifica se o formulário tem erros para exibir
   */
  get hasPlateError(): boolean {
    const plateControl = this.vehicleForm.get('license_plate');
    return !!(plateControl?.errors && plateControl?.touched);
  }

  /**
   * 🎯 Retorna a mensagem de erro da placa
   */
  get plateErrorMessage(): string {
    const plateControl = this.vehicleForm.get('license_plate');
    
    if (plateControl?.errors?.['required']) {
      return 'A placa é obrigatória';
    }
    
    if (plateControl?.errors?.['invalidPlate']) {
      return 'Formato inválido. Use ABC-1234 (antigo) ou ABC-1D23 (Mercosul)';
    }
    
    if (plateControl?.errors?.['minlength'] || plateControl?.errors?.['maxlength']) {
      return 'A placa deve ter entre 7 e 8 caracteres';
    }
    
    return '';
  }
}
