import { useState, useEffect, useRef } from "react";
import { supabase } from "@/integrations/supabase/client";
import { Trip } from "@/types";
import type { Profile } from "@/hooks/useUserProfile";
import { transformTripFromDB, type TripRowWithRelations } from "@/utils/tripDataTransformers";

export function useTripsState(currentUser: Profile | null) {
  const [trips, setTrips] = useState<Trip[]>([]);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState<string | null>(null);
  const [activityError, setActivityError] = useState<string | null>(null);
  const [refreshToken, setRefreshToken] = useState(0);
  const fetchUserTripsRef = useRef<(user: Profile) => Promise<void>>();
  const requestIdRef = useRef(0);

  useEffect(() => {
    if (currentUser) {
      fetchUserTripsRef.current?.(currentUser);
    } else {
      requestIdRef.current += 1;
      setTrips([]);
      setError(null);
      setActivityError(null);
      setIsLoading(false);
    }
  }, [currentUser, refreshToken]);

  const refetchTrips = () => setRefreshToken((value) => value + 1);

  const fetchUserTrips = async (user: Profile) => {
    const requestId = ++requestIdRef.current;
    setIsLoading(true);
    setError(null);
    setActivityError(null);
    console.log("🔄 useTripLoading - Chargement des voyages");
    console.log("Chargement pour utilisateur:", { id: user.id, role: user.role });

    try {
      console.log("🔍 fetchUserTrips - Récupération des voyages depuis Supabase");
      // Correction: Utiliser trip_steps au lieu de steps
      const travelerStepFields = "id,trip_id,day,time,location,activity,price,distance,links,link,image_path,updated_at,validation_status,is_published,step_type,start_time,end_time,description,transport_type,reference_number,departure_name,arrival_name,estimated_duration,restaurant_name,cuisine_type,budget,accommodation_name,room_type,check_in_time,check_out_time,reservation_number,rating,activity_type,guide_name,walking_level,break_purpose";
      const travelerCriticalRelations = `*, trip_steps(${travelerStepFields.replace(",updated_at", "")}, step_validations(*)), trip_members!inner(user_id,status,source,joined_at,profiles!trip_members_user_id_fkey(id,name,email,role))`;
      const relations = user.role === "planner"
        ? '*, trip_steps(*, comments!comments_step_id_fkey(*), step_validations(*)), documents(*), invitations(email, status, created_at, accepted_at, accepted_by), trip_members(user_id,status,source,joined_at,profiles!trip_members_user_id_fkey(id,name,email,role))'
        : `*, trip_steps(${travelerStepFields}, comments!comments_step_id_fkey(*), step_validations(*)), documents(*), invitations(email, status, created_at, accepted_at, accepted_by), trip_members!inner(user_id,status,source,joined_at,profiles!trip_members_user_id_fkey(id,name,email,role))`;
      let query = supabase.from('trips').select(relations);
      query = user.role === "planner" ? query.eq("planner_id", user.id) : query.eq("trip_members.user_id", user.id);
      const initialResult = await query
        .order('created_at', { ascending: false });
      let data: unknown = initialResult.data;
      let queryError = initialResult.error;

      if (queryError && user.role === "traveler") {
        console.error("Données secondaires Voyageur indisponibles, repli sur le programme:", queryError);
        if (requestId === requestIdRef.current) setActivityError(queryError.message);
        const fallback = await supabase.from("trips").select(travelerCriticalRelations)
          .eq("trip_members.user_id", user.id).order("created_at", { ascending: false });
        data = fallback.data;
        queryError = fallback.error;
      }

      if (queryError) {
        console.error("Erreur lors de la récupération des voyages:", queryError);
        if (requestId === requestIdRef.current) setError(queryError.message);
      } else {
        console.log("Données brutes reçues:", data);
        const mappedTrips = (data as TripRowWithRelations[]).map((trip) => transformTripFromDB(trip, user.role));
        if (requestId === requestIdRef.current) setTrips(mappedTrips);
        console.log("✅ " + mappedTrips.length + " voyages chargés avec succès");
        console.log("Données mappées:", mappedTrips);
      }
    } catch (error: unknown) {
      console.error("Erreur inattendue lors du chargement des voyages:", error);
      if (requestId === requestIdRef.current) setError(error instanceof Error ? error.message : "Erreur inattendue");
    } finally {
      if (requestId === requestIdRef.current) setIsLoading(false);
      console.log("📊 Voyages récupérés:", trips?.length);
    }
  };
  fetchUserTripsRef.current = fetchUserTrips;

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