"use client";
import { useToast } from "@/hooks/use-toast";
import {
  useCreateIndividualPropertiesMutation,
  useUpdateIndividualPropertiesMutation,
} from "@/redux/api/individualProperties";
import { useImageUploader } from "@/utils/useUploader";
import { useSearchParams } from "next/navigation";
import { useState } from "react";

export const uploadFiles = async (
  files: File[],
  folder: string,
  uploadFn: (file: File, folder: string) => Promise<string>
): Promise<string[]> => {
  try {
    const uploadPromises = files.map((file) => uploadFn(file, folder));
    return await Promise.all(uploadPromises);
  } catch (error) {
    console.error("Error uploading files to S3:", error);
    throw error;
  }
};

export function useCreatePropertyMutations(opts: {
  onOpenChange: (open: boolean) => void;
  resetForm: () => void;
  clearWizard: () => void;
  isEdit: boolean;
  propertyIdOverride?: string | null;
}) {
  const [imageLoading, setImageLoading] = useState(false);
  const searchParams = useSearchParams();
  const propertyId = opts.propertyIdOverride ?? searchParams.get("id");
  const { toast } = useToast();
  const { uploadFileToS3 } = useImageUploader();

  const [createProperty, { isLoading: isCreating }] =
    useCreateIndividualPropertiesMutation();
  const [updateProperty, { isLoading: isUpdating }] =
    useUpdateIndividualPropertiesMutation();

  const { onOpenChange, resetForm, clearWizard, isEdit } = opts;

  const handleSuccess = () => {
    if (isEdit) window.location.reload(); // Reload the page (so default values are reset) TODO find a better way
    onOpenChange(false);
    resetForm();
    clearWizard();
    return true;
  };

  const handleError = (title: string, message: string | undefined) => {
    toast({
      variant: "destructive",
      title,
      description: message || "An unknown error occurred.",
    });
    return false;
  };

  const submitHelper = async (
    payload: Partial<individualProperties>,
    errorTitle: string
  ): Promise<boolean> => {
    const { media, mediaUrls: existingPayloadMediaUrls, ...formData } = payload;
    let finalMediaUrls: string[] = [];

    try {
      if (Array.isArray(media) && media.length > 0) {
        setImageLoading(true);
        const newMediaUrls = await uploadFiles(
          media as unknown as File[],
          "Property",
          uploadFileToS3
        );
        finalMediaUrls = newMediaUrls;
        setImageLoading(false);
      }

      if (isEdit && Array.isArray(existingPayloadMediaUrls)) {
        const combinedUrls = [...existingPayloadMediaUrls, ...finalMediaUrls];
        finalMediaUrls = combinedUrls;
      }

      (formData as any).mediaUrls = finalMediaUrls;

      let response;
      if (isEdit && propertyId) {
        response = await updateProperty({
          id: propertyId,
          data: formData,
        }).unwrap();
      } else {
        response = await createProperty(formData).unwrap();
      }

      if (!response.success) {
        return handleError(errorTitle, response.message);
      }

      return handleSuccess();
    } catch (err: any) {
      return handleError(errorTitle, err?.data?.message || err?.message);
    }
  };

  return { submitHelper, isLoading: isCreating || isUpdating || imageLoading };
}