// src/client/entities/contractor/model/useContractorForm.ts
 // Hook for managing contractor form state and validation

 import { ref, computed } from 'vue';
 import type {
   ContractorUnifiedEntry,
   ContractorCreateRequest,
   ContractorUpdateRequest,
   ContractorResponsibleManager,
 } from '@shared/contracts/contractors';
 import { formatPhoneNumberAsYouType, isValidPhoneNumber } from '@shared/utils/formatters';

 type ContractorFormData = {
   name: string;
   category: string;
   contractNumber: string;
   phone: string;
   email: string;
   webLink: string;
   responsibleManagers: Array<{
     name: string;
     phone: string;
     email: string;
   }>;
   comment: string;
 };

 function createEmptyResponsibleManager(): { name: string; phone: string; email: string } {
   return {
     name: '',
     phone: '',
     email: '',
   };
 }

 function mapResponsibleManagersFromItem(initialItem: ContractorUnifiedEntry | null): ContractorFormData['responsibleManagers'] {
   const source = initialItem?.responsibleManagers?.length
     ? initialItem.responsibleManagers
     : (initialItem?.managerName
       ? [{
         name: initialItem.managerName,
         phone: initialItem.managerPhone || null,
         email: initialItem.managerEmail || null,
       }]
       : []);

   return source.map((manager) => ({
     name: manager.name || '',
     phone: manager.phone?.startsWith('+') ? manager.phone.substring(1) : (manager.phone || ''),
     email: manager.email || '',
   }));
 }

 export function useContractorForm(initialItem: ContractorUnifiedEntry | null = null) {
   const formData = ref<ContractorFormData>({
     name: initialItem?.name || '',
     category: initialItem?.category || '',
     contractNumber: initialItem?.contractNumber || '',
     // Strip leading + from phone if present (to avoid double + with visual prefix)
     phone: initialItem?.phone?.startsWith('+')
      ? initialItem.phone.substring(1)
       : (initialItem?.phone || ''),
     email: initialItem?.email || '',
     webLink: initialItem?.webLink || '',
     responsibleManagers: mapResponsibleManagersFromItem(initialItem),
     comment: initialItem?.comment || '',
   });

  const errors = ref<Record<string, string>>({});

  const isEditing = computed(() => !!initialItem);

  /**
   * Handle phone input - clean and format as user types
   * Takes event and field name to support both phone and managerPhone fields
   */
   function handlePhoneInput(event: Event, fieldName: 'phone'): void {
     const target = event.target as HTMLInputElement;
     // Remove all "+" symbols first to ensure complete cleanup
     const valueWithoutPlus = target.value.replace(/\+/g, '');
     // Then format cleaned value
     formData.value[fieldName] = formatPhoneNumberAsYouType(valueWithoutPlus);
   }

   function handleResponsiblePhoneInput(event: Event, index: number): void {
     const target = event.target as HTMLInputElement;
     const valueWithoutPlus = target.value.replace(/\+/g, '');
     if (!formData.value.responsibleManagers[index]) {
       return;
     }
     formData.value.responsibleManagers[index].phone = formatPhoneNumberAsYouType(valueWithoutPlus);
   }

   function addResponsibleManager(): void {
     formData.value.responsibleManagers.push(createEmptyResponsibleManager());
   }

   function removeResponsibleManager(index: number): void {
     formData.value.responsibleManagers.splice(index, 1);
   }

  function validateForm(): boolean {
    errors.value = {};

    if (!formData.value.name.trim()) {
      errors.value.name = 'Название обязательно';
    }

    if (!formData.value.category.trim()) {
      errors.value.category = 'Категория обязательна';
    }

    if (!formData.value.phone.trim()) {
      errors.value.phone = 'Телефон обязателен';
    } else if (!isValidPhoneNumber(formData.value.phone)) {
      errors.value.phone = 'Номер телефона должен содержать от 10 до 15 цифр';
    }

    if (formData.value.email && !isValidEmail(formData.value.email)) {
      errors.value.email = 'Некорректный email';
    }

    formData.value.responsibleManagers.forEach((manager, index) => {
      const hasAnyValue = !!(manager.name.trim() || manager.phone.trim() || manager.email.trim());

      if (!hasAnyValue) {
        return;
      }

      if (!manager.name.trim()) {
        errors.value[`responsibleManagers.${index}.name`] = 'Имя ответственного обязательно';
      }

      if (manager.phone.trim() && !isValidPhoneNumber(manager.phone.trim())) {
        errors.value[`responsibleManagers.${index}.phone`] = 'Номер телефона должен содержать от 10 до 15 цифр';
      }

      if (manager.email.trim() && !isValidEmail(manager.email.trim())) {
        errors.value[`responsibleManagers.${index}.email`] = 'Некорректный email';
      }
    });

    if (formData.value.webLink && !isValidUrl(formData.value.webLink)) {
      errors.value.webLink = 'Некорректный URL';
    }

    return Object.keys(errors.value).length === 0;
  }

  function resetForm() {
    formData.value = {
      name: initialItem?.name || '',
      category: initialItem?.category || '',
      contractNumber: initialItem?.contractNumber || '',
      // Strip leading + from phone if present (to avoid double + with visual prefix)
      phone: initialItem?.phone?.startsWith('+')
        ? initialItem.phone.substring(1)
        : (initialItem?.phone || ''),
      email: initialItem?.email || '',
      webLink: initialItem?.webLink || '',
      responsibleManagers: mapResponsibleManagersFromItem(initialItem),
      comment: initialItem?.comment || '',
    };
    errors.value = {};
  }

   function normalizeResponsibleManagers(): ContractorResponsibleManager[] {
     return formData.value.responsibleManagers
       .map((manager) => ({
         name: manager.name.trim(),
         phone: manager.phone.trim() || null,
         email: manager.email.trim() || null,
       }))
       .filter((manager) => manager.name.length > 0);
   }

  function getCreateRequest(): ContractorCreateRequest {
    return {
      name: formData.value.name.trim(),
      category: formData.value.category.trim(),
      contractNumber: formData.value.contractNumber || null,
      phone: formData.value.phone.trim(),
      email: formData.value.email.trim() || null,
      webLink: formData.value.webLink.trim() || null,
      responsibleManagers: normalizeResponsibleManagers(),
      managerName: normalizeResponsibleManagers()[0]?.name || null,
      managerPhone: normalizeResponsibleManagers()[0]?.phone || null,
      managerEmail: normalizeResponsibleManagers()[0]?.email || null,
      comment: formData.value.comment || null,
    };
  }

  function getUpdateRequest(): ContractorUpdateRequest {
    return {
      name: formData.value.name || undefined,
      category: formData.value.category || undefined,
      contractNumber: formData.value.contractNumber || null,
      phone: formData.value.phone || undefined,
      email: formData.value.email.trim() || null,
      webLink: formData.value.webLink.trim() || null,
      responsibleManagers: normalizeResponsibleManagers(),
      managerName: normalizeResponsibleManagers()[0]?.name || null,
      managerPhone: normalizeResponsibleManagers()[0]?.phone || null,
      managerEmail: normalizeResponsibleManagers()[0]?.email || null,
      comment: formData.value.comment || null,
    };
  }

  return {
    formData,
    errors,
    isEditing,
    validateForm,
    resetForm,
     getCreateRequest,
     getUpdateRequest,
     handlePhoneInput,
     handleResponsiblePhoneInput,
     addResponsibleManager,
     removeResponsibleManager,
   };
 }

function isValidEmail(email: string): boolean {
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return emailRegex.test(email);
}

function isValidUrl(url: string): boolean {
  try {
    new URL(url);
    return true;
  } catch {
    return false;
  }
}