import { getPrivateChannel } from "@/components/common/common";
import { UpdateChat } from "@/hooks/ChatReducer";
import { ChatMessageData } from "@/hooks/Interface";
import { useEffect, useRef } from "react";

const useMessageRecieverEventListener = (
  activeUser: any,
  currentLoggedUserId: number,
  roomId: string,
  dispatch: any,
  scrollToDown: () => void,
  markMessageAsRead: (messageId: string, roomId: string) => void,
  messageReadEvent: (
    roomId: string,
    userId: number,
    message: string,
    message_type?: string,
    id?: string
  ) => void
) => {
  // Use ref to track the active channel
  const channelRef = useRef<any>(null);
  const {
    room_id: activeUserRoomId,
    request_status,
    is_group,
    group_users,
  } = activeUser;

  useEffect(() => {
    // Clear existing subscription

    // Only subscribe if we have both Echo and room_id
    if ((window as any).Echo && activeUserRoomId) {
      const privateChannel = getPrivateChannel(activeUserRoomId);
      channelRef.current = privateChannel;

      const messageReceiveListener = (e: any) => {
        const {
          userName,
          message,
          sender_id,
          replied_parent_id,
          replied_message,
          id: messageId,
          message_type,
          request_status,
          buyer_seller_rating,
          id,
        } = e;
        if (message_type === "quot" && +sender_id === +currentLoggedUserId) {
          const msgData: ChatMessageData = {
            room_id: roomId,
            user_name: userName,
            sender_id: +sender_id,
            message,
            id: messageId,
            replied_parent_id,
            replied_message,
            created_at: new Date().toISOString(),
            read: "sent",
            message_type,
          };

          // Dispatch message update
          dispatch(UpdateChat([msgData]));
        }
        if (request_status === "pending" || +sender_id === +currentLoggedUserId)
          return;
        // Check if message should be processed
        const getFirstUserId =
          activeUser && typeof activeUser?.id === "string"
            ? +activeUser.id.split(",")[0]
            : "";
        // const isGroupMessage = is_group === 1;
        // const isDirectMessage = +sender_id === +getFirstUserId;
        // if (isGroupMessage || isDirectMessage) {
        const msgData: ChatMessageData = {
          room_id: roomId,
          user_name: userName,
          sender_id: +sender_id,
          message,
          id: messageId,
          replied_parent_id,
          replied_message,
          created_at: new Date().toISOString(),
          read: "sent",
          message_type,
        };

        // Dispatch message update
        dispatch(UpdateChat([msgData]));

        // Mark message as read and trigger read event
        markMessageAsRead(messageId, roomId);
        messageReadEvent(
          roomId,
          sender_id ? +sender_id : +activeUser.id,
          message,
          message_type,
          id
        );

        // Schedule scroll after message is processed
        requestAnimationFrame(() => {
          scrollToDown();
        });
        // }
      };

      // Subscribe to channel
      privateChannel.listen("MessageSent", messageReceiveListener);

      // Cleanup function
      return () => {
        if (channelRef.current) {
          channelRef.current.stopListening("MessageSent");
          channelRef.current = null;
        }
      };
    }
  }, [activeUser?.room_id]); // Only depend on room_id changes
};

export default useMessageRecieverEventListener;