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 { MatSelectModule } from '@angular/material/select';
import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
import { switchMap, finalize } from 'rxjs/operators';

import { CustomerService } from '../../customer.service';
import { SnackNotifyService } from '../../../../shared/components/snack-notify/snack-notify.service';
import { PersonService } from '../../../../shared/services/person.service';
import { CnpjService } from '../../../../shared/services/cnpj.service';
import { Customer } from '../../customer.interface';
import { Person } from '../../../../shared/interfaces/person.interface';
/**
 * 👥 CustomerCreateModalComponent - Modal para Cadastro Rápido de Cliente
 * 
 * ✨ Funcionalidades:
 * - Seleção entre pessoa física (CPF) ou jurídica (CNPJ)
 * - Busca automática de dados nas APIs (PersonService e CnpjService)
 * - Preenchimento automático dos campos do cliente
 * - Validação de CPF e CNPJ
 * - Design moderno com ícones e animações
 */
@Component({
  selector: 'app-customer-create-modal',
  standalone: true,
  imports: [
    CommonModule,
    ReactiveFormsModule,
    MatDialogModule,
    MatButtonModule,
    MatFormFieldModule,
    MatInputModule,
    MatIconModule,
    MatSelectModule,
    MatProgressSpinnerModule
  ],
  templateUrl: './customer-create-modal.component.html',
  styleUrl: './customer-create-modal.component.scss'
})
export class CustomerCreateModalComponent implements OnInit {

  customerForm: FormGroup;
  isLoading = false;
  searchingData = false;
  customerType: 'Individual' | 'Business' = 'Individual';
  foundData: any = null;
  person : Person = {} as Person;
  customer : Customer = {} as Customer;

  // ✅ Opções de segmento para o select
  segmentOptions = [
    { value: 'Drinks', label: 'Drinks' },
    { value: 'Medicines', label: 'Medicines' },
    { value: 'Marketplaces', label: 'Marketplaces' },
    { value: 'Others', label: 'Others' }
  ];

  constructor(
    private fb: FormBuilder,
    private customerService: CustomerService,
    private personService: PersonService,
    private cnpjService: CnpjService,
    private snackNotifyService: SnackNotifyService,
    private dialogRef: MatDialogRef<CustomerCreateModalComponent>,
    @Inject(MAT_DIALOG_DATA) public data: any
  ) {
    this.customerForm = this.createForm();
  }

  ngOnInit(): void {
    // Foco automático no campo de tipo
    setTimeout(() => {
      const typeField = document.querySelector('mat-select') as HTMLElement;
      if (typeField) {
        typeField.focus();
      }
    }, 300);
  }

  /**
   * 📝 Cria o formulário reativo
   */
  private createForm(): FormGroup {
    return this.fb.group({
      type: ['fisica', [Validators.required]],
      document: ['', [Validators.required, Validators.minLength(11)]],
      name: ['', [Validators.required, Validators.minLength(2)]],
      email: ['', [Validators.required, Validators.email]],
      phone: [''],
      notes: [''],
      segment: [[], [Validators.required]], // ✅ Array obrigatório para segmentos
      code: ['', [Validators.required]], // ✅ Código obrigatório
      personId: [''],
      id: ['']
    });
  }

  /**
   * 🔄 Altera o tipo de cliente (física/jurídica)
   */
  onTypeChange(type: 'Individual' | 'Business'): void {
    this.customerType = type;
    this.foundData = null;
    
    // Limpar campo de documento e ajustar validações
    const documentControl = this.customerForm.get('document');
    if (documentControl) {
      documentControl.setValue('');
      
      if (type === 'Individual') {
        documentControl.setValidators([Validators.required, Validators.minLength(11), Validators.maxLength(14)]);
      } else {
        documentControl.setValidators([Validators.required, Validators.minLength(14), Validators.maxLength(18)]);
      }
      documentControl.updateValueAndValidity();
    }

    // Limpar outros campos
    this.customerForm.patchValue({
      name: '',
      email: '',
      phone: '',
      segment: [], // ✅ Limpar segmentos
      code: '' // ✅ Limpar código
    });
  }

  /**
   * 🔍 Busca dados do documento (CPF ou CNPJ)
   */
  onDocumentSearch(): void {
    const document = this.customerForm.get('document')?.value;
    if (!document || document.length < 11) {
      return;
    }

    this.searchingData = true;
    this.foundData = null;

    if (this.customerType === 'Individual') {
      this.searchCpfData(document);
    } else {
      this.searchCnpjData(document);
    }
  }

  /**
   * 👤 Busca dados por CPF 
   */
  private searchCpfData(cpf: string): void {
    this.personService.searchByCpf(cpf).subscribe({
      next: (response: any) => {
        this.searchingData = false;
        if (response && response.data && response.data.length > 0) {
          this.foundData = response.data[0];
          this.fillFormWithCpfData(response.data[0]);
          this.snackNotifyService.success('✅ Dados encontrados e preenchidos automaticamente!');
        } else {
          this.snackNotifyService.warning('⚠️ CPF não encontrado. Preencha os dados manualmente.');
        }
      },
      error: (error: any) => {
        this.searchingData = false;
        console.error('Erro ao buscar CPF:', error);
        this.snackNotifyService.warning('⚠️ Erro na busca. Preencha os dados manualmente.');
      }
    });
  }

  /**
   * 🏢 Busca dados por CNPJ
   */
  private searchCnpjData(cnpj: string): void {
    this.personService.searchByCnpj(cnpj).subscribe({
      next: (response: any) => {
        this.searchingData = false;
        if (response && response.data && response.data.length > 0) {
          // this.foundData = response.data[0];
          // this.foundData.nomeFantasia = response.data[0].name;
          // this.foundData.razaoSocial = response.data[0].name;
          // this.foundData.name = response.data[0].name;
          this.fillFormWithCnpjData(response.data[0]);
          this.snackNotifyService.success('✅ Dados encontrados e preenchidos automaticamente!');
          
        } else {
          // this.snackNotifyService.warning('⚠️ CNPJ não encontrado na base de dados.');
          this.cnpjService.search(cnpj).subscribe({ 
            next: (response) => {
              this.searchingData = false;
              if (response) {
                this.foundData = response;
                this.fillFormWithCnpjData(response);
                this.snackNotifyService.success('✅ Dados da empresa encontrados e preenchidos automaticamente!');
              } else {
                this.snackNotifyService.warning('⚠️ CNPJ não encontrado. Preencha os dados manualmente.');
              }
            },
            error: (error) => {
              this.searchingData = false;
              console.error('Erro ao buscar CNPJ:', error);
              this.snackNotifyService.warning('⚠️ Erro na busca. Preencha os dados manualmente.');
            }
          });
        }
      }
    });
   
  }

  /**
   * 📋 Preenche formulário com dados do CPF
   */
  private fillFormWithCpfData(data: any): void {
    this.customerForm.patchValue({
      name: data.nome || '',
      // Outros campos serão preenchidos conforme a estrutura da API
    });
  }

  /**
   * 🏢 Preenche formulário com dados do CNPJ
   */
  private fillFormWithCnpjData(data: any): void {
    const info = this.cnpjService.extractEssentialInfo(data);
    if (info) {
      this.customerForm.patchValue({
        name: info.nomeFantasia || info.razaoSocial || info.name,
        email: info.email !== 'Não informado' ? info.email : '',
        phone: info.telefone !== 'Não informado' ? info.telefone : '',    
        personId: info.id    
        
      });
    } 
  }

  /**
   * 💾 Salva o cliente usando melhor prática Angular 19
   */
  onSave(): void {
    if (this.customerForm.invalid) {
      this.markFormGroupTouched();
      this.snackNotifyService.error('❌ Preencha todos os campos obrigatórios');
      return;
    }

    this.isLoading = true;
    const customerData = this.preparePersonData();

    const formDataCustomer = { 
      ...customerData, 
      personId: customerData.personId,
      segment: this.customerForm.get('segment')?.value || [], // ✅ Incluir segment
      code: this.customerForm.get('code')?.value || '', // ✅ Incluir code
    };

    // exist Person ?
    if(formDataCustomer.personId){
      // ✅ Operações sequenciais com switchMap - Melhor prática Angular 19
      customerData.code ? delete(formDataCustomer.code) : null;

        this.personService.update(formDataCustomer.personId, formDataCustomer).pipe(
          switchMap((personResponse: any) => {
            this.snackNotifyService.success(`✅ Pessoa "${personResponse.data?.name || personResponse.name}" criado com sucesso!`);
            this.person = personResponse.data || personResponse;
            
            // Criar cliente após sucesso da pessoa
            const customerPost: Partial<Customer> = { 
              personId : this.person.id ,
              segment  : this.customerForm.get('segment')?.value || [], // ✅ Incluir segment
              code     : this.customerForm.get('code')?.value || '', // ✅ Incluir code
            };
            // delete(customerPost.code);
            return this.customerService.create(customerPost);
          }),
          finalize(() => this.isLoading = false) // ✅ Sempre executa, independente de sucesso ou erro
        ).subscribe({
          next: (customerResponse: any) => {
            const customer = customerResponse.data || customerResponse;
            this.snackNotifyService.success(`✅ Cliente "${customer.name}" criado com sucesso!`);
            this.dialogRef.close(customer);
          },
          error: (error) => {
            console.error('Erro ao criar pessoa/cliente:', error);
            this.snackNotifyService.error('❌ Erro ao criar cliente. Tente novamente.');
          }
        });
    }else{  
       // ✅ Operações sequenciais com switchMap - Melhor prática Angular 19
        const personDataToCreate = {
          ...customerData,
          segment: this.customerForm.get('segment')?.value || [], // ✅ Incluir segment
          code: this.customerForm.get('code')?.value || '' // ✅ Incluir code
        };
        
        this.personService.create(personDataToCreate).pipe(
          switchMap((personResponse: any) => {
            this.snackNotifyService.success(`✅ Pessoa "${personResponse.data?.name || personResponse.name}" criado com sucesso!`);
            this.person = personResponse.data || personResponse;
            
            // Criar cliente após sucesso da pessoa
            const customerPost: Partial<Customer> = { personId: this.person.id };
            return this.customerService.create(customerPost);
          }),
          finalize(() => this.isLoading = false) // ✅ Sempre executa, independente de sucesso ou erro
        ).subscribe({
          next: (customerResponse: any) => {
            const customer = customerResponse.data || customerResponse;
            this.snackNotifyService.success(`✅ Cliente "${customer.name}" criado com sucesso!`);
            this.dialogRef.close(customer);
          },
          error: (error) => {
            console.error('Erro ao criar pessoa/cliente:', error);
            this.snackNotifyService.error('❌ Erro ao criar cliente. Tente novamente.');
          }
        });
    }
   
  }

  /**
   * 📋 Prepara dados do cliente para envio
   */
  private preparePersonData(): Partial<Person> {
    const formData = this.customerForm.value;

    const personData: Partial<Person> = {
      type: this.customerType ,
      name: formData.name,
      email: formData.email || '',
      phone: formData.phone || '',
      notes: formData.notes || '' ,
      segment: formData.segment || [], // ✅ Array de segmentos
      code: formData.code || '', // ✅ Código do cliente
      personId:formData.id  ||formData.personId
    };

    // Adicionar CPF ou CNPJ
    if (this.customerType === 'Individual') {
      personData.cpf = formData.document;
      delete(personData.cnpj);
    } else {
      personData.cnpj = formData.document;
      personData.gender = 'female';
      delete(personData.cpf);
    }

    // Adicionar dados extras se encontrados nas APIs
    if (this.foundData) {
      this.addFoundDataToPerson(personData);
    }

    return personData;
  }
  
  /**
   * 📊 Adiciona dados encontrados nas APIs ao cliente
   */
  private addFoundDataToPerson(customerData: Partial<Person>): void {
    if (this.customerType === 'Individual' && this.foundData) {
      // Adicionar dados do CPF se disponíveis
      // Implementar conforme estrutura da API do PersonService
    } else if (this.customerType === 'Business' && this.foundData) {
      // Adicionar dados do CNPJ
      const info = this.cnpjService.extractEssentialInfo(this.foundData);
      if (info) {
        // Extrair endereço se disponível
        const enderecoParts = info.endereco.split(', ');
        if (enderecoParts.length >= 6) {
          customerData.address_street = enderecoParts[1] || '';
          customerData.address_number = enderecoParts[2] || '';
          customerData.address_neighborhood = enderecoParts[4] || '';
          customerData.address_city = enderecoParts[5] || '';
          customerData.address_uf = enderecoParts[6] || '';
          customerData.address_cep = enderecoParts[7] || '';
          customerData.birth_date = info.dataInicioAtividade ? new Date(info.dataInicioAtividade) : new Date();
          // customerData.partners = info.socios || [];
          // customerData.shareCapital = info.capitalSocial || 0;          
          // customerData.EconomicActivityCode = info.cnaeFiscal || 0;          
          // customerData.fantasyName = info.nomeFantasia || '';
          // customerData.cnaes_secundarios = info.cnaesSecundarios || [];
          // customerData.natureza_juridica = info.naturezaJuridica || '';
          // customerData.data_situacao_cadastral = info.data_situacao_cadastral || '';
          // customerData.data_inicio_atividade = info.dataInicioAtividade || '';
          // customerData.descricao_motivo_situacao_cadastral = info.descricao_motivo_situacao_cadastral || 1;
          // customerData.descricao_identificador_matriz_filial = info.descricao_identificador_matriz_filial || '';
        }
      }
    }
  }

  /**
   * 📝 Marca todos os campos como tocados para mostrar erros
   */
  private markFormGroupTouched(): void {
    Object.keys(this.customerForm.controls).forEach(key => {
      const control = this.customerForm.get(key);
      if (control) {
        control.markAsTouched();
      }
    });
  }

  /**
   * ❌ Cancela e fecha o modal
   */
  onCancel(): void {
    this.dialogRef.close();
  }

  /**
   * 🎯 Getters para facilitar acesso aos campos do formulário
   */
  get typeControl() { return this.customerForm.get('type'); }
  get documentControl() { return this.customerForm.get('document'); }
  get nameControl() { return this.customerForm.get('name'); }
  get emailControl() { return this.customerForm.get('email'); }
  get phoneControl() { return this.customerForm.get('phone'); }
  get segmentControl() { return this.customerForm.get('segment'); }
  get codeControl() { return this.customerForm.get('code'); }

  /**
   * 📱 Formata documento conforme o tipo
   */
  formatDocument(value: string): string {
    if (!value) return '';
    
    const numbers = value.replace(/\D/g, '');
    
    if (this.customerType === 'Individual') {
      // Formato CPF: 000.000.000-00
      return numbers.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/, '$1.$2.$3-$4');
    } else {
      // Formato CNPJ: 00.000.000/0000-00
      return numbers.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/, '$1.$2.$3/$4-$5');
    }
  }

  /**
   * 🔍 Placeholder dinâmico para o campo documento
   */
  get documentPlaceholder(): string {
    return this.customerType === 'Individual' ? 'Digite o CPF' : 'Digite o CNPJ';
  }

  /**
   * 🏷️ Label dinâmico para o campo documento
   */
  get documentLabel(): string {
    return this.customerType === 'Individual' ? 'CPF' : 'CNPJ';
  }
}
