import { useState, useEffect } from "react";
import { supabase } from "@/integrations/supabase/client";
import { User } from "@/types";
import { useAuth } from "@/contexts/AuthContext";
import type { Tables } from "@/integrations/supabase/types";

type TravelerProfile = Pick<Tables<"profiles">, "id" | "name" | "email" | "role" | "id_planner">;

export function useTravelerSearch() {
  const [travelers, setTravelers] = useState<User[]>([]);
  const [filteredTravelers, setFilteredTravelers] = useState<User[]>([]);
  const [searchTerm, setSearchTerm] = useState("");
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);
  const { currentUser } = useAuth();

  // Charger la liste des voyageurs
  useEffect(() => {
    async function fetchTravelers() {
      try {
        if (!currentUser?.id) {
          console.warn("Impossible de charger les voyageurs: utilisateur non connecté");
          setLoading(false);
          return;
        }

        setLoading(true);
        console.log("Chargement des voyageurs depuis profiles_safe...");

        const { data: memberships, error: linkedError } = await supabase
          .from("trip_members")
          .select("user_id, profiles!trip_members_user_id_fkey(id,name,email,role,id_planner)");

        if (linkedError) {
          console.error("Erreur lors du chargement des voyageurs liés:", linkedError);
          throw linkedError;
        }

        const linkedTravelers = (memberships || []).flatMap((membership) =>
          membership.profiles ? [membership.profiles as TravelerProfile] : []
        );

        const { data: pendingInvitations, error: emailError } = await supabase
          .from("invitations")
          .select("email")
          .eq("planner_id", currentUser.id)
          .eq("status", "pending");

        if (emailError) {
          console.error("Erreur lors du chargement des voyageurs par email:", emailError);
        }

        const emailOnlyTravelers: TravelerProfile[] = (pendingInvitations || []).map(invitation => ({
            id: "",
            name: invitation.email.split('@')[0] || "Sans nom",
            email: invitation.email,
            role: "traveler" as const,
            id_planner: currentUser.id
          }));

        // Combiner toutes les sources et éliminer les doublons
        const allTravelers = [...linkedTravelers, ...emailOnlyTravelers];

        // Éliminer les doublons en prioritisant les entrées avec un ID
        const uniqueEmails = new Set<string>();
        const uniqueTravelers = allTravelers.filter(traveler => {
          if (!traveler.email) return false;

          const normalizedEmail = traveler.email.trim().toLowerCase();
          if (uniqueEmails.has(normalizedEmail)) {
            return false;
          }

          uniqueEmails.add(normalizedEmail);
          return true;
        });

        console.log("Combinaison des voyageurs (sans doublons):", uniqueTravelers);

        // Si traveler.id_planner est null, l'affecter au planner actuel
        const mappedTravelers: User[] = uniqueTravelers.map(traveler => ({
          id: traveler.id || "",
          name: traveler.name || traveler.email?.split('@')[0] || "Sans nom",
          email: traveler.email || "",
          role: traveler.role === "planner" ? "planner" : "traveler",
          id_planner: traveler.id_planner || currentUser.id, // Utiliser l'ID du planner actuel si non défini
        }));

        console.log("Voyageurs mappés:", mappedTravelers);

        setTravelers(mappedTravelers);
        setFilteredTravelers(mappedTravelers);
      } catch (error) {
        console.error("Erreur lors du chargement des voyageurs:", error);
        setError(error as Error);
      } finally {
        setLoading(false);
      }
    }

    fetchTravelers();
  }, [currentUser?.id]);

  // Filtre des voyageurs lors de la recherche
  useEffect(() => {
    if (searchTerm.trim() === "") {
      setFilteredTravelers(travelers);
    } else {
      const term = searchTerm.trim().toLowerCase();
      const filtered = travelers.filter(
        traveler =>
          (traveler.name?.toLowerCase() || "").includes(term) ||
          (traveler.email?.toLowerCase() || "").includes(term)
      );
      setFilteredTravelers(filtered);
    }
  }, [searchTerm, travelers]);

  return {
    travelers: filteredTravelers,
    searchTerm,
    setSearchTerm,
    loading,
    error
  };
}