'use client';
import { useDispatch } from 'react-redux';
import { useEffect, useState } from 'react';
import { QueryClient, QueryKey } from "@tanstack/react-query";
import { useMutation, useQueryClient } from '@tanstack/react-query';


import PostAPI from '@/server_api/api-functions/apipost'
import { setSnackbarAlertMessage } from '@/redux/slice/snackbar-slice';
import { useModal } from '@/components/modal/use-modal';
import { updateQueryData } from '@/utils/tanstack/react-query-update';

export interface UseMutationProps {
    isUpdateQuery?: boolean;
    alertMessage?:
    | boolean
    | { messages: React.ReactNode, type: 'success' | 'error', from: string }
    | ((response: any) => { messages: React.ReactNode, type: 'success' | 'error', from: string });
    isCloseModal?: boolean;
    onSuccessCallback?: any;
    onErrorCallback?: any;
    apiKey?: QueryKey;
    data?: any;
    isFormData?: boolean;
    refetch?: () => void;
    isRefresh?: boolean;
    isExport?: boolean;
}

const useMutateApi = ({
    isUpdateQuery = false,
    alertMessage = false,
    isCloseModal = false,
    onSuccessCallback,
    onErrorCallback,
    apiKey,
    data = false,
    isFormData = false,
    refetch = () => { },
    isRefresh,
    isExport = false

}: UseMutationProps) => {
    const dispatch = useDispatch();
    const { closeModal } = useModal();
    const queryClient = useQueryClient();
    const [errorMessages, setErrorMessages] = useState<any>('');

    const mutationFn = (variables: any) => {
        const payload = { ...variables };
        if (isExport) {
            payload.isExport = true;
        }
        return isFormData ? PostAPI.postAPI(payload) : PostAPI.postAPI(payload);
    };

    const { mutate, isPending: isLoading, error } = useMutation<any, Error, UseMutationProps>({
        mutationFn: mutationFn,
        onSuccess: async (response: any) => {
            setErrorMessages('')
            if (isExport) {
                const exportPayload = response?.data ?? response;
                onSuccessCallback(exportPayload);
                if (isCloseModal) {
                    closeModal();
                }
            } else {
                if (response.status) {
                    if (response && response.status) {
                        if (onSuccessCallback) {
                            onSuccessCallback(response.requestedData);
                        }
                        if (alertMessage) {
                            const messagePayload: any =
                                typeof alertMessage === 'function'
                                    ? alertMessage(response)
                                    : typeof alertMessage === 'boolean'
                                        ? { messages: response.message || 'Success', type: 'success', from: 'useMutateApi' }
                                        : alertMessage;
                            dispatch(setSnackbarAlertMessage(messagePayload));
                        }
                        if (isRefresh && (refetch || apiKey)) {
                            if (apiKey) {
                                queryClient.invalidateQueries({ queryKey: apiKey as any });
                            } else {
                                refetch()
                            }
                        }
                        if (isUpdateQuery && apiKey && data) {
                            updateQueryData(queryClient, apiKey, data, response);
                        }
                        if (isCloseModal) {
                            closeModal();
                        }
                    }
                } else {
                    if ((!response.status) && (response.validation)) {
                        setErrorMessages(response.validation)
                    }
                }
            }
        },
        onError: (error: any) => {
            const errorMsg = (error && (Array.isArray(error) ? error.join(', ') : typeof error === 'object' ? (error.message || JSON.stringify(error)) : error.toString())) || 'Something went wrong';
            setErrorMessages(errorMsg);
            if (onErrorCallback) {
                onErrorCallback(error);
            }
            if (alertMessage) {
                dispatch(setSnackbarAlertMessage({ messages: errorMsg, type: 'error', from: 'useMutateApi' }));
            }
        }
    });
    return {
        mutate,
        isLoading,
        error,
        errorMessages
    };
};

export default useMutateApi;