import { useState, useEffect } from "react";
import { Trip } from "../types";
import { useSupabaseTrips } from "./useSupabaseTrips";
import { supabase } from "@/integrations/supabase/client";
import { User } from "../types";

export function useTripLoading(currentUser: User | null) {
  const [trips, setTrips] = useState<Trip[]>([]);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  const [retryCount, setRetryCount] = useState(0);
  // Use the hooks directly
  const { fetchUserTrips: fetchTrips } = useSupabaseTrips();

  useEffect(() => {
    // Prevent excessive loading attempts
    if (retryCount > 3) {
      console.warn("Maximum retry count reached, stopping further attempts");
      setIsLoading(false);
      return;
    }

    const loadTrips = async () => {
      console.group('🔄 useTripLoading - Chargement des voyages');

      if (!currentUser) {
        console.info('Aucun utilisateur connecté, tableau de voyages vide');
        setTrips([]);
        setIsLoading(false);
        setError(null);
        console.groupEnd();
        return;
      }

      console.info('Chargement pour utilisateur:', {
        id: currentUser.id,
        role: currentUser.role
      });

      setIsLoading(true);
      setError(null);

      try {
        // Add a timeout to prevent hanging
        const timeoutPromise = new Promise<{ data: null, error: Error }>((_, reject) =>
          setTimeout(() => reject(new Error("Timeout")), 10000)
        );

        // Vérifier si l'utilisateur existe dans profiles_safe
        const profilePromise = supabase
          .from('profiles_safe')
          .select('*')
          .eq('id', currentUser.id)
          .maybeSingle();

        // Type the result properly
        const profileResult = await Promise.race([
          profilePromise,
          timeoutPromise
        ]);

        // Properly type check the result
        if (profileResult.error) {
          console.error('❌ Erreur lors de la vérification du profil:', profileResult.error);
          setError("Erreur lors de la vérification du profil utilisateur");
          throw profileResult.error;
        }

        if (!profileResult.data) {
          console.warn('⚠️ Aucun profil trouvé dans profiles_safe pour cet utilisateur');
          setTrips([]);
          setIsLoading(false);
          console.groupEnd();
          return;
        }

        // Charger les voyages avec un timeout
        const tripsPromise = fetchTrips(currentUser.id, currentUser.role);
        const tripsData = await Promise.race([
          tripsPromise,
          timeoutPromise
        ]);

        // Make sure tripsData is properly typed
        const tripsArray = Array.isArray(tripsData) ? tripsData : [];
        console.info(`📊 Voyages récupérés: ${tripsArray.length || 0}`);

        // Vérifier que tous les champs essentiels sont présents
        const validTrips = tripsArray.map((trip: Trip) => {
          if (trip.plannerId === undefined || trip.travelerId === undefined) {
            console.warn(`⚠️ Trip ${trip.id} a des champs manquants`);
          }

          return {
            ...trip,
            plannerId: trip.plannerId || null,
            travelerId: trip.travelerId || null,
            // S'assurer que les tableaux ne sont jamais undefined
            steps: trip.steps || [],
            documents: trip.documents || []
          };
        });

        setTrips(validTrips);
        setError(null);
      } catch (error) {
        console.error('❌ Erreur lors du chargement des voyages:', error);

        // Enregistrer l'erreur mais ne pas bloquer l'interface
        setError("Impossible de charger tous les voyages");

        // Garder les voyages existants si nous en avions
        setTrips(existingTrips => existingTrips.length === 0 ? [] : existingTrips);
      } finally {
        setIsLoading(false);
        console.groupEnd();
      }
    };

    loadTrips();

    // Si le chargement échoue, réessayer jusqu'à 3 fois avec un délai progressif
  }, [currentUser, retryCount, fetchTrips]);

  useEffect(() => {
    if (error && retryCount < 3) {
      const timer = setTimeout(() => {
        console.log(`⚠️ Nouvelle tentative de chargement (${retryCount + 1}/3)`);
        setRetryCount(prevCount => prevCount + 1);
      }, 2000 * (retryCount + 1)); // Délai progressif: 2s, 4s, 6s

      return () => clearTimeout(timer);
    }
  }, [error, retryCount]);

  return { trips, setTrips, isLoading, error };
}