import { useState, useEffect, useCallback } from 'react';
import GPSService from '../services/gpsService';

/**
 * Hook personalizado para manejo de GPS
 * Proporciona funcionalidades de geolocalización con manejo de errores y permisos
 */
export const useGPS = () => {
  const [position, setPosition] = useState(null);
  const [error, setError] = useState(null);
  const [loading, setLoading] = useState(false);
  const [permission, setPermission] = useState('prompt');
  const [isWatching, setIsWatching] = useState(false);

  // Verificar permisos al montar el componente
  useEffect(() => {
    const checkPermission = async () => {
      try {
        const permissionState = await GPSService.requestPermission();
        setPermission(permissionState);
      } catch (err) {
        setError(err.message);
      }
    };

    checkPermission();
  }, []);

  /**
   * Obtiene la posición actual
   */
  const getCurrentPosition = useCallback(async () => {
    setLoading(true);
    setError(null);

    try {
      const coords = await GPSService.getCurrentPosition();
      setPosition(coords);
      return coords;
    } catch (err) {
      setError(err.message);
      throw err;
    } finally {
      setLoading(false);
    }
  }, []);

  /**
   * Inicia el seguimiento continuo de la posición
   */
  const startWatching = useCallback(() => {
    if (isWatching) return;

    setError(null);
    setIsWatching(true);

    GPSService.startWatching(
      (coords) => {
        setPosition(coords);
        setError(null);
      },
      (err) => {
        setError(err.message);
        setIsWatching(false);
      }
    );
  }, [isWatching]);

  /**
   * Detiene el seguimiento de la posición
   */
  const stopWatching = useCallback(() => {
    GPSService.stopWatching();
    setIsWatching(false);
  }, []);

  /**
   * Solicita permisos de geolocalización
   */
  const requestPermission = useCallback(async () => {
    try {
      const permissionState = await GPSService.requestPermission();
      setPermission(permissionState);
      return permissionState;
    } catch (err) {
      setError(err.message);
      throw err;
    }
  }, []);

  /**
   * Limpia errores
   */
  const clearError = useCallback(() => {
    setError(null);
  }, []);

  /**
   * Valida si las coordenadas están en Guatemala
   */
  const validateGuatemalaCoordinates = useCallback((latitude, longitude) => {
    return GPSService.isValidGuatemalaCoordinates(latitude, longitude);
  }, []);

  /**
   * Formatea coordenadas para mostrar
   */
  const formatCoordinates = useCallback((latitude, longitude) => {
    return GPSService.formatCoordinates(latitude, longitude);
  }, []);

  // Limpiar watcher al desmontar
  useEffect(() => {
    return () => {
      if (isWatching) {
        GPSService.stopWatching();
      }
    };
  }, [isWatching]);

  return {
    // Estado
    position,
    error,
    loading,
    permission,
    isWatching,
    isSupported: GPSService.isSupported(),
    
    // Acciones
    getCurrentPosition,
    startWatching,
    stopWatching,
    requestPermission,
    clearError,
    
    // Utilidades
    validateGuatemalaCoordinates,
    formatCoordinates,
    
    // Última posición conocida
    lastKnownPosition: GPSService.getLastKnownPosition()
  };
};

export default useGPS;