server.ts

import express from "express";
import { createServer } from "http";
import next from "next";
import { Server as SocketIOServer } from "socket.io";
import {
  GameRoom,
  createRoom,
  addPlayer,
  removePlayer,
  startNewRound,
  submitAnswer,
  getGameState,
  generateRoomCode,
} from "./src/lib/gameLogic";
import { solve } from "./src/lib/solver";

const dev = process.env.NODE_ENV !== "production";
const hostname = dev ? "localhost" : "0.0.0.0";
const port = parseInt(process.env.PORT || "3000", 10);

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

const rooms = new Map<string, GameRoom>();
const roomTimers = new Map<string, NodeJS.Timeout>();

function clearRoundTimer(roomId: string) {
  const timer = roomTimers.get(roomId);
  if (timer) {
    clearTimeout(timer);
    roomTimers.delete(roomId);
  }
}

function setRoundTimer(room: GameRoom, io: SocketIOServer) {
  clearRoundTimer(room.id);
  if (room.roundTimeLimit <= 0) return;

  const roundIndex = room.currentRoundIndex;
  const timer = setTimeout(() => {
    roomTimers.delete(room.id);
    const round = room.rounds[roundIndex];
    if (round && !round.completed && room.currentRoundIndex === roundIndex) {
      round.completed = true;
      room.state = "round_end";
      const cardValues = round.cards.map((c) => c.value);
      const solution = solve(cardValues, room.target);
      io.to(room.id).emit("round_timeout", { gameState: getGameState(room), solution });
    }
  }, room.roundTimeLimit * 1000);
  roomTimers.set(room.id, timer);
}

// Clean up empty rooms periodically
setInterval(() => {
  for (const [id, room] of rooms) {
    if (room.players.size === 0) {
      rooms.delete(id);
    }
  }
}, 60000);

app.prepare().then(() => {
  const expressApp = express();
  const httpServer = createServer(expressApp);

  const io = new SocketIOServer(httpServer, {
    path: "/api/socketio",
    addTrailingSlash: false,
    cors: {
      origin: "*",
      methods: ["GET", "POST"],
    },
  });

  io.on("connection", (socket) => {
    console.log(`Player connected: ${socket.id}`);
    let currentRoomId: string | null = null;

    socket.on("create_room", ({ playerName, target, totalRounds, roundTimeLimit }, callback) => {
      let roomId = generateRoomCode();
      let attempts = 0;
      while (rooms.has(roomId) && attempts < 20) {
        roomId = generateRoomCode();
        attempts++;
      }
      const t = typeof target === "number" && target >= 1 && target <= 999 ? target : 24;
      const rounds = typeof totalRounds === "number" && totalRounds >= 1 && totalRounds <= 20 ? totalRounds : 5;
      const timeLimit = typeof roundTimeLimit === "number" && roundTimeLimit >= 0 && roundTimeLimit <= 300 ? roundTimeLimit : 60;

      const room = createRoom(roomId, t, rounds, timeLimit);
      rooms.set(roomId, room);

      const player = addPlayer(room, socket.id, playerName || "Player 1");
      if (!player) {
        callback({ success: false, error: "Failed to create room" });
        return;
      }

      socket.join(roomId);
      currentRoomId = roomId;

      callback({ success: true, roomId, gameState: getGameState(room) });
      console.log(`Room ${roomId} created by ${socket.id}`);
    });

    socket.on("join_room", ({ roomId, playerName }, callback) => {
      const room = rooms.get(roomId);
      if (!room) {
        callback({ success: false, error: "Room not found" });
        return;
      }

      if (room.players.size >= 2) {
        callback({ success: false, error: "Room is full" });
        return;
      }

      const player = addPlayer(room, socket.id, playerName || "Player 2");
      if (!player) {
        callback({ success: false, error: "Could not join room" });
        return;
      }

      socket.join(roomId);
      currentRoomId = roomId;

      const gameState = getGameState(room);
      callback({ success: true, roomId, gameState });

      // Notify room that a player joined
      io.to(roomId).emit("player_joined", gameState);
      console.log(`${socket.id} joined room ${roomId}`);
    });

    socket.on("start_game", ({ solo } = {}, callback) => {
      if (!currentRoomId) {
        callback?.({ success: false, error: "Not in a room" });
        return;
      }

      const room = rooms.get(currentRoomId);
      if (!room) {
        callback?.({ success: false, error: "Room not found" });
        return;
      }

      if (!solo && room.players.size < 2) {
        callback?.({ success: false, error: "Need 2 players to start" });
        return;
      }

      const round = startNewRound(room);
      if (!round) {
        callback?.({ success: false, error: "Could not start round" });
        return;
      }

      const gameState = getGameState(room);
      callback?.({ success: true, gameState });
      io.to(currentRoomId).emit("round_started", gameState);

      setRoundTimer(room, io);

      console.log(`Game started in room ${currentRoomId}`);
    });

    socket.on("submit_answer", ({ expression }, callback) => {
      if (!currentRoomId) {
        callback({ success: false, error: "Not in a room" });
        return;
      }

      const room = rooms.get(currentRoomId);
      if (!room) {
        callback({ success: false, error: "Room not found" });
        return;
      }

      const result = submitAnswer(room, socket.id, expression);
      callback(result);

      if (result.success) {
        clearRoundTimer(currentRoomId);
        io.to(currentRoomId).emit("round_won", {
          winnerId: socket.id,
          winnerName: room.players.get(socket.id)?.name || "Unknown",
          expression,
          gameState: getGameState(room),
        });
      }
    });

    socket.on("next_round", (_, callback) => {
      if (!currentRoomId) {
        callback?.({ success: false, error: "Not in a room" });
        return;
      }

      const room = rooms.get(currentRoomId);
      if (!room) {
        callback?.({ success: false, error: "Room not found" });
        return;
      }

      if (room.currentRoundIndex >= room.totalRounds - 1) {
        room.state = "game_over";
        const gameState = getGameState(room);
        callback?.({ success: true, gameState });
        io.to(currentRoomId).emit("game_over", gameState);
        return;
      }

      const round = startNewRound(room);
      if (!round) {
        callback?.({ success: false, error: "Could not start next round" });
        return;
      }

      const gameState = getGameState(room);
      callback?.({ success: true, gameState });
      io.to(currentRoomId).emit("round_started", gameState);

      setRoundTimer(room, io);
    });

    socket.on("play_again", (_, callback) => {
      if (!currentRoomId) {
        callback?.({ success: false, error: "Not in a room" });
        return;
      }

      const room = rooms.get(currentRoomId);
      if (!room) {
        callback?.({ success: false, error: "Room not found" });
        return;
      }

      // Reset the game
      clearRoundTimer(currentRoomId);
      room.currentRoundIndex = -1;
      room.rounds = [];
      room.state = "waiting";
      for (const player of room.players.values()) {
        player.score = 0;
      }

      const gameState = getGameState(room);
      callback?.({ success: true, gameState });
      io.to(currentRoomId).emit("game_reset", gameState);
    });

    socket.on("disconnect", () => {
      console.log(`Player disconnected: ${socket.id}`);
      if (currentRoomId) {
        const room = rooms.get(currentRoomId);
        if (room) {
          removePlayer(room, socket.id);
          if (room.players.size === 0) {
            clearRoundTimer(currentRoomId);
            rooms.delete(currentRoomId);
          } else {
            room.state = "waiting";
            io.to(currentRoomId).emit("player_left", getGameState(room));
          }
        }
      }
    });
  });

  expressApp.all("/{*path}", (req: any, res: any) => {
    return handle(req, res);
  });

  httpServer.listen(port, () => {
    console.log(`> Ready on http://${hostname}:${port}`);
  });
});