import { Trip } from "../types";
import { useSupabaseTrips } from "./useSupabaseTrips";
import { useAuth } from "@/contexts/AuthContext";
import * as tripOperations from "../utils/tripOperations";
import { useCallback } from "react";

export function useTripOperations(trips: Trip[], setTrips: React.Dispatch<React.SetStateAction<Trip[]>>) {
  const { createTrip: create, updateTrip: update, deleteTrip: remove } = useSupabaseTrips();
  const { currentUser } = useAuth();

  const getUserTrips = useCallback(() => {
    // Si nous n'avons pas d'utilisateur, retourner un tableau vide
    if (!currentUser) {
      console.info('📋 getUserTrips - Aucun utilisateur connecté, retourne un tableau vide');
      return [];
    }

    // Pour les voyageurs, récupérer les voyages où ils sont explicitement mentionnés
    if (currentUser.role === 'traveler') {
      const userTrips = trips.filter(trip =>
        trip.members?.some((member) => member.userId === currentUser.id)
      );

      console.info('📋 getUserTrips - Nombre de voyages récupérés pour voyageur:', userTrips.length);
      if (userTrips.length === 0) {
        console.warn('⚠️ Aucun voyage trouvé pour ce voyageur (id:', currentUser.id, ', email:', currentUser.email, ')');
      }
      return userTrips;
    }

    // Pour les planners, récupérer tous leurs voyages créés
    // On utilise la fonction getUserTrips qui a été modifiée pour n'accepter qu'un seul argument
    const userTrips = tripOperations.getUserTrips(trips).filter((trip) => trip.plannerId === currentUser.id);
    console.info('📋 getUserTrips - Nombre de voyages récupérés:', userTrips.length);
    return userTrips;
  }, [currentUser, trips]);

  const getTrip = useCallback((tripId: string) => {
    console.group('🔍 Recherche de voyage');
    console.info('ID recherché:', tripId);

    // Si l'utilisateur est un voyageur, vérifier l'accès par email aussi
    if (currentUser && currentUser.role === 'traveler') {
      const trip = trips.find(trip =>
        trip.id === tripId && (
          trip.members?.some((member) => member.userId === currentUser.id)
        )
      );

      if (trip) {
        console.info('✅ Voyage trouvé par ID/email:', {
          id: trip.id,
          title: trip.title,
          destination: trip.destination,
          steps: trip.steps?.length || 0
        });
        console.groupEnd();
        return trip;
      }
    } else {
      // Pour les planners ou cas standard, recherche par ID
      const trip = trips.find((candidate) => candidate.id === tripId && candidate.plannerId === currentUser?.id) || null;

      if (trip) {
        console.info('✅ Voyage trouvé:', {
          id: trip.id,
          title: trip.title,
          destination: trip.destination,
          steps: trip.steps?.length || 0
        });
        console.groupEnd();
        return trip;
      }
    }

    console.warn('⚠️ Aucun voyage trouvé avec cet ID');
    console.groupEnd();
    return null;
  }, [currentUser, trips]);

  const createTrip = async (tripData: Omit<Trip, "id" | "steps" | "documents">) => {
    console.group('➕ Création d\'un nouveau voyage');
    console.info('Données:', { ...tripData });

    const newTrip = await create(tripData);
    if (newTrip) {
      console.info('✅ Voyage créé avec succès:', newTrip.id);
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterCreate(prev, newTrip));
    } else {
      console.error('❌ Échec de la création du voyage');
    }

    console.groupEnd();
    return newTrip;
  };

  const updateTrip = async (tripId: string, tripData: Partial<Trip>) => {
    console.group('🔄 Mise à jour du voyage');
    console.info('ID:', tripId);
    console.info('Données:', { ...tripData });

    const updatedTrip = await update(tripId, tripData);
    if (updatedTrip) {
      console.info('✅ Voyage mis à jour avec succès');
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterUpdate(prev, tripId, updatedTrip));
    } else {
      console.error('❌ Échec de la mise à jour du voyage');
    }

    console.groupEnd();
    return updatedTrip;
  };

  const deleteTrip = async (tripId: string) => {
    console.group('🗑️ Suppression du voyage');
    console.info('ID à supprimer:', tripId);

    const success = await remove(tripId);
    if (success) {
      console.info('✅ Voyage supprimé avec succès');
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterDelete(prev, tripId));
    } else {
      console.error('❌ Échec de la suppression du voyage');
    }

    console.groupEnd();
    return success;
  };

  return {
    getUserTrips,
    getTrip,
    createTrip,
    updateTrip,
    deleteTrip,
  };
}