server.js

const { createServer } = require("http");
const { parse } = require("url");
const next = require("next");
const { Server: SocketIOServer } = require("socket.io");
const { v4: uuidv4 } = require("uuid");

const dev = process.env.NODE_ENV !== "production";
const hostname = "localhost";
const port = process.env.PORT || 3000;

const app = next({ dev, hostname, port });
const handle = app.getRequestHandler();

// In-memory storage for rooms (no persistence as requested)
const rooms = new Map();

app.prepare().then(() => {
  const httpServer = createServer(async (req, res) => {
    try {
      const parsedUrl = parse(req.url, true);
      await handle(req, res, parsedUrl);
    } catch (err) {
      console.error("Error occurred handling", req.url, err);
      res.statusCode = 500;
      res.end("internal server error");
    }
  });

  const io = new SocketIOServer(httpServer, {
    cors: {
      origin: "*",
      methods: ["GET", "POST"],
    },
  });

  io.on("connection", (socket) => {
    console.log("User connected:", socket.id);

    socket.on("join-room", ({ roomCode, username }) => {
      console.log(`User ${username} joining room ${roomCode}`);

      socket.join(roomCode);

      // Add user to room tracking
      if (!rooms.has(roomCode)) {
        rooms.set(roomCode, new Set());
      }
      const roomUsers = rooms.get(roomCode);
      roomUsers.add({ id: socket.id, username });

      // Store user info in socket
      socket.roomCode = roomCode;
      socket.username = username;

      // Notify others that user joined (but not the user who just joined)
      const joinMessage = {
        id: uuidv4(),
        type: "user_joined",
        content: `${username} joined the chat`,
        timestamp: Date.now(),
      };

      socket
        .to(roomCode)
        .emit("user-joined", { username, message: joinMessage });

      // Send updated online users list to everyone
      const onlineUsers = Array.from(roomUsers).map((user) => user.username);
      io.to(roomCode).emit("online-users", onlineUsers);
    });

    socket.on("send-message", ({ roomCode, content, username }) => {
      const message = {
        id: uuidv4(),
        type: "message",
        content,
        username,
        timestamp: Date.now(),
      };

      // Send to all users in the room (including sender)
      io.to(roomCode).emit("message", message);
    });

    socket.on("typing", ({ roomCode, username, isTyping }) => {
      // Send typing status to all other users in the room (not the sender)
      socket.to(roomCode).emit("user-typing", { username, isTyping });
    });

    socket.on("disconnect", () => {
      console.log("User disconnected:", socket.id);

      const roomCode = socket.roomCode;
      const username = socket.username;

      if (roomCode && username) {
        const roomUsers = rooms.get(roomCode);
        if (roomUsers) {
          // Remove user from room
          for (const user of Array.from(roomUsers)) {
            if (user.id === socket.id) {
              roomUsers.delete(user);
              break;
            }
          }

          // If room is empty, remove it
          if (roomUsers.size === 0) {
            rooms.delete(roomCode);
            console.log(`Room ${roomCode} deleted (empty)`);
          } else {
            // Notify others that user left
            const leaveMessage = {
              id: uuidv4(),
              type: "user_left",
              content: `${username} left the chat`,
              timestamp: Date.now(),
            };

            socket
              .to(roomCode)
              .emit("user-left", { username, message: leaveMessage });

            // Send updated online users list
            const onlineUsers = Array.from(roomUsers).map(
              (user) => user.username
            );
            socket.to(roomCode).emit("online-users", onlineUsers);
          }
        }
      }
    });
  });

  httpServer
    .once("error", (err) => {
      console.error(err);
      process.exit(1);
    })
    .listen(port, () => {
      console.log(`> Ready on http://${hostname}:${port}`);
    });
});