flyer-crawler.projectium.com/src/hooks/useProfileAddress.ts

// src/hooks/useProfileAddress.ts
import { useState, useEffect, useCallback } from 'react';
import toast from 'react-hot-toast';
import type { Address, Profile } from '../types';
import { useApi } from './useApi';
import * as apiClient from '../services/apiClient';
import { logger } from '../services/logger.client';
import { useDebounce } from './useDebounce';

const geocodeWrapper = (address: string, signal?: AbortSignal) => apiClient.geocodeAddress(address, { signal });
const fetchAddressWrapper = (id: number, signal?: AbortSignal) => apiClient.getUserAddress(id, { signal });

/**
 * A custom hook to manage a user's profile address, including fetching,
 * updating, and automatic/manual geocoding.
 * @param profile The user's profile object.
 * @param isOpen Whether the parent component (e.g., a modal) is open. This is used to reset state.
 * @returns An object with address state and handler functions.
 */
export const useProfileAddress = (profile: Profile | null, isOpen: boolean) => {
  const [address, setAddress] = useState<Partial<Address>>({});
  const [initialAddress, setInitialAddress] = useState<Partial<Address>>({});

  const { execute: geocode, loading: isGeocoding } = useApi<{ lat: number; lng: number }, [string]>(geocodeWrapper);
  const { execute: fetchAddress } = useApi<Address, [number]>(fetchAddressWrapper);

  const handleAddressFetch = useCallback(async (addressId: number) => {
    logger.debug(`[useProfileAddress] Starting fetch for addressId: ${addressId}`);
    const fetchedAddress = await fetchAddress(addressId);
    if (fetchedAddress) {
      logger.debug('[useProfileAddress] Successfully fetched address:', fetchedAddress);
      setAddress(fetchedAddress);
      setInitialAddress(fetchedAddress);
    } else {
      logger.warn(`[useProfileAddress] Fetch returned null or undefined for addressId: ${addressId}.`);
    }
  }, [fetchAddress]);

  // Effect to fetch or reset address based on profile and modal state
  useEffect(() => {
    if (isOpen && profile) {
      if (profile.address_id) {
        logger.debug(`[useProfileAddress] Profile has address_id: ${profile.address_id}. Calling handleAddressFetch.`);
        handleAddressFetch(profile.address_id);
      } else {
        logger.debug('[useProfileAddress] Profile has no address_id. Resetting address form.');
        setAddress({});
        setInitialAddress({});
      }
    } else {
        logger.debug('[useProfileAddress] Modal is closed or profile is null. Resetting address state.');
        setAddress({});
        setInitialAddress({});
    }
  }, [isOpen, profile, handleAddressFetch]);

  const handleAddressChange = (field: keyof Address, value: string) => {
    setAddress(prev => ({ ...prev, [field]: value }));
  };

  const handleManualGeocode = async () => {
    const addressString = [
      address.address_line_1,
      address.city,
      address.province_state,
      address.postal_code,
      address.country,
    ].filter(Boolean).join(', ');

    if (!addressString) {
      toast.error('Please fill in the address fields before geocoding.');
      return;
    }

    logger.debug(`[useProfileAddress] Manual geocode triggering for: ${addressString}`);

    const result = await geocode(addressString);
    if (result) {
      const { lat, lng } = result;
      setAddress(prev => ({ ...prev, latitude: lat, longitude: lng }));
      toast.success('Address re-geocoded successfully!');
    }
  };

  // --- Automatic Geocoding Logic ---
  const debouncedAddress = useDebounce(address, 1500);

  useEffect(() => {
    const handleAutoGeocode = async () => {
      logger.debug('[useProfileAddress] Auto-geocode effect triggered by debouncedAddress change');
      
      // Prevent geocoding on initial load if the address hasn't been changed by the user.
      if (JSON.stringify(debouncedAddress) === JSON.stringify(initialAddress)) {
        logger.debug('[useProfileAddress] Skipping auto-geocode: address is unchanged from initial load.');
        return;
      }

      const addressString = [
        debouncedAddress.address_line_1,
        debouncedAddress.city,
        debouncedAddress.province_state,
        debouncedAddress.postal_code,
        debouncedAddress.country,
      ].filter(Boolean).join(', ');

      logger.debug(`[useProfileAddress] addressString generated for auto-geocode: "${addressString}"`);

      // Don't geocode an empty address or if we already have coordinates.
      if (!addressString || (debouncedAddress.latitude && debouncedAddress.longitude)) {
        logger.debug('[useProfileAddress] Skipping auto-geocode: empty string or coordinates already exist');
        return;
      }

      logger.debug('[useProfileAddress] Calling auto-geocode API...');
      const result = await geocode(addressString);
      if (result) {
        logger.debug('[useProfileAddress] Auto-geocode API returned result:', result);
        const { lat, lng } = result;
        setAddress(prev => ({ ...prev, latitude: lat, longitude: lng }));
        toast.success('Address geocoded successfully!');
      }
    };

    handleAutoGeocode();
  }, [debouncedAddress, initialAddress, geocode]);

  return {
    address,
    initialAddress,
    isGeocoding,
    handleAddressChange,
    handleManualGeocode,
  };
};