import "dotenv/config";
import express from "express";
import { createServer } from "http";
import { Server } from "socket.io";
import ActiveSession from "./models/ActiveSession";
import connectDB from "./config/db";

connectDB();

const app = express();
const port = process.env.PORT || 3000;
const server = createServer(app);
const io = new Server(server, {
  cors: {
    origin: "*",
  },
});

io.on("connection", async (socket) => {
  const { roomId, user } = socket.handshake.auth;

  user.ownerIp = socket.handshake.headers["x-real-ip"];

  let activeSession;

  try {
    activeSession = await ActiveSession.findById(roomId);
  } catch (error) {
    console.log((error as Error).message);
  }

  if (activeSession?.ownerIp === user.ownerIp || user.superAdmin) {
    user.isAdmin = true;
    user.isControlAllowed = true;
  } else {
    user.isAdmin = false;
    user.isControlAllowed = false;
  }

  // console.log("socket.conn.remoteAddress", socket.conn.remoteAddress);
  // console.log("socket.handshake.address", socket.handshake.address);

  socket.join(roomId);

  const sockets = await io.in(roomId).fetchSockets();

  io.to(roomId).emit(
    "update",
    sockets.map((socket) => socket.handshake.auth.user)
  );

  try {
    await ActiveSession.findByIdAndUpdate(roomId, {
      connectedPlayersCount: sockets.length,
    });
  } catch (error) {}

  socket.on("request-control", async (userId) => {
    io.to(roomId).emit(
      "request-control",
      sockets.find((socket) => socket.handshake.auth.user.id === userId)
        ?.handshake.auth.user.id
    );
  });

  socket.on("transfer-control", async (userId) => {
    const sockets = await io.in(roomId).fetchSockets();

    const roomUsers = sockets.map((socket) => socket.handshake.auth.user);
    const updatedRoomUsers = roomUsers.map((roomUser) => {
      if (roomUser.id === userId) {
        io.to(roomId).emit("transfer-control", userId);
        roomUser.isControlAllowed = true;
      } else {
        roomUser.isControlAllowed = false;
      }

      return roomUser;
    });

    io.to(roomId).emit("update", updatedRoomUsers);
  });

  socket.on("message", (text) => {
    io.to(roomId).emit("message", {
      userId: socket.handshake.auth.user.id,
      text,
    });
  });

  socket.on("disconnect", async () => {
    const sockets = await io.in(roomId).fetchSockets();

    io.to(roomId).emit(
      "update",
      sockets.map((socket) => socket.handshake.auth.user)
    );

    try {
      await ActiveSession.findByIdAndUpdate(roomId, {
        connectedPlayersCount: sockets.length,
      });
    } catch (error) {}
  });
});

server.listen(port, () => {
  console.log(`Server is listening on port ${port}`);
});