import { useState, useEffect, useCallback } from 'react';
import { api } from '../services/api';
import { Delivery } from '../types';
import AsyncStorage from '@react-native-async-storage/async-storage';

interface UseRoutingReturn {
  needsRouting: boolean;
  isRouting: boolean;
  routingProgress: number;
  error: string | null;
  checkRoutingStatus: () => Promise<boolean>;
  executeRouting: () => Promise<boolean>;
  clearError: () => void;
}

export const useRouting = (): UseRoutingReturn => {
  const [needsRouting, setNeedsRouting] = useState(false);
  const [isRouting, setIsRouting] = useState(false);
  const [routingProgress, setRoutingProgress] = useState(0);
  const [error, setError] = useState<string | null>(null);

  // Verificar status de roteirização
  const checkRoutingStatus = useCallback(async (): Promise<boolean> => {
    try {
      console.log('=== 🪝 DEBUG: CHECK ROUTING STATUS ===');
      setError(null);
      const deliveries = await api.getDeliveries();
      console.log('📦 Entregas carregadas no hook:', deliveries.length);
      
      // Log detalhado de cada entrega
      deliveries.forEach((delivery, index) => {
        console.log(`📦 Entrega ${index + 1}:`, {
          outId: delivery.outId,
          customerName: delivery.customerName,
          routing: delivery.routing,
          deliverySeq: delivery.deliverySeq,
          status: delivery.status
        });
      });
      
      const hasUnroutedDeliveries = deliveries.some(delivery => delivery.routing === 0);
      console.log('🔍 Precisa de roteirização?', hasUnroutedDeliveries);
      setNeedsRouting(hasUnroutedDeliveries);
      return hasUnroutedDeliveries;
    } catch (error: any) {
      console.error('❌ Erro ao verificar status de roteirização:', error);
      setError(error.message || 'Erro ao verificar roteirização');
      return false;
    }
  }, []);

  // Executar roteirização
  const executeRouting = useCallback(async (): Promise<boolean> => {
    try {
      setIsRouting(true);
      setRoutingProgress(0);
      setError(null);

      const token = await AsyncStorage.getItem('authToken');
      if (!token) {
        throw new Error('Token de autenticação não encontrado');
      }

      // Obter entregas que precisam de roteirização
      const deliveries = await api.getDeliveries();
      const deliveriesToRoute = deliveries.filter(delivery => delivery.routing === 0);
      
      if (deliveriesToRoute.length === 0) {
        setNeedsRouting(false);
        return true;
      }

      // Preparar dados para roteirização
      const routingData = deliveriesToRoute.map(delivery => ({
        outId: delivery.outId,
        customerId: delivery.customerId,
        deliverySeq: delivery.deliverySeq || 1,
        lat: delivery.lat || delivery.coordinates?.latitude,
        lng: delivery.lng || delivery.coordinates?.longitude
      })).filter(item => item.lat && item.lng);

      if (routingData.length === 0) {
        throw new Error('Nenhuma entrega com coordenadas válidas para roteirização');
      }

      setRoutingProgress(20);

      // Executar roteirização
      const routingResponse = await api.request<{ success: boolean; message: string }>('/v1/driver/routing', {
        method: 'POST',
        body: JSON.stringify(routingData)
      });

      setRoutingProgress(60);

      if (routingResponse && routingResponse.success) {
        setRoutingProgress(80);
        
        // Aguardar processamento da API
        await new Promise(resolve => setTimeout(resolve, 2000));
        
        setRoutingProgress(90);
        
        // Verificar se a roteirização foi bem-sucedida
        const updatedDeliveries = await api.getDeliveries();
        const hasSuccessfulRouting = updatedDeliveries.some(d => d.routing === 1);
        
        if (hasSuccessfulRouting) {
          setNeedsRouting(false);
          setRoutingProgress(100);
          return true;
        } else {
          throw new Error('Roteirização executada, mas aguardando confirmação da API');
        }
      } else {
        throw new Error(routingResponse?.message || 'Erro na roteirização');
      }
    } catch (error: any) {
      console.error('Erro na roteirização:', error);
      setError(error.message || 'Erro ao executar roteirização');
      return false;
    } finally {
      setIsRouting(false);
      setRoutingProgress(0);
    }
  }, []);

  // Limpar erro
  const clearError = useCallback(() => {
    setError(null);
  }, []);

  // Verificar status inicial
  useEffect(() => {
    checkRoutingStatus();
  }, [checkRoutingStatus]);

  return {
    needsRouting,
    isRouting,
    routingProgress,
    error,
    checkRoutingStatus,
    executeRouting,
    clearError,
  };
}; 