multiplayer.js

console.log('multiplayer.js loaded');

const { Server } = require("socket.io");
const jwt = require('jsonwebtoken');
const User = require('./models/User');
const { updateUserPointsAndRank } = require('./utils/points');
const { logMatchHistory, createMatchData } = require('./utils/matchHistoryLogger');
const { generateDSAPrompt, generateDSAValidationPrompt } = require('./utils/dsaProblemGenerator');

// Per-language and difficulty waiting queues
const waitingPlayers = {};
// { language: { difficulty: [ { socket, name } ] } }

// Custom rooms storage
const customRooms = {};
const customMarathonRooms = {};
// { roomCode: { language, playerCount, players: [socket], maxPlayers, createdBy } }

// Track active game sessions to handle reconnection
const activeGames = {}; // { roomId: { players: [socketId], language, difficulty, startTime, ... } }
const activeGamePlayers = {}; // { socketId: { roomId, gameType } } - Track which game each player is in

// Debug Marathon waiting players
const debugMarathonWaitingPlayers = [];
const MAX_DEBUG_MARATHON_PLAYERS = 5;

// Track recently used buggy codes per language
const recentBuggyCodes = {};
const RECENT_CODES_LIMIT = 50;
const REPEAT_CHANCE = 0.1; // 10% chance to allow a repeat



async function generateBuggyCode(language, difficulty, genAI) {
  try {
    const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
    
    // Use the new DSA problem generator
    const { prompt, problemType, specificProblem } = generateDSAPrompt(language, difficulty);
    
    console.log(`🎯 Generating DSA problem: ${problemType} - ${specificProblem} (${difficulty})`);
    console.log(`🎯 generateDSAPrompt returned:`, { prompt: prompt.substring(0, 100) + '...', problemType, specificProblem });
    
    // Validate that we got proper values
    if (!problemType || problemType === 'DSA Problem') {
      console.error(`❌ Invalid problemType: "${problemType}"`);
    }
    if (!specificProblem || specificProblem.trim() === '') {
      console.error(`❌ Invalid specificProblem: "${specificProblem}"`);
    }
    
    const result = await model.generateContent(prompt);
    const response = await result.response;
    const code = response.text().replace(/```(?:[a-z]+)?|```/g, "").trim();
    
    console.log(`✅ Generated DSA problem for ${language} (${difficulty}): ${problemType} - ${specificProblem}`);
    
    return {
      code,
      problemType,
      specificProblem
    };
  } catch (err) {
    console.error(`⚠️ Could not generate ${language} DSA buggy code:`, err);
    throw err;
  }
}

function setupMultiplayer(server, genAI) {
  console.log("🎮 setupMultiplayer called");
  const io = new Server(server, {
    cors: {
      origin: process.env.NODE_ENV === 'production'
        ? [
            'https://debug-arena.onrender.com',
            process.env.ALLOWED_ORIGIN || '',
            ...((process.env.ADDITIONAL_ALLOWED_ORIGINS || '').split(',').filter(Boolean))
          ].filter(Boolean)
        : [
            'http://localhost:3000',
            'http://localhost:3001',
            'http://localhost:8080',
            'http://127.0.0.1:3000',
            'http://127.0.0.1:3001',
            'http://127.0.0.1:8080'
          ],
      methods: ["GET", "POST"],
      credentials: true
    }
  });

  // JWT authentication middleware for Socket.IO
  io.use(async (socket, next) => {
    const token = socket.handshake.auth.token;
    if (!token) {
      console.log('❌ Multiplayer: No token provided for socket:', socket.id);
      return next(new Error('Authentication error: No token provided'));
    }
    
    jwt.verify(token, process.env.JWT_SECRET || 'debugarena_secret', async (err, user) => {
      if (err) {
        console.log('❌ Multiplayer: Invalid token for socket:', socket.id, 'Error:', err.message);
        return next(new Error('Authentication error: Invalid token'));
      }
      
      if (!user || !user.userId) {
        console.log('❌ Multiplayer: Token missing userId for socket:', socket.id, 'User object:', user);
        return next(new Error('Authentication error: Token missing userId'));
      }
      
      try {
        // Fetch user details from database to get username
        const userDoc = await User.findById(user.userId);
        if (!userDoc) {
          console.log('❌ Multiplayer: User not found in database for socket:', socket.id, 'userId:', user.userId);
          return next(new Error('Authentication error: User not found'));
        }
        
        socket.user = user;
        socket.userId = user.userId;
        socket.username = userDoc.username; // Store username for rankings
        socket.userDoc = userDoc; // Store full user document for lobby display
        console.log('✅ Multiplayer: Authenticated user for socket:', socket.id, 'User:', { userId: user.userId, username: userDoc.username });
        next();
      } catch (error) {
        console.error('❌ Multiplayer: Database error during authentication:', error);
        return next(new Error('Authentication error: Database error'));
      }
    });
  });

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

    // Handle socket reconnection by checking current state
    socket.on("reconnect-session", ({ sessionId, gameMode }) => {
      console.log('🔄 Reconnection request received:', { sessionId, gameMode, socketId: socket.id });

      // Check if user was in a game session and restore state
      if (gameMode === 'rank' && sessionId) {
        // For rank mode, check if user was in waiting lobby
        for (const lang in waitingPlayers) {
          for (const diff in waitingPlayers[lang]) {
            const playerIndex = waitingPlayers[lang][diff].findIndex(p => p.socket && p.socket.id === socket.id);
            if (playerIndex !== -1) {
              // Restore socket reference for reconnected user
              waitingPlayers[lang][diff][playerIndex].socket = socket;
              socket.language = lang;
              socket.difficulty = diff;
              console.log(`🔄 Restored rank lobby connection for user in ${lang}/${diff}`);
              // Send updated lobby information
              emitLobbyUpdate(lang, diff);
              return;
            }
          }
        }
      } else if (gameMode === 'custom' && sessionId) {
        // For custom room, check if user was in a room
        for (const roomCode in customRooms) {
          const room = customRooms[roomCode];
          const playerIndex = room.players.findIndex(p => p.id === socket.id);
          if (playerIndex !== -1) {
            // Update socket reference with new connection
            room.players[playerIndex] = socket;
            socket.language = room.language;
            socket.difficulty = room.difficulty;
            socket.join(roomCode);
            console.log(`🔄 Restored custom room connection for user in room ${roomCode}`);
            // Notify player of room state
            socket.emit('custom-room-joined', {
              roomCode: room.roomCode,
              language: room.language,
              playerCount: room.playerCount,
              difficulty: room.difficulty,
              challengeMode: room.challengeMode,
              betAmount: room.betAmount
            });
            // Send updated room information
            room.players.forEach(player => {
              player.emit('custom-room-update', {
                players: room.players.map(p => {
                  const user = p.user;
                  const userDoc = p.userDoc;

                  return {
                    id: p.id,
                    userId: user?.userId,
                    username: userDoc?.username || user?.username || 'Player',
                    displayName: userDoc?.displayName,
                    profilePicture: userDoc?.profilePicture,
                    rank: userDoc?.rank || 'Bronze',
                    points: userDoc?.points || 0,
                    gamesPlayed: userDoc?.gamesPlayed || 0
                  };
                }),
                maxPlayers: room.maxPlayers,
                difficulty: room.difficulty,
                challengeMode: room.challengeMode,
                betAmount: room.betAmount,
                totalPot: room.challengeMode ? room.bets.reduce((sum, bet) => sum + bet.amount, 0) : 0
              });
            });
            return;
          }
        }
      } else if (gameMode === 'custom-marathon' && sessionId) {
        // For custom marathon room
        for (const roomCode in customMarathonRooms) {
          const room = customMarathonRooms[roomCode];
          if (room && room.players) {
            const playerIndex = room.players.findIndex(p => p && p.id === socket.id);
            if (playerIndex !== -1) {
              // Update socket reference with new connection
              room.players[playerIndex] = socket;
              socket.language = room.language;
              socket.difficulty = 'marathon';
              socket.join(roomCode);
              console.log(`🔄 Restored custom marathon room connection for user in room ${roomCode}`);
              // Notify player of room state
              socket.emit('custom-marathon-room-joined', {
                roomCode: room.roomCode,
                language: room.language,
                playerCount: room.playerCount || 5,
                rounds: room.rounds || 5,
                timeLimit: room.timeLimit || 10,
                challengeMode: room.challengeMode,
                betAmount: room.betAmount,
                problems: room.problems || [] // Send problems if they exist, otherwise empty array
              });
              // Send updated room information
              room.players.forEach(player => {
                if (player) {
                  player.emit('custom-marathon-room-update', {
                    players: room.players.map(p => {
                      const user = p.user;
                      const userDoc = p.userDoc;

                      return {
                        id: p.id,
                        userId: user?.userId,
                        username: userDoc?.username || user?.username || 'Player',
                        displayName: userDoc?.displayName,
                        profilePicture: userDoc?.profilePicture,
                        rank: userDoc?.rank || 'Bronze',
                        points: userDoc?.points || 0,
                        gamesPlayed: userDoc?.gamesPlayed || 0
                      };
                    }),
                    roomInfo: {
                      roomCode: room.roomCode,
                      language: room.language,
                      playerCount: room.playerCount || 5,
                      rounds: room.rounds || 5,
                      timeLimit: room.timeLimit || 10,
                      challengeMode: room.challengeMode
                    }
                  });
                }
              });
              return;
            }
          }
        }
      }
    });

    // Handle reconnection attempt for active games
    socket.on("request-game-state", ({ sessionId }) => {
      console.log('🔄 Request for game state received:', { sessionId, socketId: socket.id });

      // Check if this socket was part of an active game
      const playerGameInfo = activeGamePlayers[socket.id];
      if (playerGameInfo) {
        const roomId = playerGameInfo.roomId;
        const gameInfo = activeGames[roomId];

        if (gameInfo) {
          console.log(`🔄 Sending game state for ${playerGameInfo.gameType} game in room ${roomId}`);

          // Send the current game state to the reconnected player
          socket.emit('restore-game-state', {
            gameType: playerGameInfo.gameType,
            roomId: roomId,
            buggyCode: gameInfo.buggyCode,
            timeLimit: gameInfo.timeLimit,
            problemType: gameInfo.problemType,
            specificProblem: gameInfo.specificProblem,
            language: gameInfo.language,
            difficulty: gameInfo.difficulty
          });
        }
      }
    });

    socket.on("join-lobby", ({ language, difficulty }) => {
      console.log('Join lobby request:', { language, difficulty, socketId: socket.id, user: socket.user?.username });
      if (!language || !difficulty) {
        console.error('Missing language or difficulty:', { language, difficulty });
        return;
      }
      socket.language = language;
      socket.difficulty = difficulty;
      console.log('Socket language set:', socket.language, 'for user:', socket.user?.username);
      if (!waitingPlayers[language]) waitingPlayers[language] = {};
      if (!waitingPlayers[language][difficulty]) waitingPlayers[language][difficulty] = [];
      waitingPlayers[language][difficulty].push({ socket });
      updateLobby(language, difficulty);
      // Notify this player of current lobby
      emitLobbyUpdate(language, difficulty);
      // If 3 players, start game
      if (waitingPlayers[language][difficulty].length === 3) {
        const players = waitingPlayers[language][difficulty].splice(0, 3).map(p => p.socket);
        console.log('Starting match with players:', players.map(p => ({ id: p.id, user: p.user?.username, language: p.language })));
        startMatch(players, genAI, io, language, difficulty);
        // Notify those players to start game
        players.forEach(s => s.emit('lobby-start-game', {}));
      }
    });

    socket.on("leave-lobby", ({ language, difficulty }) => {
      if (!language || !difficulty || !waitingPlayers[language] || !waitingPlayers[language][difficulty]) return;
      waitingPlayers[language][difficulty] = waitingPlayers[language][difficulty].filter(p => p.socket.id !== socket.id);
      updateLobby(language, difficulty);
    });

    socket.on("disconnect", () => {
      // Remove from active game tracking if player was in a game
      if (activeGamePlayers[socket.id]) {
        const gameInfo = activeGamePlayers[socket.id];
        console.log(`🔄 Player ${socket.id} disconnected from ${gameInfo.gameType} game in room ${gameInfo.roomId}`);

        // Mark player as disconnected but keep game in progress
        // The game will continue without this player
        delete activeGamePlayers[socket.id];
      }

      // Remove from all language/difficulty lobbies
      for (const lang in waitingPlayers) {
        for (const diff in waitingPlayers[lang]) {
          waitingPlayers[lang][diff] = waitingPlayers[lang][diff].filter(p => p.socket.id !== socket.id);
          updateLobby(lang, diff);
        }
      }

      // Remove from custom rooms
      for (const roomCode in customRooms) {
        const room = customRooms[roomCode];
        room.players = room.players.filter(p => p.id !== socket.id);
        if (room.players.length === 0) {
          // Clean up active game tracking if room was for a game in progress
          if (activeGames[roomCode]) {
            delete activeGames[roomCode];
          }
          delete customRooms[roomCode];
          console.log(`🗑️ Custom room ${roomCode} deleted (empty)`);
        } else {
          // Notify remaining players with enhanced user information
          room.players.forEach(player => {
            player.emit('custom-room-update', {
              players: room.players.map(p => {
                const user = p.user;
                const userDoc = p.userDoc;

                return {
                  id: p.id,
                  userId: user?.userId,
                  username: userDoc?.username || user?.username || 'Player',
                  displayName: userDoc?.displayName,
                  profilePicture: userDoc?.profilePicture,
                  rank: userDoc?.rank || 'Bronze',
                  points: userDoc?.points || 0,
                  gamesPlayed: userDoc?.gamesPlayed || 0
                };
              }),
              maxPlayers: room.maxPlayers
            });
          });
        }
      }
      // Custom marathon disconnect handling
      for (const marathonCode in customMarathonRooms) {
        const marathon = customMarathonRooms[marathonCode];
        if (!marathon) continue;
        const player = marathon.players.find(p => p.socket && p.socket.id === socket.id);
        if (player) {
          // Mark as disconnected but keep progress for rankings
          player.disconnected = true;
          player.socket = null;
          console.log(`⚠️ Player ${player.name} disconnected from custom marathon ${marathonCode}, progress kept for rankings.`);
        }
      }

      // Debug marathon disconnect handling
      const marathonIndex = debugMarathonWaitingPlayers.findIndex(p => p.id === socket.id);
      if (marathonIndex !== -1) {
        debugMarathonWaitingPlayers.splice(marathonIndex, 1);

        // Emit updated lobby to remaining players
        const players = debugMarathonWaitingPlayers.map(s => ({
          id: s.id,
          userId: s.marathonUserId || s.userId,
          username: s.username || 'Anonymous',
          displayName: s.userDoc?.displayName,
          profilePicture: s.userDoc?.profilePicture,
          rank: s.userDoc?.rank || 'Bronze',
          points: s.userDoc?.points || 0,
          gamesPlayed: s.userDoc?.gamesPlayed || 0
        }));

        console.log(`🎯 Debug Marathon: Player disconnected. Lobby now: [${players.map(p => p.username).join(', ')}] (${debugMarathonWaitingPlayers.length}/${MAX_DEBUG_MARATHON_PLAYERS})`);
        debugMarathonWaitingPlayers.forEach(s => s.emit('marathon-lobby-update', { players }));
      }
    });

    // Practice challenge request event
    socket.on("request-practice-challenge", async ({ language, difficulty }) => {
      console.log(`🎯 Practice challenge request from ${socket.id} for ${language} (${difficulty})`);
      try {
        let buggyCode = "loading...";
        let problemType = "DSA Problem";
        let specificProblem = "";
        let attempts = 0;
        for (let i = 0; i < 5; i++) {
          const result = await generateBuggyCode(language, difficulty, genAI);
          console.log(`🎯 Practice attempt ${i + 1} result:`, { 
            code: result.code.substring(0, 50) + '...', 
            problemType: result.problemType, 
            specificProblem: result.specificProblem 
          });
          const candidate = result.code;
          if (!recentBuggyCodes[language]) recentBuggyCodes[language] = [];
          const isRecent = recentBuggyCodes[language].includes(candidate);
          if (!isRecent || Math.random() < REPEAT_CHANCE) {
            buggyCode = candidate;
            problemType = result.problemType || "DSA Problem";
            specificProblem = result.specificProblem || "";
            console.log(`🎯 Practice selected result: problemType="${problemType}", specificProblem="${specificProblem}"`);
            break;
          }
          attempts++;
        }
        
        // If we didn't get a good result, use the last attempt
        if (buggyCode === "loading...") {
          console.log(`🎯 Practice fallback: using last attempt`);
          const result = await generateBuggyCode(language, difficulty, genAI);
          buggyCode = result.code;
          problemType = result.problemType || "DSA Problem";
          specificProblem = result.specificProblem || "";
          console.log(`🎯 Practice fallback result: problemType="${problemType}", specificProblem="${specificProblem}"`);
        }
        // Save to recent codes
        if (!recentBuggyCodes[language]) recentBuggyCodes[language] = [];
        recentBuggyCodes[language].unshift(buggyCode);
        if (recentBuggyCodes[language].length > RECENT_CODES_LIMIT) {
          recentBuggyCodes[language] = recentBuggyCodes[language].slice(0, RECENT_CODES_LIMIT);
        }

        // Set time limit based on difficulty
        let timeLimit = 60;
        if (difficulty === 'easy') timeLimit = 60;
        else if (difficulty === 'normal') timeLimit = 90;
        else if (difficulty === 'hard') timeLimit = 300;
        else if (difficulty === 'insane') timeLimit = 420;

        console.log(`🎯 Practice challenge response: problemType="${problemType}", specificProblem="${specificProblem}"`);
        console.log(`🎯 Final values being sent:`, { problemType, specificProblem, buggyCode: buggyCode.substring(0, 50) + '...' });
        socket.emit('practice-challenge-response', {
          success: true,
          buggyCode: buggyCode,
          language: language,
          difficulty: difficulty,
          timeLimit: timeLimit,
          problemType: problemType,
          specificProblem: specificProblem
        });
        console.log(`🎯 Practice challenge generated for ${socket.user?.username || 'anonymous'} (${language}, ${difficulty}): ${problemType} - ${specificProblem}`);
      } catch (err) {
        console.error('❌ Error generating practice challenge:', err);
        socket.emit('practice-challenge-response', {
          success: false,
          message: 'Error generating practice challenge.'
        });
      }
    });



    // === Custom Room Events ===
    socket.on("create-custom-room", ({ roomCode, language, playerCount, difficulty, challengeMode, betAmount }) => {
      console.log('Creating custom room:', { roomCode, language, playerCount, difficulty, challengeMode, betAmount, socketId: socket.id });
      
      if (customRooms[roomCode]) {
        socket.emit('custom-room-error', { message: 'Room code already exists' });
        return;
      }
      
      // Set socket properties for chat functionality
      socket.language = language;
      socket.difficulty = difficulty || 'normal';
      
      customRooms[roomCode] = {
        roomCode,
        language,
        playerCount,
        maxPlayers: playerCount,
        players: [socket],
        createdBy: socket.id,
        created: Date.now(),
        difficulty: difficulty || 'normal',
        challengeMode: challengeMode || false,
        betAmount: betAmount || 0,
        bets: challengeMode ? [{ playerId: socket.id, amount: betAmount, username: socket.user?.username }] : []
      };
      
      socket.join(roomCode);
      socket.emit('custom-room-created', { roomCode, language, playerCount, difficulty, challengeMode, betAmount });
      console.log(`🏠 Custom room ${roomCode} created for ${playerCount} players (${difficulty})${challengeMode ? ' with challenge mode' : ''}`);
      
      // Send a test chat message to verify chat is working
      setTimeout(() => {
        socket.emit('lobby-chat-message', {
          message: 'Room created! Chat is working.',
          username: 'System',
          userId: 'system',
          timestamp: Date.now()
        });
      }, 1000);
    });

    socket.on("join-custom-room", ({ roomCode }) => {
      console.log('Joining custom room:', { roomCode, socketId: socket.id });
      
      const room = customRooms[roomCode];
      if (!room) {
        socket.emit('custom-room-error', { message: 'Room not found' });
        return;
      }
      
      if (room.players.length >= room.maxPlayers) {
        socket.emit('custom-room-error', { message: 'Room is full' });
        return;
      }
      
      // Check if player is already in the room
      if (room.players.find(p => p.id === socket.id)) {
        socket.emit('custom-room-error', { message: 'Already in this room' });
        return;
      }
      
      // For challenge mode, require 3 players minimum
      if (room.challengeMode && room.players.length === 2 && room.maxPlayers < 3) {
        socket.emit('custom-room-error', { message: 'Challenge mode requires at least 3 players' });
        return;
      }
      
      // Set socket properties for chat functionality
      socket.language = room.language;
      socket.difficulty = room.difficulty;
      
      room.players.push(socket);
      socket.join(roomCode);
      
      // Add bet for challenge mode
      if (room.challengeMode) {
        room.bets.push({ 
          playerId: socket.id, 
          amount: room.betAmount, 
          username: socket.user?.username 
        });
      }
      
      socket.emit('custom-room-joined', { 
        roomCode, 
        language: room.language, 
        playerCount: room.playerCount,
        difficulty: room.difficulty,
        challengeMode: room.challengeMode,
        betAmount: room.betAmount
      });
      
      // Notify all players in the room with enhanced user information
      room.players.forEach(player => {
        player.emit('custom-room-update', { 
          players: room.players.map(p => {
            const user = p.user;
            const userDoc = p.userDoc;
            
            return {
              id: p.id,
              userId: user?.userId,
              username: userDoc?.username || user?.username || 'Player',
              displayName: userDoc?.displayName,
              profilePicture: userDoc?.profilePicture,
              rank: userDoc?.rank || 'Bronze',
              points: userDoc?.points || 0,
              gamesPlayed: userDoc?.gamesPlayed || 0
            };
          }),
          maxPlayers: room.maxPlayers,
          difficulty: room.difficulty,
          challengeMode: room.challengeMode,
          betAmount: room.betAmount,
          totalPot: room.challengeMode ? room.bets.reduce((sum, bet) => sum + bet.amount, 0) : 0
        });
      });
      
      console.log(`👥 Player joined custom room ${roomCode} (${room.players.length}/${room.maxPlayers})${room.challengeMode ? ` with ${room.betAmount} point bet` : ''}`);
      
      // If room is full, start the game
      if (room.players.length === room.maxPlayers) {
        console.log(`🎮 Starting custom game in room ${roomCode}${room.challengeMode ? ' with challenge mode' : ''}`);
        startCustomMatch(room.players, genAI, io, room.language, roomCode);
        room.players.forEach(player => {
          player.emit('custom-game-start', { challengeMode: room.challengeMode });
        });
      }
    });

    // Test message handler
    socket.on("test-message", (data) => {
      console.log('🧪 Test message received:', data);
      socket.emit('test-response', { message: 'Hello client!' });
    });
    
    // Ping handler
    socket.on("ping", (data) => {
      console.log('🏓 Ping received from client:', data);
      socket.emit('pong', { timestamp: Date.now(), originalTimestamp: data.timestamp });
    });

    // === Chat Events ===
    socket.on("lobby-chat", ({ message, username, userId }) => {
      console.log('🎯 LOBBY-CHAT EVENT RECEIVED ON SERVER!');
      console.log('📨 Chat message received:', { message, username, userId, socketId: socket.id });
      console.log('🔍 Socket connected:', socket.connected);
      console.log('🔍 Socket rooms:', Array.from(socket.rooms));
      
      const chatData = {
        message,
        username: username || socket.username || 'Anonymous',
        userId: userId || socket.userId,
        timestamp: Date.now()
      };
      
      console.log('🔍 Looking for player in rooms...');
      
      // Find which room/lobby the player is in
      let roomCode = null;
      
      // Check custom rooms
      for (const code in customRooms) {
        if (customRooms[code].players.find(p => p.id === socket.id)) {
          roomCode = code;
          console.log('🏠 Found player in custom room:', code);
          break;
        }
      }
      
      // Check custom marathon rooms
      if (!roomCode) {
        for (const code in customMarathonRooms) {
          if (customMarathonRooms[code].players.find(p => p.id === socket.id)) {
            roomCode = code;
            console.log('🏁 Found player in marathon room:', code);
            break;
          }
        }
      }
      
      if (roomCode) {
        // Broadcast to room members
        console.log('📢 Broadcasting to room:', roomCode);
        socket.to(roomCode).emit('lobby-chat-message', chatData);
      } else {
        // For regular lobbies, check all waiting players
        console.log('🔍 Checking regular lobbies...');
        let foundInLobby = false;
        
        for (const language in waitingPlayers) {
          for (const difficulty in waitingPlayers[language]) {
            const waitingList = waitingPlayers[language][difficulty];
            console.log('🔍 Checking lobby:', language, difficulty, 'with', waitingList.length, 'players');
            console.log('🔍 Looking for socket.id:', socket.id);
            console.log('🔍 Available socket IDs:', waitingList.map(p => p.socket?.id));
            
            const playerInLobby = waitingList.find(p => p.socket && p.socket.id === socket.id);
            
            if (playerInLobby) {
              console.log('📢 Broadcasting to lobby:', language, difficulty);
              console.log('👥 Players in lobby:', waitingList.length);
              
              waitingList.forEach(player => {
                if (player.socket && player.socket.id !== socket.id) {
                  console.log('📤 Sending to player:', player.socket.id);
                  player.socket.emit('lobby-chat-message', chatData);
                }
              });
              
              foundInLobby = true;
              break;
            }
          }
          if (foundInLobby) break;
        }
        
        if (!foundInLobby) {
          console.log('❌ Player not found in any room or lobby');
          console.log('Current socket language/difficulty:', socket.language, socket.difficulty);
          console.log('Available waiting players:', Object.keys(waitingPlayers));
          console.log('Waiting players details:', JSON.stringify(waitingPlayers, null, 2));
        }
      }
    });

    // Marathon lobby chat
    socket.on("marathon-lobby-chat", ({ message, username, userId }) => {
      console.log('Marathon chat message received:', { message, username, userId, socketId: socket.id });
      
      const chatData = {
        message,
        username: username || socket.username || 'Anonymous',
        userId: userId || socket.userId,
        timestamp: Date.now()
      };
      
      // Find which marathon room the player is in
      let roomCode = null;
      for (const code in customMarathonRooms) {
        if (customMarathonRooms[code].players.find(p => p.id === socket.id)) {
          roomCode = code;
          break;
        }
      }
      
      if (roomCode) {
        // Broadcast to marathon room members
        socket.to(roomCode).emit('marathon-lobby-chat-message', chatData);
      } else {
        // If not in a custom room, broadcast to debug marathon lobby
        console.log('🎯 Debug Marathon: Broadcasting chat to debug marathon lobby');
        debugMarathonWaitingPlayers.forEach(s => {
          if (s.id !== socket.id) {
            s.emit('marathon-lobby-chat-message', chatData);
          }
        });
      }
    });

    // === Debug Marathon Lobby Events ===
    socket.on("join-marathon-lobby", async ({ language, userId, username }) => {
      console.log('🎯 Debug Marathon: Player joining lobby:', { language, userId, username, socketId: socket.id });
      console.log('🎯 Debug Marathon: Current waiting players:', debugMarathonWaitingPlayers.length);
      console.log('🎯 Debug Marathon: Socket user info:', { 
        userId: socket.userId, 
        username: socket.username, 
        userDoc: socket.userDoc 
      });
      console.log('🎯 Debug Marathon: Event received successfully!');
      
      // Set socket properties
      socket.language = language;
      socket.difficulty = 'marathon';
      socket.marathonUserId = userId;
      
      // Add to waiting players if not already there
      if (!debugMarathonWaitingPlayers.find(p => p.id === socket.id)) {
        debugMarathonWaitingPlayers.push(socket);
      }
      
      // Emit lobby update to all waiting players
      const players = debugMarathonWaitingPlayers.map(s => ({
        id: s.id,
        userId: s.marathonUserId || s.userId,
        username: s.username || username || 'Anonymous',
        displayName: s.userDoc?.displayName,
        profilePicture: s.userDoc?.profilePicture,
        rank: s.userDoc?.rank || 'Bronze',
        points: s.userDoc?.points || 0,
        gamesPlayed: s.userDoc?.gamesPlayed || 0
      }));
      
      console.log('🎯 Debug Marathon: Emitting lobby update with players:', players);
      
      console.log(`🎯 Debug Marathon: Lobby update: [${players.map(p => p.username).join(', ')}] (${debugMarathonWaitingPlayers.length}/${MAX_DEBUG_MARATHON_PLAYERS})`);
      debugMarathonWaitingPlayers.forEach(s => s.emit('marathon-lobby-update', { players }));
      
      // Check if we have enough players to start
      if (debugMarathonWaitingPlayers.length === MAX_DEBUG_MARATHON_PLAYERS) {
        console.log('🎯 Debug Marathon: 5 players joined, starting game!');
        
        // Notify all players that game is starting
        debugMarathonWaitingPlayers.forEach(s => s.emit('marathon-game-starting', { message: 'Generating problems... Please wait.' }));
        
        // Start the marathon game
        const sessionId = `debug_marathon_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
        const players = debugMarathonWaitingPlayers.splice(0, MAX_DEBUG_MARATHON_PLAYERS);
        
        // Generate problems (simplified for now)
        const problems = [
          { round: 1, problem: 'def calculate():\n    return 1', difficulty: 'easy' },
          { round: 2, problem: 'def calculate():\n    return 2', difficulty: 'normal' },
          { round: 3, problem: 'def calculate():\n    return 3', difficulty: 'normal' },
          { round: 4, problem: 'def calculate():\n    return 4', difficulty: 'hard' },
          { round: 5, problem: 'def calculate():\n    return 5', difficulty: 'hard' }
        ];
        
        const gameStartTime = Date.now();
        const playerIds = players.map(s => s.marathonUserId || s.userId);
        
        players.forEach(s => {
          s.join(sessionId);
          s.emit('marathon-start', { 
            sessionId, 
            problems: problems.map(p => ({ round: p.round, difficulty: p.difficulty, problem: p.problem })), 
            players: playerIds,
            gameStartTime: gameStartTime
          });
        });
      }
    });



    // === Custom DebugMarathon Room Events ===
    socket.on("create-custom-marathon-room", async ({ roomCode, language, playerCount, rounds, timeLimit, challengeMode, betAmount }) => {
      console.log('Creating custom marathon room:', { roomCode, language, playerCount, rounds, timeLimit, challengeMode, betAmount, socketId: socket.id });
      
      if (customMarathonRooms[roomCode]) {
        socket.emit('custom-marathon-room-error', { message: 'Room code already exists' });
        return;
      }
      
      // Set socket properties for chat functionality
      socket.language = language;
      socket.difficulty = 'marathon'; // Use 'marathon' as difficulty for marathon rooms
      
      // Create room without generating problems yet - wait until room is full
      customMarathonRooms[roomCode] = {
        roomCode,
        language,
        playerCount: playerCount || 5, // Default to 5 players for marathon
        maxPlayers: playerCount || 5,
        players: [socket],
        createdBy: socket.id,
        created: Date.now(),
        rounds: rounds || 5, // Default to 5 rounds for marathon
        timeLimit: timeLimit || 10, // Default to 10 minutes for marathon
        challengeMode: challengeMode || false,
        betAmount: betAmount || 0,
        bets: challengeMode ? [{ playerId: socket.id, amount: betAmount, username: socket.user?.username }] : [],
        problems: null // Problems will be generated when room is full
      };
      
      socket.join(roomCode);
      socket.emit('custom-marathon-room-created', { roomCode, language, playerCount: playerCount || 5, rounds: rounds || 5, timeLimit: timeLimit || 10, challengeMode, betAmount, problems: [] });
      console.log(`🏁 Custom marathon room ${roomCode} created for ${playerCount || 5} players (${rounds || 5} rounds, ${timeLimit || 10} min)${challengeMode ? ' with challenge mode' : ''}`);
    });

    socket.on("join-custom-marathon-room", async ({ roomCode }) => {
      console.log('Joining custom marathon room:', { roomCode, socketId: socket.id });
      
      const room = customMarathonRooms[roomCode];
      if (!room) {
        socket.emit('custom-marathon-room-error', { message: 'Room not found' });
        return;
      }
      
      if (room.players.length >= room.maxPlayers) {
        socket.emit('custom-marathon-room-error', { message: 'Room is full' });
        return;
      }
      
      // Check if player is already in the room
      if (room.players.find(p => p.id === socket.id)) {
        socket.emit('custom-marathon-room-error', { message: 'Already in this room' });
        return;
      }
      
      // Set socket properties for chat functionality
      socket.language = room.language;
      socket.difficulty = 'marathon'; // Use 'marathon' as difficulty for marathon rooms
      
      room.players.push(socket);
      socket.join(roomCode);
      
      // Add bet for challenge mode
      if (room.challengeMode) {
        room.bets.push({ 
          playerId: socket.id, 
          amount: room.betAmount, 
          username: socket.user?.username 
        });
      }
      
      socket.emit('custom-marathon-room-joined', { 
        roomCode, 
        language: room.language, 
        playerCount: room.playerCount || 5,
        rounds: room.rounds || 5,
        timeLimit: room.timeLimit || 10,
        challengeMode: room.challengeMode,
        betAmount: room.betAmount,
        problems: room.problems || [] // Send problems if they exist, otherwise empty array
      });
      
      // Notify all players in the room with enhanced user information
      room.players.forEach(player => {
        player.emit('custom-marathon-room-update', { 
          players: room.players.map(p => {
            const user = p.user;
            const userDoc = p.userDoc;
            
            return {
              id: p.id,
              userId: user?.userId,
              username: userDoc?.username || user?.username || 'Player',
              displayName: userDoc?.displayName,
              profilePicture: userDoc?.profilePicture,
              rank: userDoc?.rank || 'Bronze',
              points: userDoc?.points || 0,
              gamesPlayed: userDoc?.gamesPlayed || 0
            };
          }),
          roomInfo: {
            roomCode: room.roomCode,
            language: room.language,
            playerCount: room.playerCount || 5,
            rounds: room.rounds || 5,
            timeLimit: room.timeLimit || 10,
            challengeMode: room.challengeMode
          }
        });
      });
      
      console.log(`👥 Player joined custom marathon room ${roomCode} (${room.players.length}/${room.maxPlayers})${room.challengeMode ? ` with ${room.betAmount} point bet` : ''}`);
      
      // If room is full, generate problems and start the marathon
      if (room.players.length === room.maxPlayers) {
        console.log(`🏁 Room ${roomCode} is full! Generating problems and starting marathon${room.challengeMode ? ' with challenge mode' : ''}`);
        
        // Send "Generating problems" message to all players
        console.log(`🔄 Sending generating message to ${room.players.length} players in room ${roomCode}`);
        room.players.forEach(player => {
          if (player) {
            console.log(`🔄 Emitting custom-marathon-generating to player ${player.id}`);
            player.emit('custom-marathon-generating', { message: 'Generating problems, please wait...' });
          } else {
            console.log(`⚠️ Player is undefined, skipping generating message`);
          }
        });
        
        // Generate problems only when room is full
        const { generateMarathonProblems } = require('./utils/debugMarathonProblemGen');
        try {
          room.problems = await generateMarathonProblems(room.language, genAI, room.rounds);
          console.log(`✅ Generated ${room.problems.length} problems for room ${roomCode}`);
        } catch (err) {
          console.error(`❌ Failed to generate problems for room ${roomCode}:`, err);
          console.log(`⚠️ Falling back to built-in problems due to generation failure (e.g., 503 overload)`);
          // Build a minimal fallback set matching requested rounds and including difficulty/round
          const fallbackByDifficulty = ['easy','normal','normal','hard','hard'];
          const total = room.rounds || 5;
          const lang = (room.language || 'python').toLowerCase();
          const fallbackCode = (roundIdx) => {
            if (lang === 'python') return `def solve_${roundIdx}(arr):\n    # TODO: fix bug\n    return arr[0]`;
            if (lang === 'java') return `class Solution${roundIdx} {\n    int solve(int[] arr){ /* TODO: fix bug */ return arr[0]; }\n}`;
            if (lang === 'cpp') return `int solve_${roundIdx}(vector<int>& a){ /* TODO */ return a[0]; }`;
            if (lang === 'c') return `int solve_${roundIdx}(int* a,int n){ /* TODO */ return a[0]; }`;
            if (lang === 'js' || lang === 'javascript') return `function solve${roundIdx}(arr){ /* TODO */ return arr[0]; }`;
            return `def solve_${roundIdx}(arr):\n    # TODO: fix bug\n    return arr[0]`;
          };
          room.problems = Array.from({length: total}, (_, i) => ({
            round: i + 1,
            difficulty: fallbackByDifficulty[i] || 'normal',
            problem: fallbackCode(i + 1),
            problemType: 'DSA Problem',
            specificProblem: `Fallback Round ${i + 1}`
          }));
          console.log(`✅ Fallback problems prepared for room ${roomCode}: ${room.problems.length}`);
        }

        // Start the marathon (generated or fallback problems)
        startCustomMarathon(room.players, genAI, io, room.language, roomCode, room.rounds, room.timeLimit, room.problems);
        room.players.forEach(player => {
          if (player) {
            player.emit('custom-marathon-start', { challengeMode: room.challengeMode });
          }
        });
        
        // Show initial rankings after a short delay to let players join
        // (Removed here; startCustomMarathon will handle initial rankings using its own sessionId)
      }
    });

    // Handle custom marathon round completion from any socket
    socket.on('marathon-round-complete', (data) => {
      console.log(`[CustomMarathon] 🔍 marathon-round-complete event received from socket ${socket.id}:`, data);
      const { sessionId: sid, round, timeTaken, userId } = data || {};
      
      if (!sid) {
        console.log(`[CustomMarathon] ❌ No sessionId provided`);
        return;
      }
      
      // Find the marathon room that owns this sessionId
      let owningRoomCode = null;
      for (const code in customMarathonRooms) {
        const room = customMarathonRooms[code];
        if (room && room.marathonSession && room.marathonSession.sessionId === sid) {
          owningRoomCode = code;
          break;
        }
      }
      
      if (!owningRoomCode) {
        console.log(`[CustomMarathon] ❌ No marathon room found for sessionId: ${sid}`);
        return;
      }
      
      const marathon = customMarathonRooms[owningRoomCode].marathonSession;
      console.log(`[CustomMarathon] 🎯 Processing round completion for sessionId=${sid}, round=${round}, timeTaken=${timeTaken}, userId=${userId}`);
      
      // Find the player in the marathon session
      console.log(`[CustomMarathon] 🔍 Looking for player with userId=${userId} in marathon session`);
      console.log(`[CustomMarathon] 🔍 Available players in marathon:`, marathon.players.map(p => ({ name: p.name, userId: p.userId, socketId: p.socket?.id })));
      
      const player = marathon.players.find(p => p.userId === userId);
      if (!player) {
        console.log(`[CustomMarathon] ❌ Player not found in marathon session: userId=${userId}`);
        console.log(`[CustomMarathon] ❌ Available userIds:`, marathon.players.map(p => p.userId));
        return;
      }
      
      // Record the round completion
      if (!player.roundTimes) player.roundTimes = {};
      player.roundTimes[round] = timeTaken;
      player.completedRounds = (player.completedRounds || 0) + 1;
      player.currentRound = round + 1;
      player.totalTime = (player.totalTime || 0) + timeTaken;
      
      // CRITICAL FIX: Mark this round as finished to prevent penalty
      if (!player.finishedRounds) player.finishedRounds = [];
      if (!player.finishedRounds.includes(round)) {
        player.finishedRounds.push(round);
      }
      
      console.log(`[CustomMarathon] ✅ Round ${round} completed by ${player.name} in ${timeTaken}s`);
      console.log(`[CustomMarathon] Player stats: completedRounds=${player.completedRounds}, totalTime=${player.totalTime}, finishedRounds=${player.finishedRounds}`);
      
      // Update the marathon state
      marathon.players = marathon.players.sort((a, b) => {
        if (a.completedRounds !== b.completedRounds) {
          return b.completedRounds - a.completedRounds;
        }
        return (a.totalTime || 0) - (b.totalTime || 0);
      });
      
      // Update ranks
      marathon.players.forEach((p, index) => {
        p.rank = index + 1;
      });
      
      // Send updated rankings to all players in the session
      const rankings = marathon.players.map(p => ({
        rank: p.rank,
        username: p.name,
        userId: p.userId,
        completedRounds: p.completedRounds || 0,
        currentRound: p.currentRound || 1,
        totalTime: p.totalTime || 0,
        roundTimes: p.roundTimes || {}
      }));
      
      io.to(sid).emit('custom-marathon-current-rankings', {
        rankings: rankings,
        isFinal: false,
        message: 'Round completed! Updated standings:',
        totalRounds: marathon.totalRounds || 5
      });
    });

    // Provide current round snapshot for custom marathon on rejoin (align with debug mode)
    socket.on('join-marathon-session', ({ sessionId }) => {
      try {
        if (!sessionId) return;
        // Find the marathon room that owns this sessionId
        let owningRoomCode = null;
        for (const code in customMarathonRooms) {
          const room = customMarathonRooms[code];
          if (room && room.marathonSession && room.marathonSession.sessionId === sessionId) {
            owningRoomCode = code;
            break;
          }
        }
        if (!owningRoomCode) return;
        const marathon = customMarathonRooms[owningRoomCode].marathonSession;
        socket.join(sessionId);

        // Compute remaining time for current round based on server state
        const ROUND_TIME_BY_DIFFICULTY = { easy: 60, normal: 90, hard: 120 };
        const roomState = customMarathonRooms[owningRoomCode].marathonState || {};
        let currentRound = roomState.currentRound || 1;
        // If 0 (not started yet), default to 1
        if (currentRound <= 0) currentRound = 1;
        const roundMeta = marathon.problems.find(p => p.round === currentRound) || {};
        const difficulty = (roomState.currentDifficulty || roundMeta.difficulty || 'normal').toLowerCase();
        const limit = ROUND_TIME_BY_DIFFICULTY[difficulty] || 90;
        // Calculate remaining time if we have a stored roundStartTimeMs
        let remaining = limit;
        if (roomState.roundStartTimeMs && Number.isFinite(roomState.roundStartTimeMs)) {
          const elapsed = Math.max(0, Math.floor((Date.now() - roomState.roundStartTimeMs) / 1000));
          remaining = Math.max(0, limit - elapsed);
        }

        socket.emit('marathon-round-start', {
          sessionId,
          round: currentRound,
          difficulty: roundMeta.difficulty || roomState.currentDifficulty || 'normal',
          problem: roundMeta.problem,
          problemType: roundMeta.problemType || 'DSA Problem',
          specificProblem: roundMeta.specificProblem || '',
          timeLimit: remaining
        });
      } catch (e) {
        console.error('[CustomMarathon] Error handling join-marathon-session:', e?.message || e);
      }
    });

    // Handle custom marathon rankings request
    // REMOVED: Duplicate handler - this is handled inside startCustomMarathon
  });

  function updateLobby(language, difficulty) {
    emitLobbyUpdate(language, difficulty);
  }

  function emitLobbyUpdate(language, difficulty) {
    if (!waitingPlayers[language] || !waitingPlayers[language][difficulty]) return;
    
    // Get user information for each player in the lobby
    const players = waitingPlayers[language][difficulty].map((p, i) => {
      const user = p.socket.user;
      const userDoc = p.socket.userDoc; // This will be set in the auth middleware
      
      return {
        id: p.socket.id,
        userId: user?.userId,
        username: userDoc?.username || user?.username || `Player ${i + 1}`,
        displayName: userDoc?.displayName,
        profilePicture: userDoc?.profilePicture,
        rank: userDoc?.rank || 'Bronze',
        points: userDoc?.points || 0,
        gamesPlayed: userDoc?.gamesPlayed || 0
      };
    });
    
    waitingPlayers[language][difficulty].forEach(({ socket }) => {
      socket.emit('lobby-update', { players });
    });
  }

  
}

async function startMatch(players, genAI, io, language, difficulty) {
  console.log(`🎮 Matchmaking 3 players for ${language} (${difficulty})...`);

  let buggyCode = null;
  let attempts = 0;
  // Track problem metadata for UI
  let selectedProblemType = "DSA Problem";
  let selectedSpecificProblem = "";
  // Set time limit based on difficulty
  let timeLimit = 60; // Default 60 seconds
  if (difficulty === 'easy') timeLimit = 60;
  else if (difficulty === 'normal') timeLimit = 90;
  else if (difficulty === 'hard') timeLimit = 300;
  else if (difficulty === 'insane') timeLimit = 420;

  try {
    // Try up to 5 times to get a non-recent code, unless random chance allows repeat
    for (let i = 0; i < 5; i++) {
      const result = await generateBuggyCode(language, difficulty, genAI);
      const candidate = result.code;
      if (!candidate) continue;
      if (!recentBuggyCodes[language]) recentBuggyCodes[language] = [];
      const isRecent = recentBuggyCodes[language].includes(candidate);
      if (!isRecent || Math.random() < REPEAT_CHANCE) {
        buggyCode = candidate;
        selectedProblemType = result.problemType || "DSA Problem";
        selectedSpecificProblem = result.specificProblem || "";
        break;
      }
      attempts++;
    }
    // Save to recent codes
    if (buggyCode) {
      if (!recentBuggyCodes[language]) recentBuggyCodes[language] = [];
      recentBuggyCodes[language].unshift(buggyCode);
      if (recentBuggyCodes[language].length > RECENT_CODES_LIMIT) {
        recentBuggyCodes[language] = recentBuggyCodes[language].slice(0, RECENT_CODES_LIMIT);
      }
    }
  } catch (err) {
    console.error(`⚠️ Could not generate ${language} buggy code:`, err);
    buggyCode = null;
  }

  if (!buggyCode || typeof buggyCode !== 'string' || buggyCode.trim().length < 5) {
    players.forEach(socket => {
      socket.emit('game-error', { message: 'Could not generate a new buggy code. Please try again.' });
    });
    return;
  }

  const roomId = `room-${Date.now()}-${language}`;
  const session = {
    players: [],
    finished: [],
    startTime: Date.now(),
    rankingSent: false,
  };

  // Track active game session for reconnection
  activeGames[roomId] = {
    players: players.map(p => p.id), // Store socket IDs
    language: language,
    difficulty: difficulty,
    startTime: Date.now(),
    buggyCode: buggyCode, // Store the code to send to reconnected players
    timeLimit: timeLimit,
    problemType: selectedProblemType,
    specificProblem: selectedSpecificProblem
  };



  players.forEach((socket, index) => {
    socket.join(roomId);

    // Track which game this player is in for reconnection
    activeGamePlayers[socket.id] = {
      roomId: roomId,
      gameType: 'rank'
    };

    // Get user information for enhanced display
    const user = socket.user;
    const userDoc = socket.userDoc;
    const playerName = userDoc?.username || user?.username || `Player ${index + 1}`;

    session.players.push({
      socket,
      playerId: socket.id,
      name: playerName,
      username: playerName,
      displayName: userDoc?.displayName,
      profilePicture: userDoc?.profilePicture,
      rank: userDoc?.rank || 'Bronze',
      points: userDoc?.points || 0
    });

    socket.emit("game-start", {
      playerNumber: index + 1,
      buggyCode,
      roomId,
      timeLimit,
      problemType: selectedProblemType,
      specificProblem: selectedSpecificProblem
    });

    socket.on("player-finished", ({ timeTaken, roomId: submittedRoom }) => {
      if (submittedRoom !== roomId) return;
      if (session.finished.find((f) => f.socketId === socket.id)) return;

      session.finished.push({
        socketId: socket.id,
        timeTaken,
        name: playerName,
        username: playerName
      });

      io.to(roomId).emit("player-submitted", {
        name: playerName,
        time: timeTaken,
      });

      console.log(`✅ ${socket.id} completed in ${timeTaken}s`);

      // ✅ If all 3 submitted, send ranking early
      if (
        session.finished.length === session.players.length &&
        !session.rankingSent
      ) {
        sendFinalRanking(io, roomId, session.finished, language, difficulty);
        session.rankingSent = true;
      }
    });
  });

  // ⏳ After timeLimit, fallback send ranking if not already sent
  setTimeout(() => {
    if (!session.rankingSent) {
      sendFinalRanking(io, roomId, session.finished, language, difficulty);
      session.rankingSent = true;
    }
  }, (timeLimit + 1) * 1000); // Add 1 second buffer
}

async function sendFinalRanking(io, roomId, finishedList, language, difficulty) {
  let ranked = [];

  if (finishedList.length > 0) {
    ranked = finishedList
      .sort((a, b) => a.timeTaken - b.timeTaken)
      .map((entry, i) => ({
        rank: i + 1,
        name: entry.name,
        time: entry.timeTaken,
        socketId: entry.socketId
      }));

    // Award points based on rank and difficulty (updated logic)
    const pointsTable = {
      easy:    { first: 10, second: 3, third: -10 },
      normal:  { first: 20, second: 7, third: -20 },
      hard:    { first: 30, second: 10, third: -30 },
      insane:  { first: 40, second: 20, third: -40 }
    };
    const diff = difficulty || 'easy';
    for (const entry of ranked) {
      let pointsChange = 0;
      let transactionType = 'game_loss';
      if (entry.rank === 1) {
        pointsChange = pointsTable[diff].first;
        transactionType = 'game_win';
      } else if (entry.rank === 2) {
        pointsChange = pointsTable[diff].second;
        transactionType = 'game_win'; // Use game_win for second place too
      } else if (entry.rank === 3) {
        pointsChange = pointsTable[diff].third;
        transactionType = 'game_loss';
      }
      // Find the socket and userId
      const socket = io.sockets.sockets.get(entry.socketId);
      console.log('Processing entry:', entry.socketId, 'socket found:', !!socket, 'user:', socket?.user);
      
      if (!socket) {
        console.error('❌ Socket not found for entry:', entry.socketId);
        continue;
      }
      
      if (!socket.user) {
        console.error('❌ Socket user object missing for entry:', entry.socketId);
        continue;
      }
      
      if (!socket.user.userId) {
        console.error('❌ Socket user.userId missing for entry:', entry.socketId, 'user object:', socket.user);
        continue;
      }
      
      if (socket && socket.user && socket.user.userId) {
        try {
          console.log('Updating user:', socket.user.userId, 'with points:', pointsChange, 'language:', language);
          await updateUserPointsAndRank(socket.user.userId, pointsChange, transactionType, `Match result: Rank ${entry.rank}`);

          // Update user stats: CPM, accuracy, games played, top languages
          const User = require('./models/User');
          const user = await User.findById(socket.user.userId);
          if (user) {
            console.log('Found user in database:', user.username);
            // Calculate CPM safely based on difficulty
            let buggyCodeLength = 100; // Default fallback
            if (difficulty === 'easy') buggyCodeLength = 150; // ~10 lines * 15 chars avg
            else if (difficulty === 'normal') buggyCodeLength = 400; // ~25 lines * 16 chars avg
            else if (difficulty === 'hard') buggyCodeLength = 1600; // ~100 lines * 16 chars avg
            else if (difficulty === 'insane') buggyCodeLength = 2400; // ~150 lines * 16 chars avg
            
            let cpm = 0;
            if (entry.timeTaken > 0) {
              cpm = (buggyCodeLength / entry.timeTaken) * 60; // chars per minute
            }
            
            // For demo, assume accuracy is 100% if finished
            const accuracy = 100;
            
            // Update running average safely
            const currentGames = user.gamesPlayed || 0;
            const currentCpm = user.averageCpm || 0;
            const currentAccuracy = user.averageAccuracy || 0;
            
            user.averageCpm = ((currentCpm * currentGames) + cpm) / (currentGames + 1);
            user.averageAccuracy = ((currentAccuracy * currentGames) + accuracy) / (currentGames + 1);
            user.gamesPlayed = currentGames + 1;
            
            // Update gamesWon for winners (rank 1 and 2)
            if (entry.rank === 1 || entry.rank === 2) {
              user.gamesWon = (user.gamesWon || 0) + 1;
              console.log(`🏆 ${user.username} won game (rank ${entry.rank}), total wins: ${user.gamesWon}`);
            }
            
            // Debug log for language update
            console.log('Before update:', user.username, 'topLanguages:', user.topLanguages, 'language:', language);
            // Update topLanguages (add if not present)
            if (language && !user.topLanguages.includes(language)) {
              user.topLanguages.push(language);
              console.log('Added language:', language, 'for user:', user.username);
            } else if (language) {
              console.log('Language already exists for user:', user.username, 'language:', language);
            }
            await user.save();
            console.log('After update:', user.username, 'topLanguages:', user.topLanguages, 'gamesPlayed:', user.gamesPlayed, 'gamesWon:', user.gamesWon);
          } else {
            console.error('User not found in database:', socket.user.userId);
          }
        } catch (err) {
          console.error('❌ Error updating points/rank/stats for user:', socket.user.userId, 'Error:', err.message);
          
          // Try to save just the language update if the main update fails
          try {
            const User = require('./models/User');
            const user = await User.findById(socket.user.userId);
            if (user && language && !user.topLanguages.includes(language)) {
              user.topLanguages.push(language);
              await user.save();
              console.log('✅ Language update saved successfully for user:', user.username);
            }
          } catch (langErr) {
            console.error('❌ Failed to save language update for user:', socket.user.userId, 'Error:', langErr.message);
          }
        }
      } else {
        console.error('Socket or user not found for entry:', entry.socketId);
      }
    }
  }

  if (ranked.length === 0) {
    io.to(roomId).emit("game-over", []);
  } else {
    io.to(roomId).emit("game-over", { ranking: ranked });
    
    // Log match history
    try {
      const matchData = createMatchData(
        ranked.map(entry => {
          const socket = io.sockets.sockets.get(entry.socketId);
          return {
            userId: socket?.user?.userId,
            username: entry.name,
            rank: entry.rank,
            timeTaken: entry.time,
            pointsGained: entry.rank === 1 ? (difficulty === 'easy' ? 10 : difficulty === 'normal' ? 20 : difficulty === 'hard' ? 30 : 40) : 
                         entry.rank === 2 ? (difficulty === 'easy' ? 3 : difficulty === 'normal' ? 7 : difficulty === 'hard' ? 10 : 20) : 0,
            pointsLost: entry.rank === 3 ? (difficulty === 'easy' ? 10 : difficulty === 'normal' ? 20 : difficulty === 'hard' ? 30 : 40) : 0,
            completed: true
          };
        }),
        'multiplayer',
        language,
        difficulty,
        {
          startTime: new Date(Date.now() - 90000), // Approximate start time
          endTime: new Date(),
          problemTitle: `${language} Debug Challenge`,
          problemDescription: `Multiplayer debugging challenge in ${language}`
        }
      );
      
      await logMatchHistory(matchData);
      console.log('📝 Match history logged for room:', roomId);
    } catch (error) {
      console.error('❌ Error logging match history:', error);
    }
  }

  console.log("🏁 Final ranking sent to room:", roomId, ranked);

  // Clean up active game tracking
  if (activeGames[roomId]) {
    delete activeGames[roomId];
  }
  // Clean up player tracking
  players.forEach(socket => {
    if (activeGamePlayers[socket.id] && activeGamePlayers[socket.id].roomId === roomId) {
      delete activeGamePlayers[socket.id];
    }
  });
}

async function startCustomMatch(players, genAI, io, language, roomCode) {
  console.log(`🎮 Starting custom match in room ${roomCode} for ${language}...`);

  let buggyCode = "loading...";
  let timeLimit = 90; // Default time limit
  let difficulty = 'normal'; // Default difficulty

  // Get room info for difficulty and time limit
  const room = customRooms[roomCode];
  if (room) {
    difficulty = room.difficulty || 'normal';

    // Set time limit based on difficulty
    if (difficulty === 'easy') timeLimit = 60;
    else if (difficulty === 'normal') timeLimit = 90;
    else if (difficulty === 'hard') timeLimit = 300;
    else if (difficulty === 'insane') timeLimit = 420;
  }

  try {
    const result = await generateBuggyCode(language, difficulty, genAI);
    buggyCode = result.code;
    var selectedProblemType = result.problemType || "DSA Problem";
    var selectedSpecificProblem = result.specificProblem || "";
  } catch (err) {
    console.error(`⚠️ Could not generate ${language} buggy code for custom room:`, err);
    buggyCode = `// Error generating code for ${language}`;
    var selectedProblemType = "DSA Problem";
    var selectedSpecificProblem = "";
  }

  const session = {
    players: [],
    finished: [],
    startTime: Date.now(),
    rankingSent: false,
  };

  // Track custom game session for reconnection
  activeGames[roomCode] = {
    players: players.map(p => p.id), // Store socket IDs
    language: language,
    difficulty: difficulty,
    startTime: Date.now(),
    buggyCode: buggyCode, // Store the code to send to reconnected players
    timeLimit: timeLimit,
    problemType: selectedProblemType,
    specificProblem: selectedSpecificProblem,
    gameType: 'custom'
  };

  players.forEach((socket, index) => {
    // Track which game this player is in for reconnection
    activeGamePlayers[socket.id] = {
      roomId: roomCode,
      gameType: 'custom'
    };

    // Get user information for enhanced display
    const user = socket.user;
    const userDoc = socket.userDoc;
    const playerName = userDoc?.username || user?.username || `Player ${index + 1}`;

    session.players.push({
      socket,
      playerId: socket.id,
      name: playerName,
      username: playerName,
      displayName: userDoc?.displayName,
      profilePicture: userDoc?.profilePicture,
      rank: userDoc?.rank || 'Bronze',
      points: userDoc?.points || 0
    });

    socket.emit("game-start", {
      playerNumber: index + 1,
      buggyCode,
      roomId: roomCode,
      timeLimit,
      problemType: selectedProblemType,
      specificProblem: selectedSpecificProblem
    });

    socket.on("player-finished", ({ timeTaken, roomId: submittedRoom }) => {
      if (submittedRoom !== roomCode) return;
      if (session.finished.find((f) => f.socketId === socket.id)) return;

      session.finished.push({
        socketId: socket.id,
        timeTaken,
        name: playerName,
        username: playerName
      });

      io.to(roomCode).emit("player-submitted", {
        name: playerName,
        time: timeTaken,
      });

      console.log(`✅ ${socket.id} completed custom game in ${timeTaken}s`);

      // If all players submitted, send ranking
      if (
        session.finished.length === session.players.length &&
        !session.rankingSent
      ) {
        sendCustomFinalRanking(io, roomCode, session.finished, language);
        session.rankingSent = true;
      }
    });
  });

  // After timeLimit, fallback send ranking if not already sent
  setTimeout(() => {
    if (!session.rankingSent) {
      sendCustomFinalRanking(io, roomCode, session.finished, language);
      session.rankingSent = true;
    }
  }, (timeLimit + 1) * 1000); // Add 1 second buffer
}

async function sendCustomFinalRanking(io, roomCode, finishedList, language) {
  let ranked = [];
  // Resolve room info once; avoid using 'room' identifier later
  const roomInfo = customRooms[roomCode];

  if (finishedList.length > 0) {
    // Check for ties (same completion time)
    const timeGroups = {};
    finishedList.forEach(entry => {
      if (!timeGroups[entry.timeTaken]) {
        timeGroups[entry.timeTaken] = [];
      }
      timeGroups[entry.timeTaken].push(entry);
    });

    // Handle ties by giving same rank to players with same time
    let currentRank = 1;
    Object.keys(timeGroups).sort((a, b) => parseFloat(a) - parseFloat(b)).forEach(time => {
      const playersWithSameTime = timeGroups[time];
      playersWithSameTime.forEach(entry => {
        ranked.push({
          rank: currentRank,
          name: entry.name,
          time: entry.timeTaken,
          socketId: entry.socketId
        });
      });
      currentRank += playersWithSameTime.length;
    });

    // Get room info for challenge mode
    const isChallengeMode = roomInfo?.challengeMode;
    
    if (isChallengeMode && roomInfo?.bets && roomInfo.bets.length > 0) {
      console.log(`🎯 Challenge mode results for room ${roomCode}:`, ranked);
      console.log(`💰 Total pot: ${roomInfo.bets.reduce((sum, bet) => sum + bet.amount, 0)} points`);
      
      // Check if there's a tie for first place
      const firstPlaceTime = ranked[0]?.time;
      const tiedPlayers = ranked.filter(entry => entry.time === firstPlaceTime);
      
      if (tiedPlayers.length > 1) {
        // Tie situation - no points awarded or deducted
        console.log(`🤝 Tie detected! No points awarded or deducted for challenge mode.`);
        
        for (const entry of ranked) {
          const socket = io.sockets.sockets.get(entry.socketId);
          if (socket && socket.user && socket.user.userId) {
            try {
              const User = require('./models/User');
              const user = await User.findById(socket.user.userId);
              
              if (user) {
                // Return bet amount to all players in case of tie
                const playerBet = roomInfo.bets.find(bet => bet.playerId === entry.socketId);
                if (playerBet) {
                  console.log(`🔄 ${user.username} gets bet refunded due to tie: +${playerBet.amount} points`);
                }
              }
            } catch (err) {
              console.error('❌ Error processing tie situation:', err);
            }
          }
        }
      } else {
        // No tie - process normal challenge mode betting
        const totalPot = roomInfo.bets.reduce((sum, bet) => sum + bet.amount, 0);
        
        for (const entry of ranked) {
          const socket = io.sockets.sockets.get(entry.socketId);
          if (socket && socket.user && socket.user.userId) {
            try {
              const User = require('./models/User');
              const user = await User.findById(socket.user.userId);
              
              if (user) {
                if (entry.rank === 1) {
                  // Winner gets all the bets
                  const pointsGained = totalPot;
                  await updateUserPointsAndRank(socket.user.userId, pointsGained, 'challenge_win', `Challenge mode win: +${pointsGained} points`);
                  
                  // Update gamesWon for challenge mode winner
                  user.gamesWon = (user.gamesWon || 0) + 1;
                  await user.save();
                  console.log(`🏆 ${user.username} won challenge mode: +${pointsGained} points, total wins: ${user.gamesWon}`);
                } else {
                  // Losers lose their bet amount
                  const playerBet = roomInfo.bets.find(bet => bet.playerId === entry.socketId);
                  if (playerBet) {
                    const pointsLost = -playerBet.amount;
                    await updateUserPointsAndRank(socket.user.userId, pointsLost, 'challenge_loss', `Challenge mode loss: ${pointsLost} points`);
                    console.log(`💸 ${user.username} lost challenge mode: ${pointsLost} points`);
                  }
                }
              }
            } catch (err) {
              console.error('❌ Error processing challenge mode points:', err);
            }
          }
        }
      }
    } else {
      // Regular custom game - no points awarded
      console.log(`🏆 Custom game results for room ${roomCode}:`, ranked);
    }
  }

  if (ranked.length === 0) {
    io.to(roomCode).emit("game-over", []);
  } else {
    const isTie = ranked.length > 0 && ranked.filter(entry => entry.time === ranked[0].time).length > 1;
    const challengeMode = roomInfo?.challengeMode || false;
    const totalPot = challengeMode ? roomInfo.bets.reduce((sum, bet) => sum + bet.amount, 0) : 0;
    io.to(roomCode).emit("game-over", { 
      ranking: ranked,
      challengeMode,
      totalPot,
      isTie
    });
    
    // Log match history for custom games
    try {
      const matchType = roomInfo?.challengeMode ? 'challenge' : 'multiplayer';
      const totalPot = roomInfo?.challengeMode ? roomInfo.bets.reduce((sum, bet) => sum + bet.amount, 0) : 0;
      const isTie = ranked.length > 0 && ranked.filter(entry => entry.time === ranked[0].time).length > 1;
      
      const matchData = createMatchData(
        ranked.map(entry => {
          const socket = io.sockets.sockets.get(entry.socketId);
          const playerBet = room?.bets?.find(bet => bet.playerId === entry.socketId);
          
          let pointsGained = 0;
          let pointsLost = 0;
          
          if (room?.challengeMode) {
            if (isTie) {
              // Tie - no points gained or lost
              pointsGained = 0;
              pointsLost = 0;
            } else if (entry.rank === 1) {
              // Winner gets all the bets
              pointsGained = totalPot;
              pointsLost = 0;
            } else {
              // Losers lose their bet
              pointsLost = playerBet ? playerBet.amount : 0;
              pointsGained = 0;
            }
          }
          
          return {
            userId: socket?.user?.userId,
            username: entry.name,
            rank: entry.rank,
            timeTaken: entry.time,
            pointsGained,
            pointsLost,
            completed: true
          };
        }),
        matchType,
        language,
        roomInfo?.difficulty || 'normal',
        {
          roomCode,
          challengeMode: roomInfo?.challengeMode || false,
          totalPot,
          isTie,
          startTime: new Date(Date.now() - 90000), // Approximate start time
          endTime: new Date(),
          problemTitle: `${language} Custom Challenge`,
          problemDescription: `Custom ${matchType} debugging challenge in ${language}`
        }
      );
      
      await logMatchHistory(matchData);
      console.log('📝 Custom match history logged for room:', roomCode);
    } catch (error) {
      console.error('❌ Error logging custom match history:', error);
    }
  }

  // Clean up the custom room after game
  delete customRooms[roomCode];

  // Clean up active game tracking
  if (activeGames[roomCode]) {
    delete activeGames[roomCode];
  }
  // Clean up player tracking
  players.forEach(socket => {
    if (activeGamePlayers[socket.id] && activeGamePlayers[socket.id].roomId === roomCode) {
      delete activeGamePlayers[socket.id];
    }
  });

  console.log(`🗑️ Custom room ${roomCode} cleaned up after game`);
}

async function startCustomMarathon(players, genAI, io, language, roomCode, rounds, timeLimit, problems) {
  console.log(`🏁 Starting custom marathon for ${players.length} players in ${language} (${rounds} rounds, ${timeLimit} minutes)`);

  try {
    // Use pre-generated problems instead of generating them again
    if (!problems || problems.length === 0) {
      throw new Error('No problems provided for marathon');
    }
    
    // Create marathon session
    const sessionId = `marathon-${roomCode}-${Date.now()}`;
    const marathonSession = {
      sessionId,
      roomCode,
      players: players.map((p, i) => {
        const user = p.user;
        const userDoc = p.userDoc;
        
        const playerData = {
          socket: p, 
          playerId: p.id, 
          name: userDoc?.username || user?.username || `Player ${i + 1}`,
          username: userDoc?.username || user?.username || `Player ${i + 1}`,
          displayName: userDoc?.displayName,
          profilePicture: userDoc?.profilePicture,
          rank: userDoc?.rank || 'Bronze',
          points: userDoc?.points || 0,
          currentRound: 1,
          finishedRounds: [],
          totalTime: 0,
          startTime: Date.now(), // Track individual start time for each player
          userId: user?.userId || user?.id // CRITICAL: Store userId for round completion lookup
        };
        
        console.log(`[CustomMarathon] Created player data:`, {
          name: playerData.name,
          userId: playerData.userId,
          socketId: playerData.playerId
        });
        
        return playerData;
      }),
      problems: problems,
      totalRounds: rounds,
      timeLimit: timeLimit * 60 * 1000, // Convert to milliseconds
      startTime: Date.now(),
      status: 'in_progress'
    };

    // Persist the session on the room so other handlers (e.g., rankings requests) can access it
    if (customMarathonRooms[roomCode]) {
      customMarathonRooms[roomCode].marathonSession = marathonSession;
      console.log(`[CustomMarathon] Stored marathon session for room ${roomCode}:`, {
        sessionId: marathonSession.sessionId,
        totalRounds: marathonSession.totalRounds,
        players: marathonSession.players.length
      });
    }

    // Join all players to the marathon room
    players.forEach((socket, index) => {
      socket.join(sessionId);
      socket.emit('custom-marathon-game-start', {
        sessionId,
        playerNumber: index + 1,
        problems: problems,
        totalRounds: rounds,
        timeLimit: timeLimit * 60 * 1000,
        language: language
      });
    });

    // Show initial rankings after a short delay to let players join
    // (Removed here; startCustomMarathon will handle initial rankings using its own sessionId)

    // Difficulty-based per-round time limits
    const ROUND_TIME_BY_DIFFICULTY = { easy: 60, normal: 90, hard: 120 };

    // Per-round orchestration state (also persisted to room for reconnects)
    const state = {
      currentRound: 0,
      roundStartTimeMs: 0,
      roundTimer: null,
      currentDifficulty: 'normal'
    };
    // Persist minimal state to room for external access (e.g., join handler)
    if (customMarathonRooms[roomCode]) {
      customMarathonRooms[roomCode].marathonState = {
        currentRound: state.currentRound,
        roundStartTimeMs: state.roundStartTimeMs,
        currentDifficulty: state.currentDifficulty,
        sessionId
      };
    }

    function getRoundMeta(roundNumber) {
      const meta = marathonSession.problems.find(p => p.round === roundNumber) || {};
      const difficulty = (meta.difficulty || 'normal').toLowerCase();
      const timeLimitSec = ROUND_TIME_BY_DIFFICULTY[difficulty] || 90;
      return { difficulty, timeLimitSec, problem: meta.problem };
    }

    function startRound(roundNumber) {
      state.currentRound = roundNumber;
      const { difficulty, timeLimitSec, problem } = getRoundMeta(roundNumber);
      state.roundStartTimeMs = Date.now();
      state.currentDifficulty = difficulty;
      // Keep room-level snapshot in sync for reconnect calculations
      if (customMarathonRooms[roomCode]) {
        customMarathonRooms[roomCode].marathonState = {
          currentRound: state.currentRound,
          roundStartTimeMs: state.roundStartTimeMs,
          currentDifficulty: state.currentDifficulty,
          sessionId
        };
      }

      console.log(`[CustomMarathon] ▶️ Round ${roundNumber} started for session ${sessionId} (${difficulty}, ${timeLimitSec}s)`);
      io.to(sessionId).emit('marathon-round-start', {
        sessionId,
        round: roundNumber,
        difficulty,
        problem,
        problemType: roundMeta.problemType || 'DSA Problem',
        specificProblem: roundMeta.specificProblem || '',
        timeLimit: timeLimitSec
      });

      if (state.roundTimer) clearTimeout(state.roundTimer);
      state.roundTimer = setTimeout(() => endRound(roundNumber, timeLimitSec), timeLimitSec * 1000);
      console.log(`[CustomMarathon] ⏰ Round ${roundNumber} timer set for ${timeLimitSec}s`);
    }

    function endRound(roundNumber, timeLimitSec) {
      console.log(`[CustomMarathon] 🔚 Round ${roundNumber} ended. Applying penalties where needed...`);

      // Apply penalty equal to full round time for players who did not submit this round
      marathonSession.players.forEach(p => {
        const finished = p.finishedRounds || [];
        if (!finished.includes(roundNumber)) {
          p.totalTime += timeLimitSec;
          p.currentRound = Math.min(roundNumber + 1, rounds);
          if (!p.penalties) p.penalties = {};
          p.penalties[roundNumber] = timeLimitSec;
          console.log(`[CustomMarathon] ⏰ Penalty applied to ${p.name}: +${timeLimitSec}s (Total: ${p.totalTime}s)`);
        } else {
          // Already counted on submission via 'marathon-round-complete'
          console.log(`[CustomMarathon] ✅ ${p.name} completed round ${roundNumber}, no penalty`);
        }
      });

      // Emit round end and refresh live rankings
      io.to(sessionId).emit('marathon-round-end', { round: roundNumber });
      showCurrentRankings(marathonSession, io);

      if (roundNumber < rounds) {
        // Start next round after a 4s gap to process rankings/penalties
        setTimeout(() => startRound(roundNumber + 1), 4000);
      } else {
        // Finish marathon
        console.log(`[CustomMarathon] 🏁 All ${rounds} rounds completed for session ${sessionId}`);
        // Compute final rankings identical to timeout/early-complete scheme
        const finalRankings = marathonSession.players
          .map(player => ({
            name: player.name,
            username: player.username,
            completedRounds: player.finishedRounds.length,
            currentRound: player.currentRound,
            totalTime: player.totalTime || 0,
            socketId: player.socket?.id || 'disconnected',
            userId: player.socket?.user?.userId || null
          }))
          .sort((a, b) => {
            if (a.completedRounds !== b.completedRounds) return b.completedRounds - a.completedRounds;
            return a.totalTime - b.totalTime;
          })
          .map((player, index) => ({ ...player, rank: index + 1, displayRank: `#${index + 1}` }));

        io.to(sessionId).emit('custom-marathon-final-results', {
          rankings: finalRankings,
          winner: null,
          winnerUserId: null,
          challengeMode: false,
          totalPot: 0,
          resultMessage: '🏁 Marathon completed! Final rankings:',
          timeout: false,
          pointsAwarded: 0,
          totalRounds: rounds,
          allPlayersCompleted: false,
          earlyCompletion: false
        });

        // Log match history for custom marathon
        try {
          const matchData = createMatchData(
            finalRankings.map(player => ({
              userId: player.userId,
              username: player.name,
              rank: player.rank,
              timeTaken: player.totalTime,
              pointsGained: 0, // Marathon mode doesn't award points
              pointsLost: 0,
              completed: player.completedRounds >= rounds
            })),
            'custom_marathon',
            currentLanguage,
            {
              problemTitle: `${currentLanguage} Custom Marathon`,
              problemDescription: `Custom marathon debugging challenge in ${currentLanguage}`
            }
          );
          
          logMatchHistory(matchData).catch(error => {
            console.error('❌ Error logging custom marathon match history:', error);
          });
          console.log('📝 Custom marathon match history logged for session:', sessionId);
        } catch (error) {
          console.error('❌ Error logging custom marathon match history:', error);
        }

        // Cleanup room
        delete customMarathonRooms[roomCode];
        console.log(`🗑️ Custom marathon room ${roomCode} cleaned up after completion`);
      }
    }

    // Kick off synchronized per-round flow (replicates debug marathon architecture)
    startRound(1);
    const checkMarathonCompletion = () => {
      // CRITICAL FIX: Get the latest marathon session from the room
      let currentMarathonSession = marathonSession;
      if (customMarathonRooms[roomCode] && customMarathonRooms[roomCode].marathonSession) {
        currentMarathonSession = customMarathonRooms[roomCode].marathonSession;
        console.log(`[CustomMarathon] Using updated marathon session for completion check`);
      }
      
      const completedPlayers = currentMarathonSession.players.filter(p => p.finishedRounds.length === rounds);
      console.log(`[CustomMarathon] Checking completion: ${completedPlayers.length}/${currentMarathonSession.players.length} players completed all ${rounds} rounds`);
      
      if (completedPlayers.length === currentMarathonSession.players.length) {
        // All players completed all rounds - end marathon early and show rankings popup immediately
        console.log(`[CustomMarathon] 🎉 ALL PLAYERS COMPLETED ALL ROUNDS! Ending marathon early.`);
        
        // Calculate final rankings for early completion
        const playerRankings = currentMarathonSession.players
          .map(player => ({
            name: player.name,
            username: player.username,
            completedRounds: player.finishedRounds.length,
            currentRound: player.currentRound,
            totalTime: player.totalTime || 0,
            socketId: player.socket?.id || 'disconnected',
            userId: player.socket?.user?.userId || null
          }))
          .sort((a, b) => {
            // Primary sort: by completed rounds (higher is better)
            if (a.completedRounds !== b.completedRounds) {
              return b.completedRounds - a.completedRounds;
            }
            // Secondary sort: by total time (lower is better) for same round count
            return a.totalTime - b.totalTime;
          });

        // Assign simple sequential ranks to ALL players
        const finalRankings = playerRankings.map((player, index) => ({
          ...player,
          rank: index + 1,
          displayRank: `#${index + 1}`
        }));

        console.log(`[CustomMarathon] 🏆 Early completion rankings:`, finalRankings.map(r => `${r.rank}. ${r.name} (${r.completedRounds}/${rounds} rounds, ${r.totalTime}s)`));

        // Send final results with early completion flag
        io.to(sessionId).emit('custom-marathon-final-results', {
          rankings: finalRankings,
          winner: null, // No winner
          winnerUserId: null,
          challengeMode: false,
          totalPot: 0,
          resultMessage: '🎉 All players completed all rounds! Marathon ended early:',
          timeout: false,
          pointsAwarded: 0,
          totalRounds: rounds,
          allPlayersCompleted: true,
          earlyCompletion: true
        });

        // Log match history for custom marathon (early completion)
        try {
          const matchData = createMatchData(
            finalRankings.map(player => ({
              userId: player.userId,
              username: player.name,
              rank: player.rank,
              timeTaken: player.totalTime,
              pointsGained: 0, // Marathon mode doesn't award points
              pointsLost: 0,
              completed: true // All players completed in early completion
            })),
            'custom_marathon',
            currentLanguage,
            {
              problemTitle: `${currentLanguage} Custom Marathon (Early Completion)`,
              problemDescription: `Custom marathon debugging challenge in ${currentLanguage} - All players completed early`
            }
          );
          
          logMatchHistory(matchData).catch(error => {
            console.error('❌ Error logging custom marathon (early completion) match history:', error);
          });
          console.log('📝 Custom marathon (early completion) match history logged for session:', sessionId);
        } catch (error) {
          console.error('❌ Error logging custom marathon (early completion) match history:', error);
        }

        // Clean up the room
        delete customMarathonRooms[roomCode];
        console.log(`🗑️ Custom marathon room ${roomCode} cleaned up after early completion`);
      } else if (completedPlayers.length > 0) {
        console.log(`[CustomMarathon] ${completedPlayers.length} players completed all rounds, but others still playing. Waiting for timer...`);
        // Show current rankings to show completion status
        showCurrentRankings(currentMarathonSession, io);
      }
    };

    // Function to show current rankings during the marathon
    const showCurrentRankings = (marathonSession, io) => {
      const sessionId = marathonSession.sessionId;
      
      // CRITICAL FIX: Get the latest marathon session from the room
      let currentMarathonSession = marathonSession;
      if (customMarathonRooms[roomCode] && customMarathonRooms[roomCode].marathonSession) {
        currentMarathonSession = customMarathonRooms[roomCode].marathonSession;
        console.log(`[CustomMarathon] Using updated marathon session for rankings`);
      }
      
      // Calculate current rankings - include ALL players
      const playerRankings = currentMarathonSession.players
        .map(player => ({
          name: player.name,
          username: player.username,
          completedRounds: player.finishedRounds.length,
          currentRound: player.currentRound,
          totalTime: player.totalTime || 0,
          roundTimes: player.roundTimes || {},
          penalties: player.penalties || {},
          socketId: player.socket?.id || 'disconnected',
          userId: player.socket?.user?.userId || null
        }))
        .sort((a, b) => {
          // Primary sort: by completed rounds (higher is better)
          if (a.completedRounds !== b.completedRounds) {
            return b.completedRounds - a.completedRounds;
          }
          // Secondary sort: by total time (lower is better) for same round count
          return a.totalTime - b.totalTime;
        });

      // Assign simple sequential ranks to ALL players
      const currentRankings = playerRankings.map((player, index) => ({
        ...player,
        rank: index + 1,
        displayRank: `#${index + 1}`
      }));

      console.log(`[CustomMarathon] Sending current rankings for session ${sessionId}:`, currentRankings);

      // Send current rankings to all players
      io.to(sessionId).emit('custom-marathon-current-rankings', {
        rankings: currentRankings,
        isFinal: false,
        message: 'Current standings in custom marathon:',
        totalRounds: currentMarathonSession.totalRounds || 5
      });
    };

    // Set up round completion handlers (removed - now handled globally)
    // Rankings requests are handled globally in the main socket connection handler

    // Remove global marathon timeout; per-round orchestration governs flow like debug mode

    // Show periodic rankings updates every 30 seconds for custom marathon
    const rankingsInterval = setInterval(() => {
      const session = io.sockets.adapter.rooms.get(sessionId);
      if (session && session.size > 0 && marathonSession.status === 'in_progress') {
        console.log(`[CustomMarathon] Sending periodic rankings update for session ${sessionId}`);
        // CRITICAL FIX: Get the latest marathon session for periodic rankings
        let currentMarathonSession = marathonSession;
        if (customMarathonRooms[roomCode] && customMarathonRooms[roomCode].marathonSession) {
          currentMarathonSession = customMarathonRooms[roomCode].marathonSession;
          console.log(`[CustomMarathon] Using updated marathon session for periodic rankings`);
        }
        showCurrentRankings(currentMarathonSession, io);
      } else {
        clearInterval(rankingsInterval);
        console.log(`[CustomMarathon] Stopping periodic rankings updates for session ${sessionId}`);
      }
    }, 30000); // Every 30 seconds

  } catch (err) {
    console.error('❌ Error starting custom marathon:', err);
    players.forEach(socket => {
      socket.emit('custom-marathon-error', { message: 'Failed to start marathon' });
    });
  }
}

async function endCustomMarathon(marathonSession, winner, io, earlyCompletion = false) {
  const sessionId = marathonSession.sessionId;
  const roomCode = marathonSession.roomCode;
  
  console.log(`🏁 Ending custom marathon session ${sessionId}${earlyCompletion ? ' (early completion)' : ''}`);
  
  // Calculate final rankings - SIMPLE APPROACH: just sort by completion time
  const playerRankings = marathonSession.players
    .map(player => ({
      name: player.name,
      username: player.username,
      completedRounds: player.finishedRounds.length,
      currentRound: player.currentRound,
      totalTime: player.totalTime || 0,
      socketId: player.socket?.id || 'disconnected',
      userId: player.socket?.user?.userId || null
    }))
    .sort((a, b) => {
      // Primary sort: by completed rounds (higher is better)
      if (a.completedRounds !== b.completedRounds) {
        return b.completedRounds - a.completedRounds;
      }
      // Secondary sort: by total time (lower is better) for same round count
      return a.totalTime - b.totalTime;
    });

  // Check if no players completed any rounds
  if (playerRankings.length === 0 || playerRankings.every(p => p.completedRounds === 0)) {
    console.log(`[CustomMarathon] 🏁 No players completed any rounds in session ${sessionId}`);
    
    io.to(sessionId).emit('custom-marathon-final-results', {
      rankings: [],
      winner: null,
      winnerUserId: null,
      challengeMode: false,
      totalPot: 0,
      resultMessage: '🏁 Marathon ended! No players completed any rounds.',
      timeout: false,
      pointsAwarded: 0,
      totalRounds: marathonSession.totalRounds || 5,
      allPlayersCompleted: false,
      earlyCompletion: false,
      noCompletions: true
    });

    // Log match history for custom marathon (no completions)
    try {
      const matchData = createMatchData(
        marathonSession.players.map(player => ({
          userId: player.userId,
          username: player.name,
          rank: 0, // No ranking since no one completed
          timeTaken: player.totalTime || 0,
          pointsGained: 0,
          pointsLost: 0,
          completed: false
        })),
        'custom_marathon',
        marathonSession.currentLanguage || 'python',
        {
          problemTitle: `${marathonSession.currentLanguage || 'python'} Custom Marathon (No Completions)`,
          problemDescription: `Custom marathon debugging challenge in ${marathonSession.currentLanguage || 'python'} - No players completed any rounds`
        }
      );
      
      logMatchHistory(matchData).catch(error => {
        console.error('❌ Error logging custom marathon (no completions) match history:', error);
      });
      console.log('📝 Custom marathon (no completions) match history logged for session:', sessionId);
    } catch (error) {
      console.error('❌ Error logging custom marathon (no completions) match history:', error);
    }
    
    // Clean up
    delete customMarathonRooms[roomCode];
    console.log(`🗑️ Custom marathon room ${roomCode} cleaned up with no completions`);
    return;
  }

  // Assign simple sequential ranks to ALL players
  const finalRankings = playerRankings.map((player, index) => ({
    ...player,
    rank: index + 1,
    displayRank: `#${index + 1}`
  }));

  console.log(`[CustomMarathon] 🏆 Final rankings:`, finalRankings.map(r => `${r.rank}. ${r.name} (${r.completedRounds}/${marathonSession.totalRounds || 5} rounds, ${r.totalTime}s)`));

  // Determine result message based on completion type
  let resultMessage;
  if (earlyCompletion) {
    resultMessage = '🎉 All players completed all rounds! Marathon ended early:';
  } else if (marathonSession.status === 'timeout') {
    resultMessage = '⏰ Time ran out! Final rankings based on completed rounds:';
  } else {
    resultMessage = '🏁 Marathon ended! Final rankings:';
  }

  // Send final results with NO winner announcement
  io.to(sessionId).emit('custom-marathon-final-results', {
    rankings: finalRankings,
    winner: null, // No winner
    winnerUserId: null,
    challengeMode: false,
    totalPot: 0,
    resultMessage: resultMessage,
    timeout: marathonSession.status === 'timeout',
    pointsAwarded: 0,
    totalRounds: marathonSession.totalRounds || 5,
    allPlayersCompleted: earlyCompletion,
    earlyCompletion: earlyCompletion
  });

  // Log match history for custom marathon (timeout)
  try {
    const matchData = createMatchData(
      finalRankings.map(player => ({
        userId: player.userId,
        username: player.name,
        rank: player.rank,
        timeTaken: player.totalTime,
        pointsGained: 0, // Marathon mode doesn't award points
        pointsLost: 0,
        completed: player.completedRounds >= (marathonSession.totalRounds || 5)
      })),
      'custom_marathon',
      marathonSession.currentLanguage || 'python',
      {
        problemTitle: `${marathonSession.currentLanguage || 'python'} Custom Marathon (Timeout)`,
        problemDescription: `Custom marathon debugging challenge in ${marathonSession.currentLanguage || 'python'} - Timeout reached`
      }
    );
    
    logMatchHistory(matchData).catch(error => {
      console.error('❌ Error logging custom marathon (timeout) match history:', error);
    });
    console.log('📝 Custom marathon (timeout) match history logged for session:', sessionId);
  } catch (error) {
    console.error('❌ Error logging custom marathon (timeout) match history:', error);
  }

  // Clean up
  delete customMarathonRooms[roomCode];
  console.log(`🗑️ Custom marathon room ${roomCode} cleaned up`);
}

module.exports = { setupMultiplayer };