import { useRef, useState } from "react";
import { useForm } from "react-hook-form";
import { zodResolver } from "@hookform/resolvers/zod";
import { z } from "zod";
import { toast } from "sonner";
import { useNavigate } from "react-router-dom";
import { supabase } from "@/integrations/supabase/client";
import { useTrips } from "../../contexts/TripContext";
import { useAuth } from "../../contexts/AuthContext";
import { tripSchema } from "../forms/schemas/tripSchema";
import { CreateTripFormContainer } from "./CreateTripFormContainer";
import { inviteTraveler } from "@/services/invitationService";

export function CreateTripForm() {
  const { createTrip } = useTrips();
  const { currentUser } = useAuth();
  const [isSubmitting, setIsSubmitting] = useState(false);
  const submittingRef = useRef(false);
  const navigate = useNavigate();

  const form = useForm<z.infer<typeof tripSchema>>({
    resolver: zodResolver(tripSchema),
    defaultValues: {
      title: "",
      destination: "",
      startDate: "",
      endDate: "",
      travelerEmail: "",
      travelerName: "",
    },
  });

  async function onSubmit(values: z.infer<typeof tripSchema>) {
    if (submittingRef.current) return;
    if (!currentUser) {
      toast.error("Vous devez être connecté pour créer un voyage");
      return;
    }

    submittingRef.current = true;
    setIsSubmitting(true);
    try {
      let coverUrl = null;

      if (values.coverImage?.[0]) {
        const file = values.coverImage[0];
        const fileExt = file.name.split('.').pop();
        const filePath = `${Math.random()}.${fileExt}`;

        const { error: uploadError } = await supabase.storage
          .from('covers')
          .upload(filePath, file);

        if (uploadError) {
          throw uploadError;
        }

        const { data: { publicUrl } } = supabase.storage
          .from('covers')
          .getPublicUrl(filePath);

        coverUrl = publicUrl;
      }

      const newTrip = await createTrip({
        title: values.title,
        destination: values.destination,
        startDate: values.startDate,
        endDate: values.endDate,
        travelerEmail: values.travelerEmail,
        travelerName: values.travelerName,
        coverUrl: coverUrl,
        plannerId: currentUser.id,
        travelerId: "", // This will be set when the traveler accepts the invitation
      });

      if (newTrip && values.travelerEmail) {
        try {
          await inviteTraveler({
            tripId: newTrip.id,
            email: values.travelerEmail,
            travelerName: values.travelerName,
          });
          toast.success("Voyage créé et invitation envoyée !");
        } catch (invitationError) {
          const message = invitationError instanceof Error
            ? invitationError.message
            : "L’invitation n’a pas pu être envoyée.";
          toast.warning(`Le voyage a été créé. ${message}`);
        }
        navigate(`/dashboard/trips/${newTrip.id}`);
      } else if (newTrip) {
        toast.success("Voyage créé avec succès !");
        navigate(`/dashboard/trips/${newTrip.id}`);
      }
    } catch (error) {
      console.error("Failed to create trip:", error);
      toast.error("Échec de la création du voyage");
    } finally {
      submittingRef.current = false;
      setIsSubmitting(false);
    }
  }

  return (
    <CreateTripFormContainer
      form={form}
      onSubmit={onSubmit}
      isSubmitting={isSubmitting}
    />
  );
}