import { useQuery, useMutation, useQueryClient, useInfiniteQuery, UseInfiniteQueryResult, InfiniteData, InfiniteQueryObserver } from "@tanstack/react-query";
import api from "@/lib/axios";
import { ApiResponse, ApiResponseDetail, Collections } from "@/types/response";

import { BussinessProfile, CallIntiate, Contact, LabelContact } from "@/types/contacts";
import { PayloadMessage, SendMessagePayload } from "@/types/payload";
import { Conversation } from "@/types/conversations";
import { useChatStore } from "@/store/useChatStore";
import { stringify } from "querystring";
import { toast } from "sonner";
import { useDebounce } from "use-debounce";
import { SlideImage } from "yet-another-react-lightbox";
import axios from "axios";


// Fetch contacts
export const useInfiniteConversationContacts = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { perPageConversationContact, selectedBranch, searchConversationContact, selectedLabel, filterUnreplied } = useChatStore();
    const [search] = useDebounce(searchConversationContact, 500);
    return useInfiniteQuery({
        queryKey: ["contact-conversations-infinite", accountId, selectedBranch, search, selectedLabel, filterUnreplied],
        queryFn: async ({ pageParam = 1 }) => {
            const response = await api.get<ApiResponse<Contact>>(`/api/whatsapp/contacts`, {
                params: {
                    account_id:accountId,
                    page: pageParam,
                    branch:selectedBranch.join(','),
                    search:search,
                    label_id:selectedLabel,
                    unreplied: filterUnreplied,
                    per_page: perPageConversationContact
                }
            });

            return response.data.data;
        },
        getNextPageParam: (lastPage, allPages) => {
            if (lastPage.meta && lastPage.meta.current_page < lastPage.meta.last_page) {
                return lastPage.meta.current_page + 1;
            }
            return undefined;
        },
        initialPageParam: 1,
        // staleTime: 5 * 60 * 1000, // 5 minutes
    });
};

export const useInfiniteContacts = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { perPageContact, pageContact, searchContact } = useChatStore();
    const [search] = useDebounce(searchContact, 500);


    return useInfiniteQuery({
        queryKey: ["contacts-infinite", accountId, search],
        queryFn: async ({ pageParam = 1 }) => {
            const response = await api.get<ApiResponse<Contact>>(`/api/contact`, {
                params: {
                    account_id:accountId,
                    page: pageParam,
                    per_page: perPageContact,
                    search:search,
                }
            });

            return response.data.data;
        },
        getNextPageParam: (lastPage, allPages) => {
            if (lastPage.meta && lastPage.meta.current_page < lastPage.meta.last_page) {
                return lastPage.meta.current_page + 1;
            }
            return undefined;
        },
        initialPageParam: 1,
        // staleTime: 5 * 60 * 1000, // 5 minutes
    });
};


export const useConversations = (contact_id: string, page:number, per_page:number) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useQuery({
        queryKey: ["conversations", accountId, contact_id, page, per_page],
        queryFn: async () => {
            const response = await api.get<ApiResponse<Conversation>>(`/api/whatsapp/messages/${contact_id}`, {
                params: {
                    page: page,
                    per_page: per_page
                }
            });

            // Map API response to Conversation interface
            return response.data.data;
        },
        staleTime: 5 * 60 * 1000, // 5 minutes
    });
};  


export const useConversationDetail = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { messageId, selectedContact, setMessageId, pageSelectedMessage } = useChatStore();
    const queryClient = useQueryClient();

    return useQuery({
        queryKey: ["conversation-detail", accountId, messageId],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<Conversation>>(`/api/whatsapp/messages/detail/${messageId}`);
            queryClient.setQueryData(
                ["conversations-infinite", accountId, selectedContact?.id, pageSelectedMessage],
                (oldData: any) => {
                    if (!oldData) return oldData;
                    return {
                        ...oldData,
                        pages: oldData.pages.map((page: any, pageIdx: number) => {
                            // Per page (result) map
                            const hasId = page.result.some(
                                (item: any) => item.id === response.data.data?.id
                            );
                            if (hasId && response.data.data?.id) {
                                // If the conversation with id exists, update it
                                return {
                                    ...page,
                                    result: page.result.map((item: any) => {
                                        if (item.id === response.data.data.id) {
                                            return { ...item, ...response.data.data };
                                        }
                                        return item;
                                    }),
                                };
                            } else if (response.data.data?.id) {
                                // If id does not exist, add it to first page only
                                if (pageIdx === 0) {
                                    return {
                                        ...page,
                                        result: [...page.result, response.data.data],
                                    };
                                }
                                return page;
                            }
                            return page;
                        }),
                    };
                }
            );
            setMessageId('');
            return response.data.data;
        },
        enabled: !!messageId,
    });
};


export const useContactDetail = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { contactId, selectedContact,setSelectedContact, setContactId, selectedBranch, searchConversationContact,setLoadingFirstConversation, selectedLabel, filterUnreplied, setPaginationWindow } = useChatStore();
    const queryClient = useQueryClient();
    return useMutation({
        mutationKey: ["contact-detail", accountId],
        mutationFn: async (contactId: string) => {
            const response = await api.get<ApiResponseDetail<Contact>>(`/api/contact/${contactId}`);
            return response.data.data;
        },
        onSuccess:(response) => {
            queryClient.setQueryData(
                ["contact-conversations-infinite", accountId, selectedBranch, searchConversationContact, selectedLabel, filterUnreplied],
                (oldData: any) => {
                    if (!oldData) return oldData;
                    return {
                        ...oldData,
                        pages: oldData.pages.map((page: any, pageIdx: number) => {
                            // Per page (result) map
                            let newResult: any[];
                            const hasId = page.result.some(
                                (item: any) => item.id === response.id
                            );
                            const isBranchMatch = selectedBranch.length === 0 || selectedBranch.includes(response.branch_id);

                            if (hasId && response?.id) {
                                // If the conversation with id exists, update it if branch matches, else remove it
                                if (isBranchMatch) {
                                    newResult = page.result.map((item: any) => {
                                        if (item.id === response.id) {
                                            return { ...item, ...response };
                                        }
                                        return item;
                                    });
                                } else {
                                    newResult = page.result.filter((item: any) => item.id !== response.id);
                                }
                            } else if (response.id) {
                                // If id does not exist, add it to first page only if branch matches
                                if (pageIdx === 0 && isBranchMatch) {
                                    newResult = [response, ...page.result];
                                } else {
                                    newResult = [...page.result];
                                }
                            } else {
                                newResult = [...page.result];
                            }

                            // Sort by current_conversation.last_message_at (descending)
                            newResult.sort((a: any, b: any) => {
                                const aDate = a.current_conversation?.last_message_at ? new Date(a.current_conversation.last_message_at).getTime() : 0;
                                const bDate = b.current_conversation?.last_message_at ? new Date(b.current_conversation.last_message_at).getTime() : 0;
                                return bDate - aDate;
                            });

                            return {
                                ...page,
                                result: newResult,
                            };
                        }),
                    };
                }
            );

            if (selectedContact?.id.toString() == response.id.toString()) {
                setSelectedContact(response);
                setLoadingFirstConversation(false);
                setPaginationWindow(false);
            }
        }
    });
};

export const useContactInfo = (contactId?: string, enabled: boolean = false) => {
    return useQuery({
        queryKey: ["contact-info", contactId],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<Contact>>(`/api/whatsapp/contacts/${contactId}/info`);
            return response.data.data;
        },
        enabled: enabled && !!contactId,
    });
};

export const useSetMessageCategory = () => {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: async (payload: { message_id: string; category: number | null }) => {
            return await api.put<ApiResponseDetail<Conversation>>(`/api/whatsapp/messages/${payload.message_id}/category`, {
                category: payload.category
            }).then(response => response.data);
        },
        onSuccess: (response) => {
            toast.success(response.message || "Kategori pesan berhasil diperbarui");
            queryClient.invalidateQueries({ queryKey: ["conversations-infinite"] });
        },
        onError: (error: any) => {
            toast.error(error?.response?.data?.message || "Gagal memperbarui kategori pesan");
        },
    });
};

export const useSendMessage= () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { selectedContact, setPaginationWindow, pageSelectedMessage } = useChatStore();
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn:async (payload: SendMessagePayload) => {
            const isFormData = payload instanceof FormData;
            const config = isFormData ? { headers: { 'Content-Type': 'multipart/form-data' } } : undefined;
            return await api.post<ApiResponseDetail<Conversation>>('/api/whatsapp/send-message', payload, config).then(response => response.data);
        },
        onSuccess:(response) => {
            toast.success(response.message)
            setPaginationWindow(false);
            // To update InfiniteQuery data by adding a new message to the first page:
            if(response.data.message_type != "reaction") {
                queryClient.setQueryData<InfiniteData<Collections<Conversation>>>(
                    ["conversations-infinite", accountId, selectedContact?.id, pageSelectedMessage],
                    (oldData) => {
                        if (!oldData) return oldData;
                        // Add new message to the 'result' array of the first page (index 0)
                        const newPages = oldData.pages.map((page, idx) =>
                            idx === 0
                                ? {
                                      ...page,
                                      result: [...page.result, response.data],
                                  }
                                : page
                        );
                        return {
                            ...oldData,
                            pages: newPages,
                        };
                    }
                );
            }   
        },
        onError:(error: any) => {
            if(error.status == 422) {
                let message = "";
                Object.keys(error.response?.data?.data).map((key:any) => {
                    message = error.response?.data?.data[key][0];
                })
                toast.error(message);
            } else {
                toast.error(error.response?.data?.message);
            }
        }
    })

}

// Fetch conversations with infinite scroll support
export const useInfiniteConversations = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { selectedContact, perPage, setLightBoxImages, lightBoxImages, pageSelectedMessage } = useChatStore();
    return useInfiniteQuery({
        queryKey: ["conversations-infinite", accountId, selectedContact?.id, pageSelectedMessage],
        queryFn: async ({ pageParam = 1 }) => {
            const response = await api.get<ApiResponse<Conversation>>(`/api/whatsapp/messages/${selectedContact?.id}`, {
                params: {
                    page: pageParam,
                    per_page: perPage
                }
            });

            // if(response.data.data.result) {
            //     const images: SlideImage[] = [];
            //     response.data.data.result.filter((messages) => messages.message_type === 'image' || messages.message_type === 'sticker' || messages.message_type === 'template')
            //     .map((messages) => {
            //         if(messages?.media_url) {
            //             images.push({
            //                 src: messages?.media_url
            //             })
            //         }
            //         if(messages?.message_json?.filter((fill:any) => fill.type == 'header' && fill.format == 'image').at(0)?.text){
            //             images.push({
            //                 src: messages?.message_json?.filter((fill:any) => fill.type == 'header' && fill.format == 'image').at(0)?.text
            //             })
            //         }
                   
            //     })
            //     .filter((filter) => filter);
            //     setLightBoxImages(lightBoxImages.concat(images));
            // }

            return response.data.data;
        },
        getNextPageParam: (lastPage, allPages) => {
            // Check if there are more pages
            if (lastPage.meta && lastPage.meta.current_page < lastPage.meta.last_page) {
                return lastPage.meta.current_page + 1;
            }
            return undefined;
        },
        getPreviousPageParam:(firstPage, allPages) => {
            if (firstPage.meta && firstPage.meta.current_page > 1) {
                return firstPage.meta.current_page - 1;
            }
            return undefined;
        },
        initialPageParam:pageSelectedMessage ?? 1,
        enabled: !!selectedContact?.id, // Only fetch when contact_id is available
        refetchOnMount: true,
        // refetchOnWindowFocus: true,
        // staleTime: 5 * 60 * 1000, // 5 minutes
    });
}

// Add new contact
export const useAddContact = () => {
    const queryClient = useQueryClient();
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useMutation({
        mutationFn: async (newContact: { first_name: string; last_name: string;  branch:string; phone_number: string, account_id:string, address:string, province_id:string, city_id:string }) => {
            const response = await api.post(`/api/contact`, newContact);
            return response.data;
        },
        onSuccess: (response) => {
            // Invalidate and refetch contacts
            queryClient.invalidateQueries({ queryKey: ["contacts-infinite"] });
            toast.success(response.message);
        },
        onError:(error: any) => {
            if(error.status == 422) {
                let message = "";
                Object.keys(error.response?.data?.data).map((key:any) => {
                    message = error.response?.data?.data[key][0];
                })
                toast.error(message);
            } else {
                toast.error(error.response?.data?.message);
            }
        }
    });
};


// Edit contact
export const useEditContact = () => {
    const queryClient = useQueryClient();
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { setContact,selectedBranch,setSelectedContact, searchConversationContact, selectedLabel, searchContact, filterUnreplied } = useChatStore();
    const contactDetailMutation = useContactDetail();

    return useMutation({
        mutationFn: async (updateContact: { first_name: string; last_name: string;  branch:string; phone_number: string, account_id:string; contact_id:string; province_id:string; city_id:string; address:string}) => {
            const response = await api.put(`/api/contact/${updateContact.contact_id}`, updateContact);
            return response.data;
        },
        onSuccess: (response) => {
            // Invalidate and refetch contacts
            // queryClient.invalidateQueries({ queryKey: ["contacts-infinite"] });
            queryClient.setQueryData(
                ["contacts-infinite", accountId, searchContact],
                (oldData: any) => {
                if (!oldData) return oldData;
                return {
                    ...oldData,
                    pages: oldData.pages.map((page: any, pageIdx: number) => {
                        // Per page (result) map
                        let newResult: any[];
                        const hasId = page.result.some(
                            (item: any) => item.id === response.data?.id
                        );
                        if (hasId && response.data.id) {
                            // If the conversation with id exists, update it
                            newResult = page.result.map((item: any) => {
                                if (item.id === response.data.id) {
                                    return { ...item, ...response.data };
                                }
                                return item;
                            });
                        } else if (response.data.id) {
                            // If id does not exist, add it to first page only
                            if (pageIdx === 0) {
                                newResult = [response.data, ...page.result];
                            } else {
                                newResult = [...page.result];
                            }
                        } else {
                            newResult = [...page.result];
                        }
                        return {
                            ...page,
                            result: newResult,
                        };
                    }),
                };
            });


            queryClient.setQueryData(
                ["contact-conversations-infinite", accountId, selectedBranch, searchConversationContact, selectedLabel, filterUnreplied],
                (oldData: any) => {
                    if (!oldData) return oldData;
                    return {
                        ...oldData,
                        pages: oldData.pages.map((page: any, pageIdx: number) => {
                            // Per page (result) map
                            let newResult: any[];
                            const hasId = page.result.some(
                                (item: any) => item.id === response.data?.id
                            );
                            const isBranchMatch = selectedBranch.length === 0 || selectedBranch.includes(response.data?.branch_id);

                            if (hasId && response.data?.id) {
                                // If the conversation with id exists, update it if branch matches, else remove it
                                if (isBranchMatch) {
                                    newResult = page.result.map((item: any) => {
                                        if (item.id === response.data.id) {
                                            return { ...item, ...response.data };
                                        }
                                        return item;
                                    });
                                } else {
                                    newResult = page.result.filter((item: any) => item.id !== response.data.id);
                                }
                            } else if (response.data?.id) {
                                // If id does not exist, add it to first page only if branch matches
                                if (pageIdx === 0 && isBranchMatch) {
                                    newResult = [response.data, ...page.result];
                                } else {
                                    newResult = [...page.result];
                                }
                            } else {
                                newResult = [...page.result];
                            }

                            // Sort by current_conversation.last_message_at (descending)
                            newResult.sort((a: any, b: any) => {
                                const aDate = a.current_conversation?.last_message_at ? new Date(a.current_conversation.last_message_at).getTime() : 0;
                                const bDate = b.current_conversation?.last_message_at ? new Date(b.current_conversation.last_message_at).getTime() : 0;
                                return bDate - aDate;
                            });

                            return {
                                ...page,
                                result: newResult,
                            };
                        }),
                    };
                }
            );

            setContact(response.data);
            // setSelectedContact(response.data);
            contactDetailMutation.mutateAsync(response.data.id.toString() || '');
            toast.success(response.message);
        },
        onError:(error: any) => {
            if(error.status == 422) {
                let message = "";
                Object.keys(error.response?.data?.data).map((key:any) => {
                    message = error.response?.data?.data[key][0];
                })
                toast.error(message);
            } else {
                toast.error(error.response?.data?.message);
            }
        }
    });
};



export const useEditLabelContact = () => {
    const queryClient = useQueryClient();
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { setContact,selectedBranch,setSelectedContact, searchConversationContact, selectedLabel, filterUnreplied, selectedContact, setContactId } = useChatStore();
    const contactDetailMutation = useContactDetail();

    return useMutation({
        mutationFn: async (updateContact: {label_id:string; contact_id:string}) => {
            const response = await api.post(`/api/label/contact`, updateContact);
            return response.data;
        },
        onSuccess: (response) => {
            queryClient.invalidateQueries({ queryKey: ["contacts-infinite"] });
            queryClient.invalidateQueries({ queryKey: ["contact-conversations-infinite"] });
            contactDetailMutation.mutateAsync(selectedContact?.id.toString() || '');
            toast.success(response.message);
        },
        onError:(error: any) => {
            if(error.status == 422) {
                let message = "";
                Object.keys(error.response?.data?.data).map((key:any) => {
                    message = error.response?.data?.data[key][0];
                })
                toast.error(message);
            } else {
                toast.error(error.response?.data?.message);
            }
        }
    });
};

export const useWhatsappProfile = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useQuery({
        queryKey: ["profile-bussiness"],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<BussinessProfile>>(`/api/whatsapp/business/profile`, {
                params: {
                    account_id: accountId,
                }
            });

            // Map API response to Conversation interface
            return response.data.data;
        },
    });
}

export const useTemplates = (enabled:boolean) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useQuery({
        queryKey:["templates"],
        queryFn:async () => {
            const response = await api.get(`/api/whatsapp/template`, {
                params: {
                    account_id: accountId,
                }
            });

            return response.data.data;
        },
        enabled:enabled,
        refetchOnWindowFocus:true
    })
}

export const useLabel = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useQuery({
        queryKey: ["labels"],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<LabelContact[]>>(`/api/label/list`, {
                params: {
                    account_id: accountId,
                }
            });
            return response.data.data;
        },
    });
}

export const useSyncMessage = (messageId?: string | undefined) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const {selectedContact, pageSelectedMessage} = useChatStore();
    const queryClient = useQueryClient();

    return useQuery({
        queryKey: ["sync-message", messageId],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<Conversation>>(`/api/whatsapp/message/sync/${messageId}`);
            queryClient.setQueryData(
                ["conversations-infinite", accountId, selectedContact?.id, pageSelectedMessage],
                (oldData: any) => {
                    if (!oldData) return oldData;
                    return {
                        ...oldData,
                        pages: oldData.pages.map((page: any, pageIdx: number) => {
                            // Per page (result) map
                            const hasId = page.result.some(
                                (item: any) => item.id === response.data.data?.id
                            );
                            if (hasId && response.data.data?.id) {
                                // If the conversation with id exists, update it
                                return {
                                    ...page,
                                    result: page.result.map((item: any) => {
                                        if (item.id === response.data.data.id) {
                                            return { ...item, ...response.data.data };
                                        }
                                        return item;
                                    }),
                                };
                            } else if (response.data.data?.id) {
                                // If id does not exist, add it to first page only
                                if (pageIdx === 0) {
                                    return {
                                        ...page,
                                        result: [...page.result, response.data.data],
                                    };
                                }
                                return page;
                            }
                            return page;
                        }),
                    };
                }
            );
            return response.data.data;
        },
        enabled:false
    });
}


export const useSyncMedia = (messageId?: string | undefined) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const {selectedContact} = useChatStore();
    const queryClient = useQueryClient();

    return useQuery({
        queryKey: ["sync-message", messageId],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<Conversation>>(`/api/whatsapp/message/download/${messageId}`);
            queryClient.setQueryData(
                ["conversations-infinite", accountId, selectedContact?.id],
                (oldData: any) => {
                    if (!oldData) return oldData;
                    return {
                        ...oldData,
                        pages: oldData.pages.map((page: any, pageIdx: number) => {
                            // Per page (result) map
                            const hasId = page.result.some(
                                (item: any) => item.id === response.data.data?.id
                            );
                            if (hasId && response.data.data?.id) {
                                // If the conversation with id exists, update it
                                return {
                                    ...page,
                                    result: page.result.map((item: any) => {
                                        if (item.id === response.data.data.id) {
                                            return { ...item, ...response.data.data };
                                        }
                                        return item;
                                    }),
                                };
                            } else if (response.data.data?.id) {
                                // If id does not exist, add it to first page only
                                if (pageIdx === 0) {
                                    return {
                                        ...page,
                                        result: [...page.result, response.data.data],
                                    };
                                }
                                return page;
                            }
                            return page;
                        }),
                    };
                }
            );
            return response.data.data;
        },
        enabled:false
    });
}


export const useBrokenFile = (mediaPath?: string) => {
    return useQuery({
        queryKey: ["broken-image", mediaPath],
        // Only run on client side where Image object exists
        queryFn: async () => await axios.get(`${process.env.NEXT_PUBLIC_API_HOST}/check-file`,{
            params:{
                path:mediaPath
            }
        }).then(() => false).catch(() => true),
        enabled: typeof window !== "undefined" && !!mediaPath, // Only run in browser
    });
}


export const useCallInitiate  = (to:string, sdp:string) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;

    return useQuery({
        queryKey: ["call-initiate"],
        queryFn: async () => {
            const response = await api.post<ApiResponseDetail<CallIntiate>>(`api/whatsapp/calls/initiate`, {
                account_id: accountId,
                to:to,
                sdp:sdp
                    
            });
            return response.data.data;
        },
        enabled:!!to && !!sdp
    });
}

export const useSearchMessages = (search: string) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    
    return useQuery({
        queryKey: ["search-messages", accountId, search],
        queryFn: async () => {
            const response = await api.get<ApiResponse<Conversation>>(`/api/whatsapp/messages`, {
                params: {
                    search: search,
                    account_id: accountId,
                    per_page: 50,
                    sort:'desc'
                }
            });
            return response.data.data;
        },
        enabled: !!search && search.length > 0, // ensure client side
    });
}

export const usePageMessage = () => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    const { selectedContact, pageMessageId } = useChatStore();
    return useQuery({
        queryKey: ["page-message", accountId, pageMessageId],
        queryFn: async () => {
            const response = await api.get<ApiResponseDetail<{page:number}>>(`/api/whatsapp/messages/page/get`, {
                params: {
                    message_id: pageMessageId,
                    contact_id: selectedContact?.id,
                    account_id:accountId,
                    per_page: 10
                }
            });
            return response.data.data;
        },
        enabled: !!pageMessageId && !!selectedContact?.id,
    });
}

// Fetch bookmarks
export const useGetBookmarks = (page: number = 1) => {
    const accountId = process.env.NEXT_PUBLIC_APP_ACCOUNT_ID_WHATSAPP_SERVICE;
    return useQuery({
        queryKey: ["bookmarks", accountId, page],
        queryFn: async () => {
            const response = await api.get<ApiResponse<Conversation>>(`/api/whatsapp/bookmarks`, {
                params: {
                    page: page,
                    per_page: 30,
                    account_id: accountId
                }
            });
            return response.data.data;
        },
        refetchOnWindowFocus: false,
    });
}

// Bookmark a message
export const useBookmarkMessage = () => {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: async ({ messageId, madedBy }: { messageId: string, madedBy: string }) => {
            const response = await api.post(`/api/whatsapp/messages/${messageId}/bookmark`, {
                maded_by: madedBy
            });
            return response.data;
        },
        onSuccess: (response) => {
            toast.success(response.message);
            // Invalidate to refresh UI if needed
            queryClient.invalidateQueries({ queryKey: ["conversations-infinite"] });
            queryClient.invalidateQueries({ queryKey: ["bookmarks"] });
        },
        onError: (error: any) => {
            toast.error(error.response?.data?.message || 'Gagal menambahkan bookmark');
        }
    });
}

// Remove bookmark
export const useRemoveBookmarkMessage = () => {
    const queryClient = useQueryClient();
    return useMutation({
        mutationFn: async (messageId: string) => {
            const response = await api.delete(`/api/whatsapp/messages/${messageId}/bookmark`);
            return response.data;
        },
        onSuccess: (response) => {
            toast.success(response.message);
            queryClient.invalidateQueries({ queryKey: ["conversations-infinite"] });
            queryClient.invalidateQueries({ queryKey: ["bookmarks"] });
        },
        onError: (error: any) => {
            toast.error(error.response?.data?.message || 'Gagal menghapus bookmark');
        }
    });
}