import { useEffect, useRef } from 'react';
import { io } from 'socket.io-client';
import { formatTimeStr } from './useChatLogic';
import { Message } from '../types';

interface UseWhatsAppSocketOptions {
  sessionUserId: string | number | undefined;
  onMessageReceived: (convId: string | number, leadId: string | number, newMsg: Message, rawLog: any) => void;
  onStatusUpdated: (convId: string | number, messageId: string, status: string) => void;
  onUnreadCount?: (counts: { unread_count: number; conversations_with_unread: number }) => void;
}

export function useWhatsAppSocket({ sessionUserId, onMessageReceived, onStatusUpdated, onUnreadCount }: UseWhatsAppSocketOptions) {
  const onMessageRef = useRef(onMessageReceived);
  const onStatusRef = useRef(onStatusUpdated);
  const onUnreadCountRef = useRef(onUnreadCount);

  useEffect(() => {
    onMessageRef.current = onMessageReceived;
    onStatusRef.current = onStatusUpdated;
    onUnreadCountRef.current = onUnreadCount;
  }, [onMessageReceived, onStatusUpdated, onUnreadCount]);

  useEffect(() => {
    if (!sessionUserId) return;

    let socketUrl = process.env.NEXT_PUBLIC_BACKEND_URL || process.env.BACKEND_URL || 'http://localhost:4085';
    if (socketUrl.endsWith('/')) socketUrl = socketUrl.slice(0, -1);

    const socket = io(socketUrl, {
      query: { userId: sessionUserId },
      transports: ['websocket'],
      extraHeaders: { 'ngrok-skip-browser-warning': 'true' },
    });

    socket.on('connect', () => console.log('Socket connected:', socket.id));
    socket.on('registered', (data) => console.log('Registered with room:', data));

    socket.on('whatsapp_message', (data: any) => {
      console.log('Received whatsapp_message via socket:', data);

      const log = data.log || data;
      if (!log || !log.message_id) return;

      const convId = data.conversation_id || log.conversation_id;
      const leadId =
        data.lead_id ||
        (sessionUserId && String(log.sender_id) === String(sessionUserId)
          ? log.receiver_id
          : log.sender_id);

      const dateObj = log.created_at ? new Date(log.created_at) : new Date();
      const timeStr = formatTimeStr(dateObj);
      const isMessageSent =
        sessionUserId && String(log.sender_id) === String(sessionUserId);

      const newMsg: Message = {
        id: log.message_id || String(log.id),
        text: log.message || '',
        timestamp: `TODAY, ${timeStr}`,
        type: isMessageSent ? 'sent' : 'received',
        message_status: log.message_status || log.status || 'received',
        createdAt: log.created_at || dateObj.toISOString(),
        message_type: log.message_type || log.type,
        fileName: log.filename,
        logId: log.id,
        whatsappMessageId: log.message_id,
      };

      if (onMessageRef.current) {
        onMessageRef.current(convId, leadId, newMsg, log);
      }
    });

    socket.on('whatsapp_status', (data: any) => {
      console.log('Received whatsapp_status via socket:', data);
      const { conversation_id, message_id, status, message_status } = data;
      const resolvedStatus = status || message_status;
      if (!conversation_id || !message_id || !resolvedStatus) return;

      if (onStatusRef.current) {
        onStatusRef.current(conversation_id, message_id, resolvedStatus);
      }
    });

    socket.on('whatsapp_unread_count', (data: any) => {
      if (!data || !onUnreadCountRef.current) return;
      onUnreadCountRef.current({
        unread_count: Number(data.unread_count) || 0,
        conversations_with_unread: Number(data.conversations_with_unread) || 0,
      });
    });

    return () => {
      socket.disconnect();
    };
  }, [sessionUserId]); // Removing callbacks from dependencies array
}
