import { Trip, TripStep, Comment, StepValidationStatus } from "../types";
import { useSupabaseTripSteps } from "./trip-steps";
import { useSupabaseComments } from "./useSupabaseComments";
import * as tripOperations from "../utils/tripOperations";

export function useStepOperations(setTrips: React.Dispatch<React.SetStateAction<Trip[]>>) {
  const {
    addTripStep: addStep,
    updateTripStep: updateStep,
    deleteTripStep: deleteStep,
    validateTripStep: validateStep,
    publishTripStep: publishStep
  } = useSupabaseTripSteps();
  const { addStepComment: addComment } = useSupabaseComments();

  const addTripStep = async (tripId: string, stepData: Omit<TripStep, "id" | "comments" | "tripId">) => {
    console.log("useStepOperations - addTripStep - Input Data:", stepData); // Log pour déboguer
    const newStep = await addStep(tripId, stepData);
    if (newStep) {
      console.log("useStepOperations - addTripStep - New Step:", newStep); // Log pour déboguer
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterStepAdd(prev, tripId, newStep));
    }
    return newStep;
  };

  const updateTripStep = async (tripId: string, stepId: string, stepData: Partial<TripStep>) => {
    console.log("useStepOperations - updateTripStep - Input Data:", stepData); // Log pour déboguer
    const updatedStep = await updateStep(tripId, stepId, stepData);
    if (updatedStep) {
      console.log("useStepOperations - updateTripStep - Updated Step:", updatedStep); // Log pour déboguer
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterStepUpdate(prev, tripId, stepId, updatedStep));
    }
    return updatedStep;
  };

  const deleteTripStep = async (tripId: string, stepId: string) => {
    const success = await deleteStep(tripId, stepId);
    if (success) {
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterStepDelete(prev, tripId, stepId));
    }
    return success;
  };

  const validateTripStep = async (tripId: string, stepId: string, status: Exclude<StepValidationStatus, "pending">) => {
    const decision = await validateStep(tripId, stepId, status);
    if (decision) {
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterStepValidation(prev, tripId, stepId, decision.travelerId, decision.status));
    }
    return Boolean(decision);
  };

  // Nouvelle fonction pour publier/dépublier une étape
  const publishTripStep = async (tripId: string, stepId: string, isPublished: boolean) => {
    console.group('📢 Publication d\'étape');
    console.info('Trip ID:', tripId);
    console.info('Step ID:', stepId);
    console.info('État de publication:', isPublished ? 'Publiée' : 'Non publiée');

    const success = await publishStep(tripId, stepId, isPublished);
    if (success) {
      console.info('✅ Statut de publication mis à jour avec succès');
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterStepPublication(prev, tripId, stepId, isPublished));
    } else {
      console.error('❌ Échec de la mise à jour du statut de publication');
    }

    console.groupEnd();
    return success;
  };

  const addStepComment = async (tripId: string, stepId: string, comment: Omit<Comment, "id" | "userId" | "userName" | "createdAt">) => {
    const newComment = await addComment(tripId, stepId, comment);
    if (newComment) {
      setTrips((prev: Trip[]) => tripOperations.updateTripsAfterCommentAdd(prev, tripId, stepId, newComment));
    }
    return newComment;
  };

  return {
    addTripStep,
    updateTripStep,
    deleteTripStep,
    validateTripStep,
    publishTripStep,
    addStepComment,
  };
}