import { Component, ChangeDetectorRef } from "@angular/core";
import { CommonModule, DatePipe } from "@angular/common";

import { TitleService } from "../../shared/services/theme/title.service";
import { HeaderActionsService } from "../../shared/services/header-actions.service";
import { DriversService } from "./drivers.service";
import { Driver } from "./driver.interface";

import { TabSystemComponent } from "../../shared/components/tab-system/tab-system.component";
import { BaseDomainComponent, DomainConfig } from "../../shared/components/base-domain/base-domain.component";
import { TabFormConfig } from "../../shared/interfaces/generic-tab-form.interface";
import { TabFormConfigService } from "../../shared/components/tab-system/services/tab-form-config.service";
import { PhoneFormatter } from "../../shared/utils/phone-formatter.util";
import { ConfirmationService } from '../../shared/services/confirmation/confirmation.service';
import { PersonService } from '../../shared/services/person.service';
import { Person } from '../../shared/interfaces/person.interface';
import { VehiclesService } from "../vehicles/vehicles.service";

/**
 * 🎯 DriversComponent - Demonstração do Padrão Escalável ERP
 * 
 * Exemplo MÍNIMO de como criar domínios com BaseDomainComponent.
 * 
 * ✨ Este componente tem apenas 60 linhas úteis vs 1600+ anteriormente!
 * 
 * 🚀 Para novos domínios: copie, cole, configure getDomainConfig() e pronto!
 */
@Component({
  selector: 'app-drivers',
  standalone: true,
  imports: [CommonModule, TabSystemComponent],
  providers: [DatePipe],
  templateUrl: './drivers.component.html',
  styleUrl: './drivers.component.scss'
})
export class DriversComponent extends BaseDomainComponent<Driver> {

  constructor(
    private driversService: DriversService, // ✅ Injeção direta do service
    titleService: TitleService,
    headerActionsService: HeaderActionsService,
    cdr: ChangeDetectorRef,
    private datePipe: DatePipe,
    private tabFormConfigService: TabFormConfigService,
    private confirmationService: ConfirmationService,
    private vehiclesService: VehiclesService,
    private personService: PersonService // 🔍 Service para buscar pessoa por CPF
  ) {
    // ✅ ARQUITETURA ORIGINAL: DriversService passado diretamente
    super(titleService, headerActionsService, cdr, driversService);
    
    // 🚀 REGISTRAR configuração específica de drivers
    this.registerFormConfig();
  }
 
  /**
   * 🎯 NOVO: Registra a configuração de formulário específica para drivers
   * Chamado no construtor para garantir que está disponível
   */
  private registerFormConfig(): void {
    this.tabFormConfigService.registerFormConfig('driver', () => this.getFormConfig());
  }

  // ========================================
  // 🎯 ÚNICA CONFIGURAÇÃO NECESSÁRIA
  // ========================================
  protected override getDomainConfig(): DomainConfig {
    return {
      domain: 'driver',
      title: 'Motoristas',
      entityName: 'motorista',
      subTabs: ['dados', 'photos', 'documents', 'fines', 'contract'], // ✅ Atualizado: adicionado 'endereco' dinâmico
      showDashboardTab: true, // ✅ NOVO: Habilitar aba Dashboard
      dashboardConfig: {
        title: 'Dashboard de Motoristas',
        showKPIs: true,
        showCharts: true,
        showRecentItems: true,
        customKPIs: [
          {
            id: 'drivers-with-license',
            label: 'Com CNH Válida',
            value: '85%',
            icon: 'fas fa-id-card',
            color: 'success',
            trend: 'up',
            change: '+3%'
          }
        ]
      },
      filterConfig: { 
        fieldsSearchDefault: ['name'],
        // searchConfig: {
        //   minSearchLength: 3,
        //   debounceTime: 500,
        //   preserveSearchOnDataChange: true
        // },
        dateRangeFilter: false,
        companyFilter: false, 
        specialFilters: [ 
          {
            id: 'name',
            label: 'Nome do Motorista',
            type: 'custom-select',
          }
        ]
      },
      columns: [      
        { field: "id", header: "Id", sortable: true, filterable: true },
        { field: "name", header: "Nome", sortable: true, filterable: true, search: true, searchType: "text" },

        { field: "driver_license_number",
          header: "Número da CNH",
          filterField: "licenseNumber",
          sortable: true,
          filterable: true,
          search: true,
          searchType: "text"
        },
        { field: "cpf",
          header: "CPF",
          sortable: true,
          filterable: true,
          search: true,
          searchType: "date"
        },
        {
          field: "locationPersonName",
          header: "Local de Operação",
          sortable: true, 
          filterable: true , 
          search: true, 
          searchType: "text" 
        },

        { field: "email", header: "Email", sortable: true, filterable: true },
        {
          field: "contract_type",
          header: "Tipo de contrato",
          sortable: true,
          filterable: true,
          allowHtml: true,
          search: true,
          searchType: "select",
          searchOptions:[
            { value: 'clt', label: 'CLT' },
            { value: 'freelancer', label: 'Freelancer' },
            { value: 'outsourced', label: 'Terceirizado' },
            { value: 'rentals', label: 'Aluguel' },
            { value: 'fix', label: 'Frota Fixa' },
            { value: 'aggregated', label: 'Agregado' },
            { value: 'pending', label: 'Pendente' }
          ],
          label: (value: any) => {
            if (!value) return '<span class="status-badge status-unknown">Não informado</span>';
            
            const statusConfig: { [key: string]: { label: string, class: string } } = {
              'freelancer': { label: 'Freelancer', class: 'status-freelancer' },
              'outsourced': { label: 'Terceirizado', class: 'status-outsourced' },
              'rentals': { label: 'Aluguel', class: 'status-rentals' },
              'fix': { label: 'Frota Fixa', class: 'status-fix' },
              'aggregated': { label: 'Agregado', class: 'status-aggregated' },
              'pending': { label: 'Pendente', class: 'status-pending' },
              'clt': { label: 'CLT', class: 'status-clt' },
            };    
             
            
            const config = statusConfig[value.toLowerCase()] || { label: value, class: 'status-unknown' };
            return `<span class="status-badge ${config.class}">${config.label}</span>`;
          }
        },
        {
          field: "status",
          header: "Status",
          sortable: true,
          filterable: true,
          allowHtml: true,
          search: true,
          searchType: "select",
          searchOptions: [            
            { value: 'active', label: 'Ativo' },
            { value: 'inactive', label: 'Inativo' },
            { value: 'pending', label: 'Pendente' },
            { value: 'suspended', label: 'Suspenso' },
            { value: 'blocked', label: 'Bloqueado' },
            { value: 'verified', label: 'Verificado' },
            { value: 'unverified', label: 'Não Verificado' },
            { value: 'pending_verification', label: 'Pendente de Verificação' }
          ],
          label: (value: any) => {
            if (!value) return '<span class="status-badge status-unknown">Não informado</span>';
            
            const statusConfig: { [key: string]: { label: string, class: string } } = {
              'active': { label: 'Ativo', class: 'status-active' },
              'inactive': { label: 'Inativo', class: 'status-inactive' },
              'pending': { label: 'Pendente', class: 'status-pending' },
              'suspended': { label: 'Suspenso', class: 'status-suspended' },
              'blocked': { label: 'Bloqueado', class: 'status-blocked' },
              'verified': { label: 'Verificado', class: 'status-verified' },
              'unverified': { label: 'Não Verificado', class: 'status-unverified' },
              'pending_verification': { label: 'Pendente de Verificação', class: 'status-pending-verification' },
            };    
             
            
            const config = statusConfig[value.toLowerCase()] || { label: value, class: 'status-unknown' };
            return `<span class="status-badge ${config.class}">${config.label}</span>`;
          }
        }, 
        {
          field: "birth_date",
          header: "Data de aniversário",
          sortable: true,
          filterable: true,
          label: (date: any) => this.datePipe.transform(date,"dd/MM/yyyy") || "-"
        },
        { 
          field: "phone", 
          header: "Telefone", 
          sortable: true, 
          filterable: true,
          label: (phone: any) => PhoneFormatter.format(phone),
          format: "phone"
        },
        { 
          field: "gender", 
          header: "Gênero", 
          sortable: true, 
          filterable: true,
          label: (value: any) => {
            if (!value) return '-';
            
            const genderLabels: { [key: string]: string } = {
              'male': 'Masculino',
              'female': 'Feminino', 
              'other': 'Outro'
            };
            
            return genderLabels[value.toLowerCase()] || value;
          }
        },
        // { field: "type", 
        //   header: "Tipo", 
        //   sortable: true, 
        //   filterable: true 
        // },
        {
          field: "driver_license_category",
          header: "Categoria da CNH",
          sortable: true,
          filterable: true,
          allowHtml: true, // ✅ PERMITE RENDERIZAÇÃO DE HTML PARA BADGES
          label: (value: any) => {
            if (!value) {
              return '<span class="category-badge category-empty">CNH Obrigatória</span>';
            }
            
            // Se for array, cria badges coloridos para todos os itens
            if (Array.isArray(value)) {
              // ⚠️ ALERTA: Array vazio ou com strings vazias - CNH obrigatória
              const validCategories = value.filter(category => 
                typeof category === 'string' && category.trim() !== ''
              );
              
              if (validCategories.length === 0) {
                return '<span class="category-badge category-empty">CNH Obrigatória</span>';
              }
              
              return validCategories.map(category => {
                const categoryLower = category.toLowerCase();
                const categoryUpper = category.toUpperCase();
                return `<span class="category-badge category-${categoryLower}">${categoryUpper}</span>`;
              }).join('');
            }
            
            // Se for string, cria um badge único colorido
            if (typeof value === 'string') {
              // ⚠️ ALERTA: String vazia - CNH obrigatória
              if (value.trim() === '') {
                return '<span class="category-badge category-empty">CNH Obrigatória</span>';
              }
              
              const categoryLower = value.toLowerCase();
              const categoryUpper = value.toUpperCase();
              return `<span class="category-badge category-${categoryLower}">${categoryUpper}</span>`;
            }
            
            // ⚠️ ALERTA: Valor inválido - CNH obrigatória
            return '<span class="category-badge category-empty">CNH Obrigatória</span>';
          }
        },
        {
            field: "address_city",  
            header: "Cidade",
            sortable: true,
            filterable: true
        },            
        {
          field: "address_uf",
          header: "Estado",
          sortable: true,
          filterable: true
        },
        {
          field: "driver_license_due_date",
          header: "Vencimento da CNH",
          sortable: true,
          filterable: true,
          label: (date: any) => this.datePipe.transform(date, "dd/MM/yyyy") || "-"
        }
      ],
      // ✨ Configuração do Side Card - Resumo do Veículo do Motorista
      sideCard: {
        enabled: true,
        title: "Resumo do Motorista",
        position: "right",
        width: "400px",
        component: "summary",
        data: {
          imageField: "photoIds", // Campo da imagem do veículo
          displayFields: [
            {
              key: "driver_license_due_date",
              label: "Vencimento da CNH",
              type: "text",
              format: "date"
            },
            {
              key: "name",
              label: "Motorista",
              type: "text"
            },
            {
              key: "contract_type",
              label: "Contrato",
              type: "text",
              allowHtml: true,
              format: (value: any) => {
                if (!value) return '<span class="status-badge status-unknown">Não informado</span>';
                
                const statusConfig: { [key: string]: { label: string, class: string } } = {
                  'freelancer': { label: 'Freelancer', class: 'status-freelancer' },
                  'outsourced': { label: 'Terceirizado', class: 'status-outsourced' },
                  'rentals': { label: 'Aluguel', class: 'status-rentals' },
                  'fix': { label: 'Frota Fixa', class: 'status-fix' },
                  'aggregated': { label: 'Agregado', class: 'status-aggregated' },
                  'pending': { label: 'Pendente', class: 'status-pending' },
                  'clt': { label: 'CLT', class: 'status-clt' },
                };
                
                const config = statusConfig[value.toLowerCase()] || { label: value, class: 'status-unknown' };
                return `<span class="status-badge ${config.class}">${config.label}</span>`;
              }
            },
            {
              key: "driver_license_category",
              label: "Categoria da CNH",
              type: "badge",
              format: "array-all-uppercase" // ✅ MUDADO: Mostra todos os itens do array
            },
            {
              key: "phone",
              label: "Telefone",
              type: "text",
              format: "phone"
            },
            {
              key: "gender",
              label: "Gênero",
              type: "text",
              format: "gender"
            },
            {
              key: "status",
              label: "Status",
              type: "status"
            },

          ],
          statusField: "status",
          statusConfig: {
            "inactive": {
              label: "Inativo",
              color: "#f8d7da", 
              textColor: "#721c24",
              icon: "fa-pause-circle"
            },
            "active": {
              label: "Em atividade",
              color: "#d4edda",
              textColor: "#155724",
              icon: "fa-check-circle"
            },
            "pending": {
              label: "Pendente",
              color: "#f8d7da",
              textColor: "#721c24", 
              icon: "fa-check-circle"
            },
            "suspended": {
              label: "Inativo",
              color: "#f8d7da",
              textColor: "#721c24",
              icon: "fa-pause-circle"
            },
            "blocked": {
              label: "Bloqueado",
              color: "#f8d7da",
              textColor: "#721c24",
              icon: "fa-ban"
            },
            "verified": {
              label: "Verificado",
              color: "#d4edda",
              textColor: "#155724",
              icon: "fa-check-circle"
            },
            "unverified": {
              label: "Não Verificado",
              color: "#f8d7da",
              textColor: "#721c24",
              icon: "fa-times-circle"
            },
            "pendingVerification": {
              label: "Pendente de Verificação",
              color: "#d4edda",
              textColor: "#155724",
              icon: "fa-check-circle"
            }
          }
        }
      }
    };
  }

  // ========================================
  // 📋 CONFIGURAÇÃO COMPLETA DO FORMULÁRIO DE DRIVERS
  // ========================================
  /**
   * 🎯 NOVA ARQUITETURA: Configuração específica do formulário de motoristas
   * 
   * ✅ RESPONSABILIDADE DO DOMÍNIO:
   * - Campos específicos da entidade
   * - Sub-abas e sua configuração
   * - Validações e máscaras
   * - Comportamentos específicos (onValueChange)
   * 
   * ✅ BENEFÍCIOS:
   * - TabFormConfigService não fica gigantesco
   * - Cada domínio gerencia sua própria configuração
   * - Facilita manutenção e escalabilidade
   * - Registry Pattern garante que a configuração seja encontrada
   */
  getFormConfig(): TabFormConfig {
    return {
      title: 'Motorista: {{name}}',
      titleFallback: 'Novo Motorista',
      entityType: 'driver',
      fields: [
        // {
        //   key: 'personId',
        //   label: 'Person ID (Interno)',
        //   type: 'text', 
        //   required: false,
        //   readOnly: true, 
        //   placeholder: 'ID interno da pessoa (preenchido automaticamente)'
        // }
      ],
      submitLabel: 'Salvar Motorista',
      showCancelButton: true,
      subTabs: [
        {
          id: 'dados',
          label: 'Dados Básicos',
          icon: 'fa-user',
          enabled: true,
          order: 1,
          templateType: 'fields', // 🎯 Renderiza campos específicos
          requiredFields: ['name', 'cpf'],
          fields: [
            // Campos específicos da aba de dados
            {
              key: 'name',
              label: 'Nome Completo',
              type: 'text',
              required: true,
              placeholder: 'Nome completo do motorista'
            },
            {
              key: 'cpf',
              label: 'CPF',
              type: 'text',
              mask: '000.000.000-00',
              placeholder: '000.000.000-00',
              onValueChange: (value: string, formGroup: any) => {
                // 🔍 Busca automática de pessoa por CPF quando valor é alterado
                const cleanCpf = value?.replace(/\D/g, '') || '';
                if (cleanCpf.length === 11) {
                  this.searchPersonByDocument(value, 'cpf', formGroup);
                }
              }
            },
            // {
            //   key: 'cnpj',
            //   label: 'CNPJ',
            //   type: 'text',
            //   mask: '00.000.000/0000-00',
            //   placeholder: '00.000.000/0000-00',
            //   onValueChange: (value: string, formGroup: any) => {
            //     // 🔍 Busca automática de pessoa por CNPJ quando valor é alterado
            //     const cleanCnpj = value?.replace(/\D/g, '') || '';
            //     if (cleanCnpj.length === 14) {
            //       this.searchPersonByDocument(value, 'cnpj', formGroup);
            //     }
            //   }
            // },
            {
              key: 'birth_date',
              label: 'Data de Nascimento',
              type: 'date'
            },
            {
              key: 'gender',
              label: 'Gênero',
              type: 'select',
              required: false,
              options: [
                { value: 'male', label: 'Masculino' },
                { value: 'female', label: 'Feminino' },
                { value: 'other', label: 'Outro' }
              ]
            },
            {
              key: 'email',
              label: 'Email',
              type: 'email',
              placeholder: 'email@exemplo.com'
            },
            {
              key: 'phone',
              label: 'Telefone',
              type: 'tel',
              mask: '(00) 00000-0000',
              placeholder: '(00) 00000-0000'
            },
            {
              key: 'father_name',
              label: 'Nome do Pai',
              type: 'text',
              placeholder: 'Nome completo do pai'
            },
            {
              key: 'mother_name',
              label: 'Nome da Mãe',
              type: 'text',
              placeholder: 'Nome completo da mãe'
            },
            // {
            //   key: 'pix_key',
            //   label: 'Chave PIX',
            //   type: 'text',
            //   placeholder: 'CPF, email, telefone ou chave aleatória'
            // },
            // {
            //   key: 'type',
            //   label: 'Tipo de Pessoa',
            //   type: 'select',
            //   required: true,
            //   options: [
            //     { value: 'Individual', label: 'Pessoa Física' },
            //     { value: 'Business', label: 'Pessoa Jurídica' }
            //   ]
            // },
            // Campos de endereço (serão renderizados na sub-aba endereço via AddressFormComponent)
            {
              key: 'address_cep',
              label: 'CEP',
              type: 'text',
              required: false,
              mask: '00000-000',
              placeholder: '00000-000',
              onValueChange: (value: string, formGroup: any) => {
                // Busca automática de CEP quando valor é alterado
                const cleanCep = value?.replace(/\D/g, '') || '';
                if (cleanCep.length === 8) {
                  // O handleCepChange será chamado automaticamente pelo generic-tab-form
                  // através do setupFormChangeDetection
                }
              }
            },
            {
              key: 'address_uf',
              label: 'Estado',
              type: 'text',
              required: false,
              readOnly: true, // 🔒 Campo somente leitura - preenchido automaticamente pelo CEP
              placeholder: 'Estado (preenchido automaticamente)'
            },
            {
              key: 'address_city',
              label: 'Cidade',
              type: 'text',
              required: false,
              readOnly: true, // 🔒 Campo somente leitura - preenchido automaticamente pelo CEP
              placeholder: 'Cidade (preenchida automaticamente)'
            },
            {
              key: 'address_neighborhood',
              label: 'Bairro',
              type: 'text',
              required: false,
              readOnly: true, // 🔒 Campo somente leitura - preenchido automaticamente pelo CEP
              placeholder: 'Bairro (preenchido automaticamente)'
            },
            {
              key: 'address_street',
              label: 'Rua',
              type: 'text',
              required: false,
              readOnly: true, // 🔒 Campo somente leitura - preenchido automaticamente pelo CEP
              placeholder: 'Rua (preenchida automaticamente)'
            },
            {
              key: 'address_number',
              label: 'Número',
              type: 'text',
              required: false,
              placeholder: 'Número da residência'
            },
            {
              key: 'address_complement',
              label: 'Complemento',
              type: 'text',
              required: false,
              placeholder: 'Apto, bloco, etc. (opcional)'
            },
            {
              key: 'status',
              label: 'Status do Motorista',
              type: 'select',
              required: true,
              defaultValue: 'pending',
              options: [
                { value: 'active', label: 'Ativo' },
                { value: 'inactive', label: 'Inativo' },
                { value: 'pending', label: 'Pendente' },
                { value: 'suspended', label: 'Suspenso' },
                { value: 'blocked', label: 'Bloqueado' },
                { value: 'verified', label: 'Verificado' },
                { value: 'unverified', label: 'Não Verificado' },
                { value: 'pendingVerification', label: 'Pendente de Verificação' }
              ]
            }           
          ]
        },
        {
          id: 'documents',
          label: 'Documentos',
          icon: 'fa-file-alt',
          enabled: true,
          order: 3, // ✅ Ajustado: era order 2, agora é 3
          // templateType: 'custom', // 🎯 Em desenvolvimento
          // comingSoon: true,
          templateType: 'fields',
          requiredFields: [],
          fields: [
            {
              key: 'driver_license_number',
              label: 'Número da CNH',
              type: 'text',
              required: true,
              placeholder: 'Número da carteira de habilitação'
            },
            {
              key: 'driver_license_category',
              label: 'Categorias da CNH',
              type: 'multi-select',
              required: true,
              placeholder: 'Selecione as categorias da CNH...',
              options: [
                { value: 'A', label: 'A - Motocicletas' },
                { value: 'B', label: 'B - Carros' },
                { value: 'C', label: 'C - Caminhões' },
                { value: 'D', label: 'D - Ônibus' },
                { value: 'E', label: 'E - Carretas' }
              ]
            },
            {
              key: 'driver_license_issue_date',
              label: 'Data de Emissão da CNH',
              type: 'date',
              required: true
            },
            {
              key: 'driver_license_first_issue_date',
              label: 'Data da Primeira Emissão da CNH',
              type: 'date',
              required: true
            },
            {
              key: 'driver_license_due_date',
              label: 'Vencimento da CNH',
              type: 'date',
              required: true
            },
          ]
        },
        {
          id: 'fines',
          label: 'Multas',
          icon: 'fa-exclamation-triangle',
          enabled: true,
          order: 4, // ✅ Ajustado: era order 3, agora é 4
          // templateType: 'custom', // 🎯 Em desenvolvimento          
          comingSoon: true,
          requiredFields: []
        },
        {
          id: 'contract',
          label: 'Contrato',
          icon: 'fa-exclamation-triangle',
          enabled: true,
          order: 4, // ✅ Ajustado: era order 3, agora é 4
          // templateType: 'custom', // 🎯 Em desenvolvimento
          // comingSoon: true,
          templateType: 'fields',
          requiredFields: [],
          fields: [
            {
              key: 'locationPersonId',
              label: '',
              required: false,
              labelField: 'locationPersonName',
              type: 'remote-select',
              remoteConfig: {
                service: this.personService,
                searchField: 'name',
                displayField: 'name',
                valueField: 'id',
                modalTitle: 'Selecione o local de alocação',
                placeholder: 'Digite o nome do local de alocação...'
              }
            },
            {
              key: 'contract_type',
              label: '',
              type: 'select',
              required: false,
              defaultValue: 'pending',
              options: [
                { value: 'clt', label: 'CLT' },
                { value: 'freelancer', label: 'Freelancer' },
                { value: 'outsourced', label: 'Terceirizado' },
                { value: 'rentals', label: 'Rentals' },
                { value: 'fix', label: 'Frota Fixa' },
                { value: 'aggregated', label: 'Agregado' },
                { value: 'pending', label: 'Pendente' }
              ]
            },
          ]
        },
        
        {
          id: 'photos',
          label: 'Fotos',
          icon: 'fa-camera',
          enabled: true,
          order: 3,
          templateType: 'fields', // 🎯 Renderiza campos específicos
          requiredFields: ['photoIds'],
          fields: [
            {
              key: 'photoIds',
              label: 'Fotos do Motorista',
              type: 'send-image',
              required: false,
              
              imageConfiguration: {
                maxImages: 10,
                maxSizeMb: 5,
                allowedTypes: ['image/jpeg', 'image/png', 'image/webp'],
                existingImages: [] // Será preenchido dinamicamente
              }
            }
          ]
        },
      ]
    };
  }



  // ========================================
  // 🎨 DADOS PARA NOVOS MOTORISTAS (OPCIONAL)
  // ========================================
  protected override getNewEntityData(): Partial<Driver> {
    return {
      name: '',
      email: '',
      gender: '',
      contract_type: '',
      type: 'Individual',
      driver_license_category: [], // Array vazio para múltiplas categorias
      driver_license_due_date: '',
      personId: undefined, 
    };
  }

  // ========================================
  // 🔍 BUSCA DE PESSOA POR DOCUMENTO (CPF OU CNPJ)
  // ========================================
  /**
   * 🎯 Busca pessoa por documento (CPF ou CNPJ) e preenche automaticamente os campos do formulário
   * Usado quando o usuário digita um documento no campo CPF ou CNPJ do novo motorista
   * 
   * @param document CPF ou CNPJ da pessoa (pode incluir formatação)
   * @param documentType Tipo do documento: 'cpf' ou 'cnpj'
   * @param formGroup FormGroup do formulário para preenchimento automático
   */
  searchPersonByDocument(document: string, documentType: 'cpf' | 'cnpj', formGroup: any): void {
    // Remove formatação do documento
    const cleanDocument = document.replace(/\D/g, '');
    
    // Valida se documento está completo
    const isValidLength = (documentType === 'cpf' && cleanDocument.length === 11) || 
                         (documentType === 'cnpj' && cleanDocument.length === 14);
    
    if (!isValidLength) {
      return;
    }

    this.personService.searchByDocument(cleanDocument, documentType).subscribe({
      next: (response) => {
        // Se encontrou pessoa, preenche os campos automaticamente
        if (response.data && response.data.length > 0) {
          const person: Person = response.data[0];
          
          const driverData = this.mapPersonToDriver(person);
          
          // 📝 Preenche o formulário com os dados encontrados
          Object.keys(driverData).forEach(key => {
            const driverKey = key as keyof typeof driverData;
            const value = driverData[driverKey];
            if (formGroup.get(key) && value !== null && value !== undefined) {
              formGroup.get(key).setValue(value);
            }
          });
        } else {
        }
      },
      error: (error) => {
        console.error(`❌ Erro ao buscar pessoa por ${documentType.toUpperCase()}:`, error);
      }
    });
  }

  /**
   * 🔄 Mapeia dados de Person para Driver
   * Converte os campos da interface Person para os campos esperados na interface Driver
   * Inclui o person_id para referência
   * 
   * @param person Dados da pessoa encontrada
   * @returns Dados formatados para o driver
   */
  private mapPersonToDriver(person: Person): Partial<Driver> {
    return {
      // 🆔 Mantém referência à pessoa original (salvo no backend, não mostrado no front)
      personId: person.id, 
      
      // 👤 Dados pessoais
      name: person.name || '',
      email: person.email || '',
      cpf: person.cpf || '',
      cnpj: person.cnpj || '',
      birth_date: person.birth_date.toISOString() || '',
      gender: person.gender || '',
      phone: person.phone || '',
      father_name: person.father_name || '',
      mother_name: person.mother_name || '',
      pix_key: person.pix_key || '',
      
      // 🏠 Dados de endereço
      address_street: person.address_street || '',
      address_city: person.address_city || '',
      address_cep: person.address_cep || '',
      address_uf: person.address_uf || '',
      address_number: person.address_number || '',
      address_complement: person.address_complement || '',
      address_neighborhood: person.address_neighborhood || '',
      
      // 📝 Observações
      notes: person.notes || '',
      
      // 📸 Fotos (converte number[] para string[])
      photoIds: person.photoIds?.map(id => id.toString()) || [],
      
      // 🚛 Campos específicos de motorista (mantém vazios para preenchimento manual)
      type: 'Individual',
      contract_type: '',
      driver_license_category: [],
      driver_license_due_date: '',
      driver_license_issue_date: '',
      driver_license_first_issue_date: '',
      driver_license_number: '',
      licenseIds: []
    };
  }
  
}
