import { useEffect, useRef, useCallback, useState } from 'react'; import { io, Socket } from 'socket.io-client'; interface SessionStatusEvent { sessionId: string; status: string; timestamp: string; } interface QRCodeEvent { sessionId: string; qrCode: string; timestamp: string; } interface MessageEvent { sessionId: string; message: Record; timestamp: string; } interface MessageAckEvent { sessionId: string; messageId: string; ack: number; ackName: string; chatId?: string; timestamp: string; } interface MessageReactionEvent { sessionId: string; messageId: string; chatId: string; reaction: string; senderId: string; reactions: Record; timestamp: string; } interface MessageRevokedEvent { sessionId: string; id: string; chatId: string; from: string; to: string; body: string; type: string; timestamp: number; } interface WebSocketEvents { onSessionStatus?: (event: SessionStatusEvent) => void; onQRCode?: (event: QRCodeEvent) => void; onMessage?: (event: MessageEvent) => void; onMessageAck?: (event: MessageAckEvent) => void; onMessageReaction?: (event: MessageReactionEvent) => void; onMessageRevoked?: (event: MessageRevokedEvent) => void; } // Shape of the server -> client event envelope produced by the NestJS gateway. interface ServerEventEnvelope { type: string; timestamp: string; payload?: { event: string; sessionId: string; data: Record; }; } // Use current origin for WebSocket (goes through nginx proxy in Docker) // Falls back to env var or localhost for development const SOCKET_URL = import.meta.env.VITE_WS_URL || window.location.origin; export function useWebSocket(events: WebSocketEvents = {}) { const socketRef = useRef(null); const [isConnected, setIsConnected] = useState(false); const connect = useCallback(() => { if (socketRef.current?.connected) return; // Get API key from sessionStorage (same as api.ts) const apiKey = sessionStorage.getItem('openwa_api_key'); if (!apiKey) { console.warn('[WebSocket] No API key found, skipping connection'); return; } socketRef.current = io(`${SOCKET_URL}/events`, { autoConnect: true, reconnection: true, reconnectionAttempts: 5, reconnectionDelay: 1000, auth: { apiKey, }, extraHeaders: { 'X-API-Key': apiKey, }, query: { apiKey, }, }); socketRef.current.on('connect', () => { setIsConnected(true); }); socketRef.current.on('disconnect', () => { setIsConnected(false); }); socketRef.current.on('connect_error', error => { console.warn('[WebSocket] Connection error:', error.message); }); }, []); const subscribe = useCallback((sessionId: string, eventsList: string[]) => { if (socketRef.current?.connected) { socketRef.current.emit('message', { type: 'subscribe', sessionId, events: eventsList, }); } }, []); const unsubscribe = useCallback((sessionId: string) => { if (socketRef.current?.connected) { socketRef.current.emit('message', { type: 'unsubscribe', sessionId, }); } }, []); useEffect(() => { connect(); return () => { if (socketRef.current) { socketRef.current.disconnect(); socketRef.current = null; } }; }, [connect]); // Register the single envelope handler and fan out to the typed callbacks. useEffect(() => { if (!socketRef.current) return; const socket = socketRef.current; const handleIncomingMessage = (msg: ServerEventEnvelope) => { if (!msg || msg.type !== 'event' || !msg.payload) return; const { event, sessionId, data } = msg.payload; switch (event) { case 'session.status': events.onSessionStatus?.({ sessionId, status: String(data.status), timestamp: msg.timestamp }); break; case 'session.qr': events.onQRCode?.({ sessionId, qrCode: String(data.qrCode), timestamp: msg.timestamp }); break; case 'message.received': case 'message.sent': events.onMessage?.({ sessionId, message: data, timestamp: msg.timestamp }); break; case 'message.ack': events.onMessageAck?.({ sessionId, messageId: String(data.messageId), ack: Number(data.ack), ackName: String(data.ackName), chatId: data.chatId as string | undefined, timestamp: msg.timestamp, }); break; case 'message.reaction': events.onMessageReaction?.({ sessionId, messageId: String(data.messageId), chatId: String(data.chatId), reaction: String(data.reaction), senderId: String(data.senderId), reactions: (data.reactions as Record) || {}, timestamp: msg.timestamp, }); break; case 'message.revoked': events.onMessageRevoked?.({ sessionId, id: String(data.id), chatId: String(data.chatId), from: String(data.from), to: String(data.to), body: String(data.body ?? ''), type: String(data.type), timestamp: Number(data.timestamp), }); break; default: break; } }; socket.on('message', handleIncomingMessage); return () => { socket.off('message', handleIncomingMessage); }; }, [events]); return { isConnected, subscribe, unsubscribe }; }