app.js

import express from "express";
import { connectDB } from "./utils/mongoInit.js";
import dotenv from "dotenv";
import { errorMiddlewares } from "./middlewares/error.js";
import cookieParser from "cookie-parser";
import { Server } from "socket.io";
import { createServer } from "http";
import cors from "cors";
import userRoute from "./routes/user.js";
import chatRoute from "./routes/chat.js";
import { v2 as cloudinary } from "cloudinary";
import {
  CHAT_JOINED,
  CHAT_LEAVED,
  NEW_MESSAGE,
  NEW_MESSAGE_ALERT,
  ONLINE_USERS,
  START_TYPING,
  STOP_TYPING,
} from "./constants/event.js";
import { getSockets } from "./lib/socket.js";
import { Message } from "./models/message.js";
import { corsOptions } from "./constants/config.js";
import { socketAuthenticator } from "./middlewares/socketAuth.js";

dotenv.config();
connectDB(process.env.MONGO_URI);

cloudinary.config({
  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
  api_key: process.env.CLOUDINARY_API_KEY,
  api_secret: process.env.CLOUDINARY_API_SECRET,
});

const app = express();
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Credentials', 'true');
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
  next();
});
app.use(cors(corsOptions));

const server = createServer(app);
const io = new Server(server, {
  cors: corsOptions,
  transports: ['polling', 'websocket'],
  withCredentials: true,  
});
app.set("io", io);
const userSocketIDs = new Map();
const onlineUsers = new Set();

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(cookieParser());

app.use("/api/v1/user", userRoute);
app.use("/api/v1/chat", chatRoute);

io.use((socket, next) => {
  cookieParser()(socket.request, socket.request.res, async (err) => {
    try {
      await socketAuthenticator(err, socket, next);
    } catch (error) {
      console.error("Socket authentication error:", error);
      next(new Error("Authentication error"));
    }
  });
});

io.on("connection", (socket) => {
  const user = socket.user;
  userSocketIDs.set(user._id.toString(), socket.id);
  // console.log(userSocketIDs);
  socket.on(
    NEW_MESSAGE,
    async ({ chatId, members, message, isSystem = false }) => {
      try {
        const newMessage = await Message.create({
          content: message,
          sender: isSystem ? null : user._id,
          chat: chatId,
          isSystem,
        });
        const messageForRealTime = {
          content: message,
          _id: newMessage._id.toString(),
          sender: isSystem
            ? { _id: "system", name: "System" }
            : { _id: user._id, name: user.name },
          chat: chatId,
          createdAt: new Date().toISOString(),
          isSystem,
        };

        const membersSocket = getSockets(members);
        io.to(membersSocket).emit(NEW_MESSAGE, {
          chatId,
          message: messageForRealTime,
        });
        io.to(membersSocket).emit(NEW_MESSAGE_ALERT, { chatId });
      } catch (error) {
        console.log(error);
      }
    }
  );
  socket.on(START_TYPING, ({ members, chatId }) => {
    const membersSockets = getSockets(members);
    socket.to(membersSockets).emit(START_TYPING, { chatId });
  });
  socket.on(STOP_TYPING, ({ members, chatId }) => {
    const membersSockets = getSockets(members);
    socket.to(membersSockets).emit(STOP_TYPING, { chatId });
  });

  socket.on(CHAT_JOINED, ({ userId, members }) => {
    onlineUsers.add(userId.toString());
    const memberSockets = getSockets(members);
    io.to(memberSockets).emit(ONLINE_USERS, Array.from(onlineUsers));
  });
  socket.on(CHAT_LEAVED, ({ userId, members }) => {
    onlineUsers.delete(userId.toString());
    const memberSockets = getSockets(members);
    io.to(memberSockets).emit(ONLINE_USERS, Array.from(onlineUsers));
  });

  socket.on("disconnect", () => {
    console.log("user disconnected");
    userSocketIDs.delete(user._id.toString());
    onlineUsers.delete(user._id.toString());
  });
});

app.use(errorMiddlewares);

const port = process.env.PORT || 8000;
server.listen(port, () => {
  console.log(`Server running at port ${port}`);
});

export { userSocketIDs };