Update SocketContext.jsx

client/src/common/contexts/SocketContext/SocketContext.jsx

@@ -1,64 +1,99 @@
-import { createContext, useState, useEffect, useCallback } from 'react';
+import {createContext, useState, useEffect, useCallback, useRef} from 'react';
-import { io } from 'socket.io-client';
+import {io} from 'socket.io-client';
 
 export const SocketContext = createContext();
 
-export const SocketProvider = ({ children }) => {
+export const SocketProvider = ({children}) => {
-  const [socket, setSocket] = useState(null);
+    const [socket, setSocket] = useState(null);
-  const [connected, setConnected] = useState(false);
+    const [connected, setConnected] = useState(false);
+    const connectAttempts = useRef(0);
+    const maxAttempts = 3;
 
-  const connect = useCallback(() => {
+    const connect = useCallback(() => {
-    if (!socket) {
+        if (socket) return;
-      const newSocket = io(window.location.hostname === 'localhost' ? 'http://localhost:5287' : '/');
-      
-      newSocket.on('connect', () => {
-        setConnected(true);
-        console.log('Socket connected');
-      });
-      
-      newSocket.on('disconnect', () => {
-        setConnected(false);
-        console.log('Socket disconnected');
-      });
 
-      setSocket(newSocket);
+        const serverUrl = process.env.NODE_ENV === 'production' ? window.location.origin : 'http://localhost:5287';
-    }
-  }, [socket]);
 
-  const disconnect = useCallback(() => {
+        try {
-    if (socket) {
+            const newSocket = io(serverUrl, {
-      socket.disconnect();
+                reconnectionAttempts: 3,
-      setSocket(null);
+                timeout: 10000,
-      setConnected(false);
+                reconnectionDelay: 1000
-    }
+            });
-  }, [socket]);
 
-  const send = useCallback((event, data) => {
+            newSocket.on('connect', () => {
-    if (socket) {
+                console.log('Socket connected with ID:', newSocket.id);
-      socket.emit(event, data);
+                setConnected(true);
-    } else {
+                connectAttempts.current = 0;
-      console.error('Cannot send event, socket not connected');
+            });
-    }
-  }, [socket]);
 
-  const on = useCallback((event, callback) => {
+            newSocket.on('disconnect', (reason) => {
-    if (socket) {
+                console.log('Socket disconnected:', reason);
-      socket.on(event, callback);
+                setConnected(false);
-    }
+            });
-    return () => {
-      if (socket) socket.off(event, callback);
-    };
-  }, [socket]);
 
-  useEffect(() => {
+            newSocket.on('connect_error', (error) => {
-    return () => {
+                console.error('Connection error:', error);
-      if (socket) socket.disconnect();
+                connectAttempts.current += 1;
-    };
-  }, [socket]);
 
-  return (
+                if (connectAttempts.current >= maxAttempts) {
-    <SocketContext.Provider value={{ connected, connect, disconnect, send, on, socket }}>
+                    console.error('Max connection attempts reached, giving up');
-      {children}
+                    newSocket.disconnect();
-    </SocketContext.Provider>
+                }
-  );
+            });
+
+            setSocket(newSocket);
+        } catch (err) {
+            console.error('Error creating socket connection:', err);
+        }
+    }, [socket]);
+
+    const disconnect = useCallback(() => {
+        if (socket) {
+            socket.disconnect();
+            setSocket(null);
+            setConnected(false);
+            console.log('Socket manually disconnected');
+        }
+    }, [socket]);
+
+    const send = useCallback((event, data) => {
+        if (!socket || !connected) {
+            console.warn(`Cannot send event "${event}": socket not connected`);
+            return false;
+        }
+
+        try {
+            socket.emit(event, data);
+            return true;
+        } catch (err) {
+            console.error(`Error sending event "${event}":`, err);
+            return false;
+        }
+    }, [socket, connected]);
+
+    const on = useCallback((event, callback) => {
+        if (!socket) {
+            console.warn(`Cannot listen for event "${event}": socket not initialized`);
+            return () => {
+            };
+        }
+
+        socket.on(event, callback);
+        return () => socket.off(event, callback);
+    }, [socket]);
+
+    useEffect(() => {
+        return () => {
+            if (socket) {
+                socket.disconnect();
+            }
+        };
+    }, [socket]);
+
+    return (
+        <SocketContext.Provider value={{socket, connected, connect, disconnect, send, on}}>
+            {children}
+        </SocketContext.Provider>
+    );
 };